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/nestable_task_runner_for_test.h" | |
14 #include "components/scheduler/base/task_queue_impl.h" | 13 #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_selector.h" | 15 #include "components/scheduler/base/task_queue_selector.h" |
16 #include "components/scheduler/base/task_queue_sets.h" | 16 #include "components/scheduler/base/task_queue_sets.h" |
17 #include "components/scheduler/base/test_always_fail_time_source.h" | 17 #include "components/scheduler/base/test_always_fail_time_source.h" |
18 #include "components/scheduler/base/test_time_source.h" | 18 #include "components/scheduler/base/test_time_source.h" |
19 #include "testing/gmock/include/gmock/gmock.h" | 19 #include "testing/gmock/include/gmock/gmock.h" |
20 | 20 |
21 using testing::ElementsAre; | 21 using testing::ElementsAre; |
22 using testing::_; | 22 using testing::_; |
23 | 23 |
24 namespace scheduler { | 24 namespace scheduler { |
25 | 25 |
26 class MessageLoopTaskRunner : public NestableTaskRunnerForTest { | 26 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest { |
27 public: | 27 public: |
28 static scoped_refptr<MessageLoopTaskRunner> Create() { | 28 static scoped_refptr<MessageLoopTaskRunner> Create( |
29 return make_scoped_refptr(new MessageLoopTaskRunner()); | 29 scoped_ptr<base::TickClock> tick_clock) { |
| 30 return make_scoped_refptr(new MessageLoopTaskRunner(tick_clock.Pass())); |
30 } | 31 } |
31 | 32 |
32 // NestableTaskRunner implementation. | 33 // NestableTaskRunner implementation. |
33 bool IsNested() const override { | 34 bool IsNested() const override { |
34 return base::MessageLoop::current()->IsNested(); | 35 return base::MessageLoop::current()->IsNested(); |
35 } | 36 } |
36 | 37 |
37 private: | 38 private: |
38 MessageLoopTaskRunner() | 39 explicit MessageLoopTaskRunner(scoped_ptr<base::TickClock> tick_clock) |
39 : NestableTaskRunnerForTest(base::MessageLoop::current()->task_runner()) { | 40 : TaskQueueManagerDelegateForTest(base::MessageLoop::current() |
40 } | 41 ->task_runner(), |
| 42 tick_clock.Pass()) {} |
41 ~MessageLoopTaskRunner() override {} | 43 ~MessageLoopTaskRunner() override {} |
42 }; | 44 }; |
43 | 45 |
44 class TaskQueueManagerTest : public testing::Test { | 46 class TaskQueueManagerTest : public testing::Test { |
45 public: | 47 public: |
46 void DeleteTaskQueueManager() { manager_.reset(); } | 48 void DeleteTaskQueueManager() { manager_.reset(); } |
47 | 49 |
48 protected: | 50 protected: |
49 void Initialize(size_t num_queues) { | 51 void InitializeWithClock(size_t num_queues, |
50 now_src_.reset(new base::SimpleTestTickClock()); | 52 scoped_ptr<base::TickClock> test_time_source) { |
51 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | |
52 test_task_runner_ = make_scoped_refptr( | 53 test_task_runner_ = make_scoped_refptr( |
53 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); | 54 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); |
54 main_task_runner_ = | 55 main_task_runner_ = TaskQueueManagerDelegateForTest::Create( |
55 NestableTaskRunnerForTest::Create(test_task_runner_.get()); | 56 test_task_runner_.get(), |
| 57 make_scoped_ptr(new TestTimeSource(now_src_.get()))); |
56 manager_ = make_scoped_ptr(new TaskQueueManager( | 58 manager_ = make_scoped_ptr(new TaskQueueManager( |
57 main_task_runner_, "test.scheduler", "test.scheduler", | 59 main_task_runner_, "test.scheduler", "test.scheduler", |
58 "test.scheduler.debug")); | 60 "test.scheduler.debug")); |
59 manager_->SetTimeSourceForTesting( | |
60 make_scoped_ptr(new TestTimeSource(now_src_.get()))); | |
61 | 61 |
62 for (size_t i = 0; i < num_queues; i++) | 62 for (size_t i = 0; i < num_queues; i++) |
63 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 63 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
64 } | 64 } |
65 | 65 |
| 66 void Initialize(size_t num_queues) { |
| 67 now_src_.reset(new base::SimpleTestTickClock()); |
| 68 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
| 69 InitializeWithClock(num_queues, |
| 70 make_scoped_ptr(new TestTimeSource(now_src_.get()))); |
| 71 } |
| 72 |
66 void InitializeWithRealMessageLoop(size_t num_queues) { | 73 void InitializeWithRealMessageLoop(size_t num_queues) { |
67 message_loop_.reset(new base::MessageLoop()); | 74 message_loop_.reset(new base::MessageLoop()); |
68 manager_ = make_scoped_ptr( | 75 manager_ = make_scoped_ptr(new TaskQueueManager( |
69 new TaskQueueManager(MessageLoopTaskRunner::Create(), "test.scheduler", | 76 MessageLoopTaskRunner::Create( |
70 "test.scheduler", "test.scheduler.debug")); | 77 make_scoped_ptr(new TestTimeSource(now_src_.get()))), |
| 78 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
71 | 79 |
72 for (size_t i = 0; i < num_queues; i++) | 80 for (size_t i = 0; i < num_queues; i++) |
73 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 81 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
74 } | 82 } |
75 | 83 |
76 scoped_ptr<base::MessageLoop> message_loop_; | 84 scoped_ptr<base::MessageLoop> message_loop_; |
77 scoped_ptr<base::SimpleTestTickClock> now_src_; | 85 scoped_ptr<base::SimpleTestTickClock> now_src_; |
78 scoped_refptr<NestableTaskRunnerForTest> main_task_runner_; | 86 scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_; |
79 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; | 87 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; |
80 scoped_ptr<TaskQueueManager> manager_; | 88 scoped_ptr<TaskQueueManager> manager_; |
81 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; | 89 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; |
82 }; | 90 }; |
83 | 91 |
84 void PostFromNestedRunloop(base::MessageLoop* message_loop, | 92 void PostFromNestedRunloop(base::MessageLoop* message_loop, |
85 base::SingleThreadTaskRunner* runner, | 93 base::SingleThreadTaskRunner* runner, |
86 std::vector<std::pair<base::Closure, bool>>* tasks) { | 94 std::vector<std::pair<base::Closure, bool>>* tasks) { |
87 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); | 95 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); |
88 for (std::pair<base::Closure, bool>& pair : *tasks) { | 96 for (std::pair<base::Closure, bool>& pair : *tasks) { |
89 if (pair.second) { | 97 if (pair.second) { |
90 runner->PostTask(FROM_HERE, pair.first); | 98 runner->PostTask(FROM_HERE, pair.first); |
91 } else { | 99 } else { |
92 runner->PostNonNestableTask(FROM_HERE, pair.first); | 100 runner->PostNonNestableTask(FROM_HERE, pair.first); |
93 } | 101 } |
94 } | 102 } |
95 message_loop->RunUntilIdle(); | 103 message_loop->RunUntilIdle(); |
96 } | 104 } |
97 | 105 |
| 106 void NopTask() {} |
| 107 |
| 108 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { |
| 109 message_loop_.reset(new base::MessageLoop()); |
| 110 manager_ = make_scoped_ptr(new TaskQueueManager( |
| 111 MessageLoopTaskRunner::Create( |
| 112 make_scoped_ptr(new TestAlwaysFailTimeSource())), |
| 113 "test.scheduler", "test.scheduler", "test.scheduler.debug")); |
| 114 |
| 115 for (size_t i = 0; i < 3; i++) |
| 116 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
| 117 |
| 118 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
| 119 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
| 120 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
| 121 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
| 122 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
| 123 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
| 124 |
| 125 message_loop_->RunUntilIdle(); |
| 126 } |
| 127 |
98 void NullTask() {} | 128 void NullTask() {} |
99 | 129 |
100 void TestTask(int value, std::vector<int>* out_result) { | 130 void TestTask(int value, std::vector<int>* out_result) { |
101 out_result->push_back(value); | 131 out_result->push_back(value); |
102 } | 132 } |
103 | 133 |
104 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { | 134 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { |
105 Initialize(1u); | 135 Initialize(1u); |
106 | 136 |
107 std::vector<int> run_order; | 137 std::vector<int> run_order; |
(...skipping 13 matching lines...) Expand all Loading... |
121 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 151 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
122 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 152 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
123 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 153 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
124 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); | 154 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); |
125 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); | 155 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); |
126 | 156 |
127 test_task_runner_->RunUntilIdle(); | 157 test_task_runner_->RunUntilIdle(); |
128 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); | 158 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); |
129 } | 159 } |
130 | 160 |
131 void NopTask() {} | |
132 | |
133 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { | |
134 Initialize(3u); | |
135 | |
136 manager_->SetTimeSourceForTesting( | |
137 make_scoped_ptr(new TestAlwaysFailTimeSource())); | |
138 | |
139 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
140 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
141 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
142 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
143 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
144 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | |
145 | |
146 test_task_runner_->RunUntilIdle(); | |
147 } | |
148 | |
149 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { | 161 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
150 InitializeWithRealMessageLoop(1u); | 162 InitializeWithRealMessageLoop(1u); |
151 | 163 |
152 std::vector<int> run_order; | 164 std::vector<int> run_order; |
153 runners_[0]->PostNonNestableTask(FROM_HERE, | 165 runners_[0]->PostNonNestableTask(FROM_HERE, |
154 base::Bind(&TestTask, 1, &run_order)); | 166 base::Bind(&TestTask, 1, &run_order)); |
155 | 167 |
156 message_loop_->RunUntilIdle(); | 168 message_loop_->RunUntilIdle(); |
157 EXPECT_THAT(run_order, ElementsAre(1)); | 169 EXPECT_THAT(run_order, ElementsAre(1)); |
158 } | 170 } |
(...skipping 720 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
879 } | 891 } |
880 | 892 |
881 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 893 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
882 Initialize(1u); | 894 Initialize(1u); |
883 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 895 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
884 manager_.reset(); | 896 manager_.reset(); |
885 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 897 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
886 } | 898 } |
887 | 899 |
888 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { | 900 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { |
889 scoped_ptr<base::SimpleTestTickClock> clock(new base::SimpleTestTickClock()); | |
890 clock->Advance(base::TimeDelta::FromMicroseconds(10000)); | |
891 Initialize(2u); | 901 Initialize(2u); |
892 manager_->SetTimeSourceForTesting( | 902 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); |
893 make_scoped_ptr(new TestTimeSource(clock.get()))); | |
894 | 903 |
895 // With no delayed tasks. | 904 // With no delayed tasks. |
896 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 905 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
897 | 906 |
898 // With a non-delayed task. | 907 // With a non-delayed task. |
899 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 908 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
900 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 909 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
901 | 910 |
902 // With a delayed task. | 911 // With a delayed task. |
903 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 912 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
904 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 913 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
905 EXPECT_EQ(clock->NowTicks() + expected_delay, | 914 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
906 manager_->NextPendingDelayedTaskRunTime()); | 915 manager_->NextPendingDelayedTaskRunTime()); |
907 | 916 |
908 // 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. |
909 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 918 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
910 base::TimeDelta::FromMilliseconds(100)); | 919 base::TimeDelta::FromMilliseconds(100)); |
911 EXPECT_EQ(clock->NowTicks() + expected_delay, | 920 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
912 manager_->NextPendingDelayedTaskRunTime()); | 921 manager_->NextPendingDelayedTaskRunTime()); |
913 | 922 |
914 // 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. |
915 expected_delay = base::TimeDelta::FromMilliseconds(20); | 924 expected_delay = base::TimeDelta::FromMilliseconds(20); |
916 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 925 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
917 EXPECT_EQ(clock->NowTicks() + expected_delay, | 926 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
918 manager_->NextPendingDelayedTaskRunTime()); | 927 manager_->NextPendingDelayedTaskRunTime()); |
919 | 928 |
920 // 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. |
921 expected_delay = base::TimeDelta::FromMilliseconds(10); | 930 expected_delay = base::TimeDelta::FromMilliseconds(10); |
922 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 931 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
923 EXPECT_EQ(clock->NowTicks() + expected_delay, | 932 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
924 manager_->NextPendingDelayedTaskRunTime()); | 933 manager_->NextPendingDelayedTaskRunTime()); |
925 | 934 |
926 // Test it updates as time progresses | 935 // Test it updates as time progresses |
927 clock->Advance(expected_delay); | 936 now_src_->Advance(expected_delay); |
928 EXPECT_EQ(clock->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); | 937 EXPECT_EQ(now_src_->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); |
929 } | 938 } |
930 | 939 |
931 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { | 940 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { |
932 Initialize(3u); | 941 Initialize(3u); |
933 | 942 |
934 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 943 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
935 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 944 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
936 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 945 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
937 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 946 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
938 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 947 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); |
(...skipping 422 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1361 // release its reference, and checks that it has. | 1370 // release its reference, and checks that it has. |
1362 runners_[0]->PostTask(FROM_HERE, | 1371 runners_[0]->PostTask(FROM_HERE, |
1363 base::Bind(&HasOneRefTask, base::Unretained(&log), | 1372 base::Bind(&HasOneRefTask, base::Unretained(&log), |
1364 base::Unretained(task_queue.get()))); | 1373 base::Unretained(task_queue.get()))); |
1365 message_loop_->RunUntilIdle(); | 1374 message_loop_->RunUntilIdle(); |
1366 | 1375 |
1367 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1376 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1368 } | 1377 } |
1369 | 1378 |
1370 } // namespace scheduler | 1379 } // namespace scheduler |
OLD | NEW |