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" |
11 #include "base/threading/thread.h" | 11 #include "base/threading/thread.h" |
12 #include "cc/test/ordered_simple_task_runner.h" | 12 #include "cc/test/ordered_simple_task_runner.h" |
13 #include "components/scheduler/base/real_time_domain.h" | |
13 #include "components/scheduler/base/task_queue_impl.h" | 14 #include "components/scheduler/base/task_queue_impl.h" |
14 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" | 15 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" |
15 #include "components/scheduler/base/task_queue_selector.h" | 16 #include "components/scheduler/base/task_queue_selector.h" |
16 #include "components/scheduler/base/task_queue_sets.h" | 17 #include "components/scheduler/base/task_queue_sets.h" |
17 #include "components/scheduler/base/test_always_fail_time_source.h" | 18 #include "components/scheduler/base/test_always_fail_time_source.h" |
18 #include "components/scheduler/base/test_time_source.h" | 19 #include "components/scheduler/base/test_time_source.h" |
20 #include "components/scheduler/base/virtual_time_domain.h" | |
19 #include "testing/gmock/include/gmock/gmock.h" | 21 #include "testing/gmock/include/gmock/gmock.h" |
20 | 22 |
21 using testing::ElementsAre; | 23 using testing::ElementsAre; |
22 using testing::_; | 24 using testing::_; |
23 | 25 |
24 namespace scheduler { | 26 namespace scheduler { |
25 | 27 |
26 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest { | 28 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest { |
27 public: | 29 public: |
28 static scoped_refptr<MessageLoopTaskRunner> Create( | 30 static scoped_refptr<MessageLoopTaskRunner> Create( |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
64 } | 66 } |
65 | 67 |
66 void Initialize(size_t num_queues) { | 68 void Initialize(size_t num_queues) { |
67 now_src_.reset(new base::SimpleTestTickClock()); | 69 now_src_.reset(new base::SimpleTestTickClock()); |
68 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | 70 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
69 InitializeWithClock(num_queues, | 71 InitializeWithClock(num_queues, |
70 make_scoped_ptr(new TestTimeSource(now_src_.get()))); | 72 make_scoped_ptr(new TestTimeSource(now_src_.get()))); |
71 } | 73 } |
72 | 74 |
73 void InitializeWithRealMessageLoop(size_t num_queues) { | 75 void InitializeWithRealMessageLoop(size_t num_queues) { |
76 now_src_.reset(new base::SimpleTestTickClock()); | |
74 message_loop_.reset(new base::MessageLoop()); | 77 message_loop_.reset(new base::MessageLoop()); |
75 manager_ = make_scoped_ptr(new TaskQueueManager( | 78 manager_ = make_scoped_ptr(new TaskQueueManager( |
76 MessageLoopTaskRunner::Create( | 79 MessageLoopTaskRunner::Create( |
77 make_scoped_ptr(new TestTimeSource(now_src_.get()))), | 80 make_scoped_ptr(new TestTimeSource(now_src_.get()))), |
78 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | 81 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
79 | 82 |
80 for (size_t i = 0; i < num_queues; i++) | 83 for (size_t i = 0; i < num_queues; i++) |
81 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 84 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
82 } | 85 } |
83 | 86 |
(...skipping 1285 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1369 // Add a final call to HasOneRefTask. This gives the manager a chance to | 1372 // Add a final call to HasOneRefTask. This gives the manager a chance to |
1370 // release its reference, and checks that it has. | 1373 // release its reference, and checks that it has. |
1371 runners_[0]->PostTask(FROM_HERE, | 1374 runners_[0]->PostTask(FROM_HERE, |
1372 base::Bind(&HasOneRefTask, base::Unretained(&log), | 1375 base::Bind(&HasOneRefTask, base::Unretained(&log), |
1373 base::Unretained(task_queue.get()))); | 1376 base::Unretained(task_queue.get()))); |
1374 message_loop_->RunUntilIdle(); | 1377 message_loop_->RunUntilIdle(); |
1375 | 1378 |
1376 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1379 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1377 } | 1380 } |
1378 | 1381 |
1382 TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) { | |
1383 Initialize(2u); | |
1384 | |
1385 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | |
1386 scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time)); | |
1387 scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time)); | |
1388 manager_->RegisterTimeDomain(domain_a); | |
1389 manager_->RegisterTimeDomain(domain_b); | |
1390 runners_[0]->SetTimeDomain(domain_a); | |
1391 runners_[1]->SetTimeDomain(domain_b); | |
1392 | |
1393 std::vector<int> run_order; | |
1394 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
1395 base::TimeDelta::FromMilliseconds(10)); | |
1396 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | |
1397 base::TimeDelta::FromMilliseconds(20)); | |
1398 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | |
1399 base::TimeDelta::FromMilliseconds(30)); | |
1400 | |
1401 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), | |
1402 base::TimeDelta::FromMilliseconds(10)); | |
1403 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order), | |
1404 base::TimeDelta::FromMilliseconds(20)); | |
1405 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order), | |
1406 base::TimeDelta::FromMilliseconds(30)); | |
1407 | |
1408 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); | |
1409 | |
1410 test_task_runner_->RunUntilIdle(); | |
1411 EXPECT_THAT(run_order, ElementsAre(4, 5, 6)); | |
1412 | |
1413 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); | |
1414 | |
1415 test_task_runner_->RunUntilIdle(); | |
1416 EXPECT_THAT(run_order, ElementsAre(4, 5, 6, 1, 2, 3)); | |
1417 } | |
Sami
2015/11/19 14:52:23
Maybe also unregister the domains so that code is
alex clarke (OOO till 29th)
2015/11/19 15:57:14
Done.
| |
1418 | |
1419 TEST_F(TaskQueueManagerTest, TimeDomainMigration) { | |
1420 Initialize(1u); | |
1421 | |
1422 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | |
1423 scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time)); | |
1424 manager_->RegisterTimeDomain(domain_a); | |
1425 runners_[0]->SetTimeDomain(domain_a); | |
1426 | |
1427 std::vector<int> run_order; | |
1428 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | |
1429 base::TimeDelta::FromMilliseconds(10)); | |
1430 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | |
1431 base::TimeDelta::FromMilliseconds(20)); | |
1432 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | |
1433 base::TimeDelta::FromMilliseconds(30)); | |
1434 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), | |
1435 base::TimeDelta::FromMilliseconds(40)); | |
1436 | |
1437 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20)); | |
1438 test_task_runner_->RunUntilIdle(); | |
1439 EXPECT_THAT(run_order, ElementsAre(1, 2)); | |
1440 | |
1441 scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time)); | |
1442 manager_->RegisterTimeDomain(domain_b); | |
1443 runners_[0]->SetTimeDomain(domain_b); | |
1444 | |
1445 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); | |
1446 | |
1447 test_task_runner_->RunUntilIdle(); | |
1448 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4)); | |
1449 } | |
1450 | |
1451 TEST_F(TaskQueueManagerTest, | |
1452 NextPendingDelayedTaskRunTime_IgnoresNonDefaultTimeDomains) { | |
1453 Initialize(2u); | |
1454 | |
1455 base::TimeTicks start_time = manager_->delegate()->NowTicks(); | |
1456 scoped_refptr<VirtualTimeDomain> virtual_time_domain( | |
1457 new VirtualTimeDomain(start_time)); | |
1458 manager_->RegisterTimeDomain(virtual_time_domain); | |
1459 runners_[0]->SetTimeDomain(virtual_time_domain); | |
1460 | |
1461 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | |
1462 base::TimeDelta::FromMilliseconds(10)); | |
1463 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | |
1464 base::TimeDelta::FromMilliseconds(100)); | |
1465 | |
1466 EXPECT_EQ(start_time + base::TimeDelta::FromMilliseconds(100), | |
1467 manager_->NextPendingDelayedTaskRunTime()); | |
1468 | |
1469 runners_[0]->SetTimeDomain(manager_->real_time_domain()); | |
1470 EXPECT_EQ(start_time + base::TimeDelta::FromMilliseconds(10), | |
1471 manager_->NextPendingDelayedTaskRunTime()); | |
1472 } | |
1473 | |
1379 } // namespace scheduler | 1474 } // namespace scheduler |
OLD | NEW |