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 806 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
890 message_loop_->RunUntilIdle(); | 893 message_loop_->RunUntilIdle(); |
891 } | 894 } |
892 | 895 |
893 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 896 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
894 Initialize(1u); | 897 Initialize(1u); |
895 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 898 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
896 manager_.reset(); | 899 manager_.reset(); |
897 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 900 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
898 } | 901 } |
899 | 902 |
900 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { | 903 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime) { |
901 Initialize(2u); | 904 Initialize(2u); |
902 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); | 905 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); |
903 | 906 |
904 // With no delayed tasks. | 907 // With no delayed tasks. |
905 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 908 base::TimeTicks run_time; |
| 909 EXPECT_FALSE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
906 | 910 |
907 // With a non-delayed task. | 911 // With a non-delayed task. |
908 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 912 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
909 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 913 EXPECT_FALSE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
910 | 914 |
911 // With a delayed task. | 915 // With a delayed task. |
912 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 916 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
913 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 917 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
914 EXPECT_EQ(now_src_->NowTicks() + expected_delay, | 918 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
915 manager_->NextPendingDelayedTaskRunTime()); | 919 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); |
916 | 920 |
917 // With another delayed task in the same queue with a longer delay. | 921 // With another delayed task in the same queue with a longer delay. |
918 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 922 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
919 base::TimeDelta::FromMilliseconds(100)); | 923 base::TimeDelta::FromMilliseconds(100)); |
920 EXPECT_EQ(now_src_->NowTicks() + expected_delay, | 924 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
921 manager_->NextPendingDelayedTaskRunTime()); | 925 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); |
922 | 926 |
923 // With another delayed task in the same queue with a shorter delay. | 927 // With another delayed task in the same queue with a shorter delay. |
924 expected_delay = base::TimeDelta::FromMilliseconds(20); | 928 expected_delay = base::TimeDelta::FromMilliseconds(20); |
925 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 929 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
926 EXPECT_EQ(now_src_->NowTicks() + expected_delay, | 930 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
927 manager_->NextPendingDelayedTaskRunTime()); | 931 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); |
928 | 932 |
929 // With another delayed task in a different queue with a shorter delay. | 933 // With another delayed task in a different queue with a shorter delay. |
930 expected_delay = base::TimeDelta::FromMilliseconds(10); | 934 expected_delay = base::TimeDelta::FromMilliseconds(10); |
931 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 935 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
932 EXPECT_EQ(now_src_->NowTicks() + expected_delay, | 936 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
933 manager_->NextPendingDelayedTaskRunTime()); | 937 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); |
934 | 938 |
935 // Test it updates as time progresses | 939 // Test it updates as time progresses |
936 now_src_->Advance(expected_delay); | 940 now_src_->Advance(expected_delay); |
937 EXPECT_EQ(now_src_->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); | 941 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
| 942 EXPECT_EQ(now_src_->NowTicks(), run_time); |
938 } | 943 } |
939 | 944 |
940 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { | 945 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime_MultipleQueues) { |
941 Initialize(3u); | 946 Initialize(3u); |
942 | 947 |
943 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 948 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
944 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 949 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
945 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 950 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
946 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 951 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
947 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 952 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); |
948 runners_[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); | 953 runners_[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); |
| 954 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
949 | 955 |
950 EXPECT_EQ(now_src_->NowTicks() + delay2, | 956 base::TimeTicks run_time; |
951 manager_->NextPendingDelayedTaskRunTime()); | 957 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); |
| 958 EXPECT_EQ(now_src_->NowTicks() + delay2, run_time); |
952 } | 959 } |
953 | 960 |
954 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { | 961 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { |
955 Initialize(1u); | 962 Initialize(1u); |
956 | 963 |
957 runners_[0]->PostTask( | 964 runners_[0]->PostTask( |
958 FROM_HERE, base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, | 965 FROM_HERE, base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, |
959 base::Unretained(this))); | 966 base::Unretained(this))); |
960 | 967 |
961 // This should not crash, assuming DoWork detects the TaskQueueManager has | 968 // This should not crash, assuming DoWork detects the TaskQueueManager has |
(...skipping 407 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 | 1376 // Add a final call to HasOneRefTask. This gives the manager a chance to |
1370 // release its reference, and checks that it has. | 1377 // release its reference, and checks that it has. |
1371 runners_[0]->PostTask(FROM_HERE, | 1378 runners_[0]->PostTask(FROM_HERE, |
1372 base::Bind(&HasOneRefTask, base::Unretained(&log), | 1379 base::Bind(&HasOneRefTask, base::Unretained(&log), |
1373 base::Unretained(task_queue.get()))); | 1380 base::Unretained(task_queue.get()))); |
1374 message_loop_->RunUntilIdle(); | 1381 message_loop_->RunUntilIdle(); |
1375 | 1382 |
1376 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1383 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1377 } | 1384 } |
1378 | 1385 |
| 1386 TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) { |
| 1387 Initialize(2u); |
| 1388 |
| 1389 base::TimeTicks start_time = manager_->delegate()->NowTicks(); |
| 1390 scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time)); |
| 1391 scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time)); |
| 1392 manager_->RegisterTimeDomain(domain_a); |
| 1393 manager_->RegisterTimeDomain(domain_b); |
| 1394 runners_[0]->SetTimeDomain(domain_a); |
| 1395 runners_[1]->SetTimeDomain(domain_b); |
| 1396 |
| 1397 std::vector<int> run_order; |
| 1398 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
| 1399 base::TimeDelta::FromMilliseconds(10)); |
| 1400 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
| 1401 base::TimeDelta::FromMilliseconds(20)); |
| 1402 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
| 1403 base::TimeDelta::FromMilliseconds(30)); |
| 1404 |
| 1405 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), |
| 1406 base::TimeDelta::FromMilliseconds(10)); |
| 1407 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order), |
| 1408 base::TimeDelta::FromMilliseconds(20)); |
| 1409 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order), |
| 1410 base::TimeDelta::FromMilliseconds(30)); |
| 1411 |
| 1412 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); |
| 1413 |
| 1414 test_task_runner_->RunUntilIdle(); |
| 1415 EXPECT_THAT(run_order, ElementsAre(4, 5, 6)); |
| 1416 |
| 1417 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); |
| 1418 |
| 1419 test_task_runner_->RunUntilIdle(); |
| 1420 EXPECT_THAT(run_order, ElementsAre(4, 5, 6, 1, 2, 3)); |
| 1421 |
| 1422 manager_->UnregisterTimeDomain(domain_a); |
| 1423 manager_->UnregisterTimeDomain(domain_b); |
| 1424 } |
| 1425 |
| 1426 TEST_F(TaskQueueManagerTest, TimeDomainMigration) { |
| 1427 Initialize(1u); |
| 1428 |
| 1429 base::TimeTicks start_time = manager_->delegate()->NowTicks(); |
| 1430 scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time)); |
| 1431 manager_->RegisterTimeDomain(domain_a); |
| 1432 runners_[0]->SetTimeDomain(domain_a); |
| 1433 |
| 1434 std::vector<int> run_order; |
| 1435 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
| 1436 base::TimeDelta::FromMilliseconds(10)); |
| 1437 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
| 1438 base::TimeDelta::FromMilliseconds(20)); |
| 1439 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
| 1440 base::TimeDelta::FromMilliseconds(30)); |
| 1441 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), |
| 1442 base::TimeDelta::FromMilliseconds(40)); |
| 1443 |
| 1444 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20)); |
| 1445 test_task_runner_->RunUntilIdle(); |
| 1446 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
| 1447 |
| 1448 scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time)); |
| 1449 manager_->RegisterTimeDomain(domain_b); |
| 1450 runners_[0]->SetTimeDomain(domain_b); |
| 1451 |
| 1452 domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50)); |
| 1453 |
| 1454 test_task_runner_->RunUntilIdle(); |
| 1455 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4)); |
| 1456 |
| 1457 manager_->UnregisterTimeDomain(domain_a); |
| 1458 manager_->UnregisterTimeDomain(domain_b); |
| 1459 } |
| 1460 |
1379 } // namespace scheduler | 1461 } // namespace scheduler |
OLD | NEW |