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" | |
14 #include "components/scheduler/base/task_queue_impl.h" | 13 #include "components/scheduler/base/task_queue_impl.h" |
15 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" | 14 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" |
16 #include "components/scheduler/base/task_queue_selector.h" | 15 #include "components/scheduler/base/task_queue_selector.h" |
17 #include "components/scheduler/base/task_queue_sets.h" | 16 #include "components/scheduler/base/task_queue_sets.h" |
18 #include "components/scheduler/base/test_always_fail_time_source.h" | 17 #include "components/scheduler/base/test_always_fail_time_source.h" |
19 #include "components/scheduler/base/test_time_source.h" | 18 #include "components/scheduler/base/test_time_source.h" |
20 #include "components/scheduler/base/virtual_time_domain.h" | |
21 #include "testing/gmock/include/gmock/gmock.h" | 19 #include "testing/gmock/include/gmock/gmock.h" |
22 | 20 |
23 using testing::ElementsAre; | 21 using testing::ElementsAre; |
24 using testing::_; | 22 using testing::_; |
25 | 23 |
26 namespace scheduler { | 24 namespace scheduler { |
27 | 25 |
28 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest { | 26 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest { |
29 public: | 27 public: |
30 static scoped_refptr<MessageLoopTaskRunner> Create( | 28 static scoped_refptr<MessageLoopTaskRunner> Create( |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
66 } | 64 } |
67 | 65 |
68 void Initialize(size_t num_queues) { | 66 void Initialize(size_t num_queues) { |
69 now_src_.reset(new base::SimpleTestTickClock()); | 67 now_src_.reset(new base::SimpleTestTickClock()); |
70 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | 68 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
71 InitializeWithClock(num_queues, | 69 InitializeWithClock(num_queues, |
72 make_scoped_ptr(new TestTimeSource(now_src_.get()))); | 70 make_scoped_ptr(new TestTimeSource(now_src_.get()))); |
73 } | 71 } |
74 | 72 |
75 void InitializeWithRealMessageLoop(size_t num_queues) { | 73 void InitializeWithRealMessageLoop(size_t num_queues) { |
76 now_src_.reset(new base::SimpleTestTickClock()); | |
77 message_loop_.reset(new base::MessageLoop()); | 74 message_loop_.reset(new base::MessageLoop()); |
78 manager_ = make_scoped_ptr(new TaskQueueManager( | 75 manager_ = make_scoped_ptr(new TaskQueueManager( |
79 MessageLoopTaskRunner::Create( | 76 MessageLoopTaskRunner::Create( |
80 make_scoped_ptr(new TestTimeSource(now_src_.get()))), | 77 make_scoped_ptr(new TestTimeSource(now_src_.get()))), |
81 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | 78 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
82 | 79 |
83 for (size_t i = 0; i < num_queues; i++) | 80 for (size_t i = 0; i < num_queues; i++) |
84 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 81 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
85 } | 82 } |
86 | 83 |
(...skipping 806 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
893 message_loop_->RunUntilIdle(); | 890 message_loop_->RunUntilIdle(); |
894 } | 891 } |
895 | 892 |
896 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 893 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
897 Initialize(1u); | 894 Initialize(1u); |
898 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 895 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
899 manager_.reset(); | 896 manager_.reset(); |
900 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 897 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
901 } | 898 } |
902 | 899 |
903 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime) { | 900 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { |
904 Initialize(2u); | 901 Initialize(2u); |
905 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); | 902 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); |
906 | 903 |
907 // With no delayed tasks. | 904 // With no delayed tasks. |
908 base::TimeTicks run_time; | 905 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
909 EXPECT_FALSE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | |
910 | 906 |
911 // With a non-delayed task. | 907 // With a non-delayed task. |
912 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 908 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
913 EXPECT_FALSE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 909 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
914 | 910 |
915 // With a delayed task. | 911 // With a delayed task. |
916 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 912 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
917 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 913 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
918 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 914 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
919 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); | 915 manager_->NextPendingDelayedTaskRunTime()); |
920 | 916 |
921 // With another delayed task in the same queue with a longer delay. | 917 // With another delayed task in the same queue with a longer delay. |
922 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 918 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
923 base::TimeDelta::FromMilliseconds(100)); | 919 base::TimeDelta::FromMilliseconds(100)); |
924 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 920 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
925 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); | 921 manager_->NextPendingDelayedTaskRunTime()); |
926 | 922 |
927 // With another delayed task in the same queue with a shorter delay. | 923 // With another delayed task in the same queue with a shorter delay. |
928 expected_delay = base::TimeDelta::FromMilliseconds(20); | 924 expected_delay = base::TimeDelta::FromMilliseconds(20); |
929 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 925 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
930 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 926 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
931 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); | 927 manager_->NextPendingDelayedTaskRunTime()); |
932 | 928 |
933 // With another delayed task in a different queue with a shorter delay. | 929 // With another delayed task in a different queue with a shorter delay. |
934 expected_delay = base::TimeDelta::FromMilliseconds(10); | 930 expected_delay = base::TimeDelta::FromMilliseconds(10); |
935 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 931 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
936 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 932 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
937 EXPECT_EQ(now_src_->NowTicks() + expected_delay, run_time); | 933 manager_->NextPendingDelayedTaskRunTime()); |
938 | 934 |
939 // Test it updates as time progresses | 935 // Test it updates as time progresses |
940 now_src_->Advance(expected_delay); | 936 now_src_->Advance(expected_delay); |
941 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 937 EXPECT_EQ(now_src_->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); |
942 EXPECT_EQ(now_src_->NowTicks(), run_time); | |
943 } | 938 } |
944 | 939 |
945 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime_MultipleQueues) { | 940 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { |
946 Initialize(3u); | 941 Initialize(3u); |
947 | 942 |
948 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 943 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
949 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 944 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
950 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 945 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
951 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 946 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
952 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 947 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); |
953 runners_[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); | 948 runners_[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); |
954 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
955 | 949 |
956 base::TimeTicks run_time; | 950 EXPECT_EQ(now_src_->NowTicks() + delay2, |
957 EXPECT_TRUE(manager_->real_time_domain()->NextScheduledRunTime(&run_time)); | 951 manager_->NextPendingDelayedTaskRunTime()); |
958 EXPECT_EQ(now_src_->NowTicks() + delay2, run_time); | |
959 } | 952 } |
960 | 953 |
961 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { | 954 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { |
962 Initialize(1u); | 955 Initialize(1u); |
963 | 956 |
964 runners_[0]->PostTask( | 957 runners_[0]->PostTask( |
965 FROM_HERE, base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, | 958 FROM_HERE, base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, |
966 base::Unretained(this))); | 959 base::Unretained(this))); |
967 | 960 |
968 // This should not crash, assuming DoWork detects the TaskQueueManager has | 961 // This should not crash, assuming DoWork detects the TaskQueueManager has |
(...skipping 407 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1376 // Add a final call to HasOneRefTask. This gives the manager a chance to | 1369 // Add a final call to HasOneRefTask. This gives the manager a chance to |
1377 // release its reference, and checks that it has. | 1370 // release its reference, and checks that it has. |
1378 runners_[0]->PostTask(FROM_HERE, | 1371 runners_[0]->PostTask(FROM_HERE, |
1379 base::Bind(&HasOneRefTask, base::Unretained(&log), | 1372 base::Bind(&HasOneRefTask, base::Unretained(&log), |
1380 base::Unretained(task_queue.get()))); | 1373 base::Unretained(task_queue.get()))); |
1381 message_loop_->RunUntilIdle(); | 1374 message_loop_->RunUntilIdle(); |
1382 | 1375 |
1383 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1376 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1384 } | 1377 } |
1385 | 1378 |
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 | |
1461 } // namespace scheduler | 1379 } // namespace scheduler |
OLD | NEW |