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" | 13 #include "components/scheduler/base/nestable_task_runner_for_test.h" |
14 #include "components/scheduler/base/task_queue_impl.h" | 14 #include "components/scheduler/base/task_queue_impl.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 NestableTaskRunnerForTest { |
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 : NestableTaskRunnerForTest(base::MessageLoop::current()->task_runner(), |
40 } | 41 tick_clock.Pass()) {} |
41 ~MessageLoopTaskRunner() override {} | 42 ~MessageLoopTaskRunner() override {} |
42 }; | 43 }; |
43 | 44 |
44 class TaskQueueManagerTest : public testing::Test { | 45 class TaskQueueManagerTest : public testing::Test { |
45 public: | 46 public: |
46 void DeleteTaskQueueManager() { manager_.reset(); } | 47 void DeleteTaskQueueManager() { manager_.reset(); } |
47 | 48 |
48 protected: | 49 protected: |
49 void Initialize(size_t num_queues) { | 50 void InitializeWithClock(size_t num_queues, |
50 now_src_.reset(new base::SimpleTestTickClock()); | 51 scoped_ptr<base::TickClock> test_time_source) { |
51 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | |
52 test_task_runner_ = make_scoped_refptr( | 52 test_task_runner_ = make_scoped_refptr( |
53 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); | 53 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); |
54 main_task_runner_ = | 54 main_task_runner_ = NestableTaskRunnerForTest::Create( |
55 NestableTaskRunnerForTest::Create(test_task_runner_.get()); | 55 test_task_runner_.get(), |
56 make_scoped_ptr(new TestTimeSource(now_src_.get()))); | |
56 manager_ = make_scoped_ptr(new TaskQueueManager( | 57 manager_ = make_scoped_ptr(new TaskQueueManager( |
57 main_task_runner_, "test.scheduler", "test.scheduler", | 58 main_task_runner_, "test.scheduler", "test.scheduler", |
58 "test.scheduler.debug")); | 59 "test.scheduler.debug")); |
59 manager_->SetTimeSourceForTesting( | |
60 make_scoped_ptr(new TestTimeSource(now_src_.get()))); | |
61 | 60 |
62 for (size_t i = 0; i < num_queues; i++) | 61 for (size_t i = 0; i < num_queues; i++) |
63 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 62 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
64 } | 63 } |
65 | 64 |
65 void Initialize(size_t num_queues) { | |
66 now_src_.reset(new base::SimpleTestTickClock()); | |
67 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | |
68 InitializeWithClock(num_queues, | |
69 make_scoped_ptr(new TestTimeSource(now_src_.get()))); | |
70 } | |
71 | |
66 void InitializeWithRealMessageLoop(size_t num_queues) { | 72 void InitializeWithRealMessageLoop(size_t num_queues) { |
67 message_loop_.reset(new base::MessageLoop()); | 73 message_loop_.reset(new base::MessageLoop()); |
68 manager_ = make_scoped_ptr( | 74 manager_ = make_scoped_ptr(new TaskQueueManager( |
69 new TaskQueueManager(MessageLoopTaskRunner::Create(), "test.scheduler", | 75 MessageLoopTaskRunner::Create( |
70 "test.scheduler", "test.scheduler.debug")); | 76 make_scoped_ptr(new TestTimeSource(now_src_.get()))), |
77 "test.scheduler", "test.scheduler", "test.scheduler.debug")); | |
71 | 78 |
72 for (size_t i = 0; i < num_queues; i++) | 79 for (size_t i = 0; i < num_queues; i++) |
73 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); | 80 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); |
74 } | 81 } |
75 | 82 |
76 scoped_ptr<base::MessageLoop> message_loop_; | 83 scoped_ptr<base::MessageLoop> message_loop_; |
77 scoped_ptr<base::SimpleTestTickClock> now_src_; | 84 scoped_ptr<base::SimpleTestTickClock> now_src_; |
78 scoped_refptr<NestableTaskRunnerForTest> main_task_runner_; | 85 scoped_refptr<NestableTaskRunnerForTest> main_task_runner_; |
79 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; | 86 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; |
80 scoped_ptr<TaskQueueManager> manager_; | 87 scoped_ptr<TaskQueueManager> manager_; |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
121 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 128 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
122 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 129 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
123 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 130 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
124 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); | 131 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); |
125 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); | 132 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); |
126 | 133 |
127 test_task_runner_->RunUntilIdle(); | 134 test_task_runner_->RunUntilIdle(); |
128 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); | 135 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); |
129 } | 136 } |
130 | 137 |
131 void NopTask() {} | |
132 | |
133 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { | |
Sami
2015/10/28 20:00:35
Can we still test for this somehow?
alex clarke (OOO till 29th)
2015/10/30 12:12:24
Done.
| |
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) { | 138 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
150 InitializeWithRealMessageLoop(1u); | 139 InitializeWithRealMessageLoop(1u); |
151 | 140 |
152 std::vector<int> run_order; | 141 std::vector<int> run_order; |
153 runners_[0]->PostNonNestableTask(FROM_HERE, | 142 runners_[0]->PostNonNestableTask(FROM_HERE, |
154 base::Bind(&TestTask, 1, &run_order)); | 143 base::Bind(&TestTask, 1, &run_order)); |
155 | 144 |
156 message_loop_->RunUntilIdle(); | 145 message_loop_->RunUntilIdle(); |
157 EXPECT_THAT(run_order, ElementsAre(1)); | 146 EXPECT_THAT(run_order, ElementsAre(1)); |
158 } | 147 } |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
227 // After the delay has completed, the task runs normally. | 216 // After the delay has completed, the task runs normally. |
228 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | 217 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); |
229 EXPECT_THAT(run_order, ElementsAre(1)); | 218 EXPECT_THAT(run_order, ElementsAre(1)); |
230 } | 219 } |
231 | 220 |
232 bool MessageLoopTaskCounter(size_t* count) { | 221 bool MessageLoopTaskCounter(size_t* count) { |
233 *count = *count + 1; | 222 *count = *count + 1; |
234 return true; | 223 return true; |
235 } | 224 } |
236 | 225 |
226 void NopTask() {} | |
227 | |
237 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { | 228 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { |
238 Initialize(1u); | 229 Initialize(1u); |
239 | 230 |
240 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 231 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
241 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay); | 232 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay); |
242 | 233 |
243 size_t task_count = 0; | 234 size_t task_count = 0; |
244 test_task_runner_->RunTasksWhile( | 235 test_task_runner_->RunTasksWhile( |
245 base::Bind(&MessageLoopTaskCounter, &task_count)); | 236 base::Bind(&MessageLoopTaskCounter, &task_count)); |
246 EXPECT_EQ(1u, task_count); | 237 EXPECT_EQ(1u, task_count); |
(...skipping 632 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
879 } | 870 } |
880 | 871 |
881 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 872 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
882 Initialize(1u); | 873 Initialize(1u); |
883 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 874 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
884 manager_.reset(); | 875 manager_.reset(); |
885 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 876 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
886 } | 877 } |
887 | 878 |
888 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { | 879 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { |
889 scoped_ptr<base::SimpleTestTickClock> clock(new base::SimpleTestTickClock()); | |
890 clock->Advance(base::TimeDelta::FromMicroseconds(10000)); | |
891 Initialize(2u); | 880 Initialize(2u); |
892 manager_->SetTimeSourceForTesting( | 881 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); |
893 make_scoped_ptr(new TestTimeSource(clock.get()))); | |
894 | 882 |
895 // With no delayed tasks. | 883 // With no delayed tasks. |
896 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 884 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
897 | 885 |
898 // With a non-delayed task. | 886 // With a non-delayed task. |
899 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 887 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
900 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 888 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
901 | 889 |
902 // With a delayed task. | 890 // With a delayed task. |
903 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 891 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
904 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 892 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
905 EXPECT_EQ(clock->NowTicks() + expected_delay, | 893 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
906 manager_->NextPendingDelayedTaskRunTime()); | 894 manager_->NextPendingDelayedTaskRunTime()); |
907 | 895 |
908 // With another delayed task in the same queue with a longer delay. | 896 // With another delayed task in the same queue with a longer delay. |
909 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 897 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
910 base::TimeDelta::FromMilliseconds(100)); | 898 base::TimeDelta::FromMilliseconds(100)); |
911 EXPECT_EQ(clock->NowTicks() + expected_delay, | 899 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
912 manager_->NextPendingDelayedTaskRunTime()); | 900 manager_->NextPendingDelayedTaskRunTime()); |
913 | 901 |
914 // With another delayed task in the same queue with a shorter delay. | 902 // With another delayed task in the same queue with a shorter delay. |
915 expected_delay = base::TimeDelta::FromMilliseconds(20); | 903 expected_delay = base::TimeDelta::FromMilliseconds(20); |
916 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 904 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
917 EXPECT_EQ(clock->NowTicks() + expected_delay, | 905 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
918 manager_->NextPendingDelayedTaskRunTime()); | 906 manager_->NextPendingDelayedTaskRunTime()); |
919 | 907 |
920 // With another delayed task in a different queue with a shorter delay. | 908 // With another delayed task in a different queue with a shorter delay. |
921 expected_delay = base::TimeDelta::FromMilliseconds(10); | 909 expected_delay = base::TimeDelta::FromMilliseconds(10); |
922 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 910 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
923 EXPECT_EQ(clock->NowTicks() + expected_delay, | 911 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
924 manager_->NextPendingDelayedTaskRunTime()); | 912 manager_->NextPendingDelayedTaskRunTime()); |
925 | 913 |
926 // Test it updates as time progresses | 914 // Test it updates as time progresses |
927 clock->Advance(expected_delay); | 915 now_src_->Advance(expected_delay); |
928 EXPECT_EQ(clock->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); | 916 EXPECT_EQ(now_src_->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); |
929 } | 917 } |
930 | 918 |
931 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { | 919 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { |
932 Initialize(3u); | 920 Initialize(3u); |
933 | 921 |
934 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 922 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
935 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 923 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
936 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 924 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
937 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 925 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
938 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 926 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. | 1349 // release its reference, and checks that it has. |
1362 runners_[0]->PostTask(FROM_HERE, | 1350 runners_[0]->PostTask(FROM_HERE, |
1363 base::Bind(&HasOneRefTask, base::Unretained(&log), | 1351 base::Bind(&HasOneRefTask, base::Unretained(&log), |
1364 base::Unretained(task_queue.get()))); | 1352 base::Unretained(task_queue.get()))); |
1365 message_loop_->RunUntilIdle(); | 1353 message_loop_->RunUntilIdle(); |
1366 | 1354 |
1367 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1355 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1368 } | 1356 } |
1369 | 1357 |
1370 } // namespace scheduler | 1358 } // namespace scheduler |
OLD | NEW |