OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/scheduler/base/task_queue_manager.h" | 5 #include "components/scheduler/base/task_queue_manager.h" |
6 | 6 |
7 #include "base/location.h" | 7 #include "base/location.h" |
8 #include "base/run_loop.h" | 8 #include "base/run_loop.h" |
9 #include "base/single_thread_task_runner.h" | 9 #include "base/single_thread_task_runner.h" |
10 #include "base/test/simple_test_tick_clock.h" | 10 #include "base/test/simple_test_tick_clock.h" |
(...skipping 198 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
209 | 209 |
210 message_loop_->RunUntilIdle(); | 210 message_loop_->RunUntilIdle(); |
211 // Note we expect task 3 to run last because it's non-nestable. | 211 // Note we expect task 3 to run last because it's non-nestable. |
212 EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3)); | 212 EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3)); |
213 } | 213 } |
214 | 214 |
215 TEST_F(TaskQueueManagerTest, QueuePolling) { | 215 TEST_F(TaskQueueManagerTest, QueuePolling) { |
216 Initialize(1u); | 216 Initialize(1u); |
217 | 217 |
218 std::vector<int> run_order; | 218 std::vector<int> run_order; |
219 EXPECT_TRUE(runners_[0]->IsQueueEmpty()); | 219 EXPECT_FALSE(runners_[0]->HasPendingImmediateTask()); |
220 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 220 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
221 EXPECT_FALSE(runners_[0]->IsQueueEmpty()); | 221 EXPECT_TRUE(runners_[0]->HasPendingImmediateTask()); |
222 | 222 |
223 test_task_runner_->RunUntilIdle(); | 223 test_task_runner_->RunUntilIdle(); |
224 EXPECT_TRUE(runners_[0]->IsQueueEmpty()); | 224 EXPECT_FALSE(runners_[0]->HasPendingImmediateTask()); |
225 } | 225 } |
226 | 226 |
227 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) { | 227 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) { |
228 Initialize(1u); | 228 Initialize(1u); |
229 | 229 |
230 std::vector<int> run_order; | 230 std::vector<int> run_order; |
231 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 231 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
232 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 232 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
233 delay); | 233 delay); |
234 EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime()); | 234 EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime()); |
235 EXPECT_TRUE(runners_[0]->IsQueueEmpty()); | 235 EXPECT_EQ(TaskQueue::QueueState::NO_IMMEDIATE_WORK, |
| 236 runners_[0]->GetQueueState()); |
236 EXPECT_TRUE(run_order.empty()); | 237 EXPECT_TRUE(run_order.empty()); |
237 | 238 |
238 // The task doesn't run before the delay has completed. | 239 // The task doesn't run before the delay has completed. |
239 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9)); | 240 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9)); |
240 EXPECT_TRUE(run_order.empty()); | 241 EXPECT_TRUE(run_order.empty()); |
241 | 242 |
242 // After the delay has completed, the task runs normally. | 243 // After the delay has completed, the task runs normally. |
243 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | 244 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); |
244 EXPECT_THAT(run_order, ElementsAre(1)); | 245 EXPECT_THAT(run_order, ElementsAre(1)); |
| 246 EXPECT_EQ(TaskQueue::QueueState::EMPTY, runners_[0]->GetQueueState()); |
245 } | 247 } |
246 | 248 |
247 bool MessageLoopTaskCounter(size_t* count) { | 249 bool MessageLoopTaskCounter(size_t* count) { |
248 *count = *count + 1; | 250 *count = *count + 1; |
249 return true; | 251 return true; |
250 } | 252 } |
251 | 253 |
252 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { | 254 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { |
253 Initialize(1u); | 255 Initialize(1u); |
254 | 256 |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
368 Initialize(1u); | 370 Initialize(1u); |
369 runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL); | 371 runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL); |
370 | 372 |
371 std::vector<int> run_order; | 373 std::vector<int> run_order; |
372 // Posting a task when pumping is disabled doesn't result in work getting | 374 // Posting a task when pumping is disabled doesn't result in work getting |
373 // posted. | 375 // posted. |
374 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 376 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
375 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); | 377 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); |
376 | 378 |
377 // However polling still works. | 379 // However polling still works. |
378 EXPECT_FALSE(runners_[0]->IsQueueEmpty()); | 380 EXPECT_TRUE(runners_[0]->HasPendingImmediateTask()); |
379 | 381 |
380 // After pumping the task runs normally. | 382 // After pumping the task runs normally. |
381 runners_[0]->PumpQueue(); | 383 runners_[0]->PumpQueue(); |
382 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); | 384 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); |
383 test_task_runner_->RunUntilIdle(); | 385 test_task_runner_->RunUntilIdle(); |
384 EXPECT_THAT(run_order, ElementsAre(1)); | 386 EXPECT_THAT(run_order, ElementsAre(1)); |
385 } | 387 } |
386 | 388 |
387 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) { | 389 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) { |
388 Initialize(1u); | 390 Initialize(1u); |
(...skipping 607 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
996 test_task_runner_->RunUntilIdle(); | 998 test_task_runner_->RunUntilIdle(); |
997 EXPECT_TRUE(manager_->GetAndClearSystemIsQuiescentBit()); | 999 EXPECT_TRUE(manager_->GetAndClearSystemIsQuiescentBit()); |
998 | 1000 |
999 queue0->PostTask(FROM_HERE, base::Bind(&NopTask)); | 1001 queue0->PostTask(FROM_HERE, base::Bind(&NopTask)); |
1000 queue1->PostTask(FROM_HERE, base::Bind(&NopTask)); | 1002 queue1->PostTask(FROM_HERE, base::Bind(&NopTask)); |
1001 test_task_runner_->RunUntilIdle(); | 1003 test_task_runner_->RunUntilIdle(); |
1002 EXPECT_FALSE(manager_->GetAndClearSystemIsQuiescentBit()); | 1004 EXPECT_FALSE(manager_->GetAndClearSystemIsQuiescentBit()); |
1003 EXPECT_TRUE(manager_->GetAndClearSystemIsQuiescentBit()); | 1005 EXPECT_TRUE(manager_->GetAndClearSystemIsQuiescentBit()); |
1004 } | 1006 } |
1005 | 1007 |
1006 TEST_F(TaskQueueManagerTest, IsQueueEmpty) { | 1008 TEST_F(TaskQueueManagerTest, HasPendingImmediateTask) { |
1007 Initialize(2u); | 1009 Initialize(2u); |
1008 internal::TaskQueueImpl* queue0 = runners_[0].get(); | 1010 internal::TaskQueueImpl* queue0 = runners_[0].get(); |
1009 internal::TaskQueueImpl* queue1 = runners_[1].get(); | 1011 internal::TaskQueueImpl* queue1 = runners_[1].get(); |
1010 queue0->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO); | 1012 queue0->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO); |
1011 queue1->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL); | 1013 queue1->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL); |
1012 | 1014 |
1013 EXPECT_TRUE(queue0->IsQueueEmpty()); | 1015 EXPECT_FALSE(queue0->HasPendingImmediateTask()); |
1014 EXPECT_TRUE(queue1->IsQueueEmpty()); | 1016 EXPECT_FALSE(queue1->HasPendingImmediateTask()); |
1015 | 1017 |
1016 queue0->PostTask(FROM_HERE, base::Bind(NullTask)); | 1018 queue0->PostTask(FROM_HERE, base::Bind(NullTask)); |
1017 queue1->PostTask(FROM_HERE, base::Bind(NullTask)); | 1019 queue1->PostTask(FROM_HERE, base::Bind(NullTask)); |
1018 EXPECT_FALSE(queue0->IsQueueEmpty()); | 1020 EXPECT_TRUE(queue0->HasPendingImmediateTask()); |
1019 EXPECT_FALSE(queue1->IsQueueEmpty()); | 1021 EXPECT_TRUE(queue1->HasPendingImmediateTask()); |
1020 | 1022 |
1021 test_task_runner_->RunUntilIdle(); | 1023 test_task_runner_->RunUntilIdle(); |
1022 EXPECT_TRUE(queue0->IsQueueEmpty()); | 1024 EXPECT_FALSE(queue0->HasPendingImmediateTask()); |
1023 EXPECT_FALSE(queue1->IsQueueEmpty()); | 1025 EXPECT_TRUE(queue1->HasPendingImmediateTask()); |
1024 | 1026 |
1025 queue1->PumpQueue(); | 1027 queue1->PumpQueue(); |
1026 EXPECT_TRUE(queue0->IsQueueEmpty()); | 1028 EXPECT_FALSE(queue0->HasPendingImmediateTask()); |
1027 EXPECT_FALSE(queue1->IsQueueEmpty()); | 1029 EXPECT_TRUE(queue1->HasPendingImmediateTask()); |
1028 | 1030 |
1029 test_task_runner_->RunUntilIdle(); | 1031 test_task_runner_->RunUntilIdle(); |
1030 EXPECT_TRUE(queue0->IsQueueEmpty()); | 1032 EXPECT_FALSE(queue0->HasPendingImmediateTask()); |
1031 EXPECT_TRUE(queue1->IsQueueEmpty()); | 1033 EXPECT_FALSE(queue1->HasPendingImmediateTask()); |
1032 } | 1034 } |
1033 | 1035 |
1034 TEST_F(TaskQueueManagerTest, GetQueueState) { | 1036 TEST_F(TaskQueueManagerTest, GetQueueState) { |
1035 Initialize(2u); | 1037 Initialize(2u); |
1036 internal::TaskQueueImpl* queue0 = runners_[0].get(); | 1038 internal::TaskQueueImpl* queue0 = runners_[0].get(); |
1037 internal::TaskQueueImpl* queue1 = runners_[1].get(); | 1039 internal::TaskQueueImpl* queue1 = runners_[1].get(); |
1038 queue0->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO); | 1040 queue0->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO); |
1039 queue1->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL); | 1041 queue1->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL); |
1040 | 1042 |
1041 EXPECT_EQ(TaskQueue::QueueState::EMPTY, queue0->GetQueueState()); | 1043 EXPECT_EQ(TaskQueue::QueueState::EMPTY, queue0->GetQueueState()); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1095 delay1); | 1097 delay1); |
1096 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1098 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1097 delay2); | 1099 delay2); |
1098 | 1100 |
1099 now_src_->Advance(delay1 * 2); | 1101 now_src_->Advance(delay1 * 2); |
1100 test_task_runner_->RunUntilIdle(); | 1102 test_task_runner_->RunUntilIdle(); |
1101 | 1103 |
1102 EXPECT_THAT(run_order, ElementsAre(2, 1)); | 1104 EXPECT_THAT(run_order, ElementsAre(2, 1)); |
1103 } | 1105 } |
1104 | 1106 |
1105 TEST_F(TaskQueueManagerTest, DelayedTaskWithAbsoluteRunTime) { | |
1106 Initialize(1u); | |
1107 | |
1108 // One task in the past, two with the exact same run time and one in the | |
1109 // future. | |
1110 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); | |
1111 base::TimeTicks runTime1 = now_src_->NowTicks() - delay; | |
1112 base::TimeTicks runTime2 = now_src_->NowTicks(); | |
1113 base::TimeTicks runTime3 = now_src_->NowTicks(); | |
1114 base::TimeTicks runTime4 = now_src_->NowTicks() + delay; | |
1115 | |
1116 std::vector<int> run_order; | |
1117 runners_[0]->PostDelayedTaskAt( | |
1118 FROM_HERE, base::Bind(&TestTask, 1, &run_order), runTime1); | |
1119 runners_[0]->PostDelayedTaskAt( | |
1120 FROM_HERE, base::Bind(&TestTask, 2, &run_order), runTime2); | |
1121 runners_[0]->PostDelayedTaskAt( | |
1122 FROM_HERE, base::Bind(&TestTask, 3, &run_order), runTime3); | |
1123 runners_[0]->PostDelayedTaskAt( | |
1124 FROM_HERE, base::Bind(&TestTask, 4, &run_order), runTime4); | |
1125 | |
1126 now_src_->Advance(2 * delay); | |
1127 test_task_runner_->RunUntilIdle(); | |
1128 | |
1129 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4)); | |
1130 } | |
1131 | |
1132 void CheckIsNested(bool* is_nested) { | 1107 void CheckIsNested(bool* is_nested) { |
1133 *is_nested = base::MessageLoop::current()->IsNested(); | 1108 *is_nested = base::MessageLoop::current()->IsNested(); |
1134 } | 1109 } |
1135 | 1110 |
1136 void PostAndQuitFromNestedRunloop(base::RunLoop* run_loop, | 1111 void PostAndQuitFromNestedRunloop(base::RunLoop* run_loop, |
1137 base::SingleThreadTaskRunner* runner, | 1112 base::SingleThreadTaskRunner* runner, |
1138 bool* was_nested) { | 1113 bool* was_nested) { |
1139 base::MessageLoop::ScopedNestableTaskAllower allow( | 1114 base::MessageLoop::ScopedNestableTaskAllower allow( |
1140 base::MessageLoop::current()); | 1115 base::MessageLoop::current()); |
1141 runner->PostTask(FROM_HERE, run_loop->QuitClosure()); | 1116 runner->PostTask(FROM_HERE, run_loop->QuitClosure()); |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1316 | 1291 |
1317 scoped_refptr<internal::TaskQueueImpl> task_queue = | 1292 scoped_refptr<internal::TaskQueueImpl> task_queue = |
1318 manager_->NewTaskQueue(TaskQueue::Spec("test_queue")); | 1293 manager_->NewTaskQueue(TaskQueue::Spec("test_queue")); |
1319 | 1294 |
1320 EXPECT_CALL(observer, OnUnregisterTaskQueue(_)).Times(1); | 1295 EXPECT_CALL(observer, OnUnregisterTaskQueue(_)).Times(1); |
1321 task_queue->UnregisterTaskQueue(); | 1296 task_queue->UnregisterTaskQueue(); |
1322 | 1297 |
1323 manager_->SetObserver(nullptr); | 1298 manager_->SetObserver(nullptr); |
1324 } | 1299 } |
1325 | 1300 |
1326 TEST_F(TaskQueueManagerTest, ScheduleDelayedWorkIsNotReEntrant) { | |
1327 Initialize(1u); | |
1328 | |
1329 // Post two tasks into the past. The second one used to trigger a deadlock | |
1330 // because it tried to re-entrantly wake the first task in the same queue. | |
1331 runners_[0]->PostDelayedTaskAt( | |
1332 FROM_HERE, base::Bind(&NullTask), | |
1333 base::TimeTicks() + base::TimeDelta::FromMicroseconds(100)); | |
1334 runners_[0]->PostDelayedTaskAt( | |
1335 FROM_HERE, base::Bind(&NullTask), | |
1336 base::TimeTicks() + base::TimeDelta::FromMicroseconds(200)); | |
1337 test_task_runner_->RunUntilIdle(); | |
1338 } | |
1339 | |
1340 void HasOneRefTask(std::vector<bool>* log, internal::TaskQueueImpl* tq) { | 1301 void HasOneRefTask(std::vector<bool>* log, internal::TaskQueueImpl* tq) { |
1341 log->push_back(tq->HasOneRef()); | 1302 log->push_back(tq->HasOneRef()); |
1342 } | 1303 } |
1343 | 1304 |
1344 TEST_F(TaskQueueManagerTest, UnregisterTaskQueueInNestedLoop) { | 1305 TEST_F(TaskQueueManagerTest, UnregisterTaskQueueInNestedLoop) { |
1345 InitializeWithRealMessageLoop(1u); | 1306 InitializeWithRealMessageLoop(1u); |
1346 | 1307 |
1347 // We retain a reference to the task queue even when the manager has deleted | 1308 // We retain a reference to the task queue even when the manager has deleted |
1348 // its reference. | 1309 // its reference. |
1349 scoped_refptr<internal::TaskQueueImpl> task_queue = | 1310 scoped_refptr<internal::TaskQueueImpl> task_queue = |
(...skipping 30 matching lines...) Expand all Loading... |
1380 base::Unretained(task_queue.get()))); | 1341 base::Unretained(task_queue.get()))); |
1381 message_loop_->RunUntilIdle(); | 1342 message_loop_->RunUntilIdle(); |
1382 | 1343 |
1383 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1344 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1384 } | 1345 } |
1385 | 1346 |
1386 TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) { | 1347 TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) { |
1387 Initialize(2u); | 1348 Initialize(2u); |
1388 | 1349 |
1389 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | 1350 base::TimeTicks start_time = manager_->delegate()->NowTicks(); |
1390 scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time)); | 1351 scoped_ptr<VirtualTimeDomain> domain_a( |
1391 scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time)); | 1352 new VirtualTimeDomain(nullptr, start_time)); |
1392 manager_->RegisterTimeDomain(domain_a); | 1353 scoped_ptr<VirtualTimeDomain> domain_b( |
1393 manager_->RegisterTimeDomain(domain_b); | 1354 new VirtualTimeDomain(nullptr, start_time)); |
1394 runners_[0]->SetTimeDomain(domain_a); | 1355 manager_->RegisterTimeDomain(domain_a.get()); |
1395 runners_[1]->SetTimeDomain(domain_b); | 1356 manager_->RegisterTimeDomain(domain_b.get()); |
| 1357 runners_[0]->SetTimeDomain(domain_a.get()); |
| 1358 runners_[1]->SetTimeDomain(domain_b.get()); |
1396 | 1359 |
1397 std::vector<int> run_order; | 1360 std::vector<int> run_order; |
1398 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1361 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1399 base::TimeDelta::FromMilliseconds(10)); | 1362 base::TimeDelta::FromMilliseconds(10)); |
1400 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1363 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1401 base::TimeDelta::FromMilliseconds(20)); | 1364 base::TimeDelta::FromMilliseconds(20)); |
1402 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 1365 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
1403 base::TimeDelta::FromMilliseconds(30)); | 1366 base::TimeDelta::FromMilliseconds(30)); |
1404 | 1367 |
1405 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), | 1368 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), |
1406 base::TimeDelta::FromMilliseconds(10)); | 1369 base::TimeDelta::FromMilliseconds(10)); |
1407 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order), | 1370 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order), |
1408 base::TimeDelta::FromMilliseconds(20)); | 1371 base::TimeDelta::FromMilliseconds(20)); |
1409 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order), | 1372 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order), |
1410 base::TimeDelta::FromMilliseconds(30)); | 1373 base::TimeDelta::FromMilliseconds(30)); |
1411 | 1374 |
1412 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); | 1375 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); |
1413 | 1376 |
1414 test_task_runner_->RunUntilIdle(); | 1377 test_task_runner_->RunUntilIdle(); |
1415 EXPECT_THAT(run_order, ElementsAre(4, 5, 6)); | 1378 EXPECT_THAT(run_order, ElementsAre(4, 5, 6)); |
1416 | 1379 |
1417 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); | 1380 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); |
1418 | 1381 |
1419 test_task_runner_->RunUntilIdle(); | 1382 test_task_runner_->RunUntilIdle(); |
1420 EXPECT_THAT(run_order, ElementsAre(4, 5, 6, 1, 2, 3)); | 1383 EXPECT_THAT(run_order, ElementsAre(4, 5, 6, 1, 2, 3)); |
1421 | 1384 |
1422 manager_->UnregisterTimeDomain(domain_a); | 1385 manager_->UnregisterTimeDomain(domain_a.get()); |
1423 manager_->UnregisterTimeDomain(domain_b); | 1386 manager_->UnregisterTimeDomain(domain_b.get()); |
1424 } | 1387 } |
1425 | 1388 |
1426 TEST_F(TaskQueueManagerTest, TimeDomainMigration) { | 1389 TEST_F(TaskQueueManagerTest, TimeDomainMigration) { |
1427 Initialize(1u); | 1390 Initialize(1u); |
1428 | 1391 |
1429 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | 1392 base::TimeTicks start_time = manager_->delegate()->NowTicks(); |
1430 scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time)); | 1393 scoped_ptr<VirtualTimeDomain> domain_a( |
1431 manager_->RegisterTimeDomain(domain_a); | 1394 new VirtualTimeDomain(nullptr, start_time)); |
1432 runners_[0]->SetTimeDomain(domain_a); | 1395 manager_->RegisterTimeDomain(domain_a.get()); |
| 1396 runners_[0]->SetTimeDomain(domain_a.get()); |
1433 | 1397 |
1434 std::vector<int> run_order; | 1398 std::vector<int> run_order; |
1435 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1399 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1436 base::TimeDelta::FromMilliseconds(10)); | 1400 base::TimeDelta::FromMilliseconds(10)); |
1437 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1401 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1438 base::TimeDelta::FromMilliseconds(20)); | 1402 base::TimeDelta::FromMilliseconds(20)); |
1439 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 1403 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
1440 base::TimeDelta::FromMilliseconds(30)); | 1404 base::TimeDelta::FromMilliseconds(30)); |
1441 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), | 1405 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), |
1442 base::TimeDelta::FromMilliseconds(40)); | 1406 base::TimeDelta::FromMilliseconds(40)); |
1443 | 1407 |
1444 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20)); | 1408 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20)); |
1445 test_task_runner_->RunUntilIdle(); | 1409 test_task_runner_->RunUntilIdle(); |
1446 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 1410 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
1447 | 1411 |
1448 scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time)); | 1412 scoped_ptr<VirtualTimeDomain> domain_b( |
1449 manager_->RegisterTimeDomain(domain_b); | 1413 new VirtualTimeDomain(nullptr, start_time)); |
1450 runners_[0]->SetTimeDomain(domain_b); | 1414 manager_->RegisterTimeDomain(domain_b.get()); |
| 1415 runners_[0]->SetTimeDomain(domain_b.get()); |
1451 | 1416 |
1452 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); | 1417 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); |
1453 | 1418 |
1454 test_task_runner_->RunUntilIdle(); | 1419 test_task_runner_->RunUntilIdle(); |
1455 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4)); | 1420 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4)); |
1456 | 1421 |
1457 manager_->UnregisterTimeDomain(domain_a); | 1422 manager_->UnregisterTimeDomain(domain_a.get()); |
1458 manager_->UnregisterTimeDomain(domain_b); | 1423 manager_->UnregisterTimeDomain(domain_b.get()); |
1459 } | 1424 } |
1460 | 1425 |
1461 namespace { | 1426 namespace { |
1462 void ChromiumRunloopInspectionTask( | 1427 void ChromiumRunloopInspectionTask( |
1463 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner) { | 1428 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner) { |
1464 EXPECT_EQ(1u, test_task_runner->NumPendingTasks()); | 1429 EXPECT_EQ(1u, test_task_runner->NumPendingTasks()); |
1465 } | 1430 } |
1466 } // namespace | 1431 } // namespace |
1467 | 1432 |
1468 TEST_F(TaskQueueManagerTest, NumberOfPendingTasksOnChromiumRunLoop) { | 1433 TEST_F(TaskQueueManagerTest, NumberOfPendingTasksOnChromiumRunLoop) { |
1469 Initialize(1u); | 1434 Initialize(1u); |
1470 | 1435 |
1471 // NOTE because tasks posted to the chromiumrun loop are not cancellable, we | 1436 // NOTE because tasks posted to the chromiumrun loop are not cancellable, we |
1472 // will end up with a lot more tasks posted if the delayed tasks were posted | 1437 // will end up with a lot more tasks posted if the delayed tasks were posted |
1473 // in the reverse order. | 1438 // in the reverse order. |
1474 // TODO(alexclarke): Consider talking to the message pump directly. | 1439 // TODO(alexclarke): Consider talking to the message pump directly. |
1475 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 1440 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
1476 for (int i = 1; i < 100; i++) { | 1441 for (int i = 1; i < 100; i++) { |
1477 runners_[0]->PostDelayedTask( | 1442 runners_[0]->PostDelayedTask( |
1478 FROM_HERE, | 1443 FROM_HERE, |
1479 base::Bind(&ChromiumRunloopInspectionTask, test_task_runner_), | 1444 base::Bind(&ChromiumRunloopInspectionTask, test_task_runner_), |
1480 base::TimeDelta::FromMilliseconds(i)); | 1445 base::TimeDelta::FromMilliseconds(i)); |
1481 } | 1446 } |
1482 test_task_runner_->RunUntilIdle(); | 1447 test_task_runner_->RunUntilIdle(); |
1483 } | 1448 } |
1484 | 1449 |
1485 } // namespace scheduler | 1450 } // namespace scheduler |
OLD | NEW |