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) { |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
121 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 129 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
122 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 130 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
123 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 131 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
124 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); | 132 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); |
125 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); | 133 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); |
126 | 134 |
127 test_task_runner_->RunUntilIdle(); | 135 test_task_runner_->RunUntilIdle(); |
128 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); | 136 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); |
129 } | 137 } |
130 | 138 |
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) { | 139 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
150 InitializeWithRealMessageLoop(1u); | 140 InitializeWithRealMessageLoop(1u); |
151 | 141 |
152 std::vector<int> run_order; | 142 std::vector<int> run_order; |
153 runners_[0]->PostNonNestableTask(FROM_HERE, | 143 runners_[0]->PostNonNestableTask(FROM_HERE, |
154 base::Bind(&TestTask, 1, &run_order)); | 144 base::Bind(&TestTask, 1, &run_order)); |
155 | 145 |
156 message_loop_->RunUntilIdle(); | 146 message_loop_->RunUntilIdle(); |
157 EXPECT_THAT(run_order, ElementsAre(1)); | 147 EXPECT_THAT(run_order, ElementsAre(1)); |
158 } | 148 } |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
227 // After the delay has completed, the task runs normally. | 217 // After the delay has completed, the task runs normally. |
228 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | 218 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); |
229 EXPECT_THAT(run_order, ElementsAre(1)); | 219 EXPECT_THAT(run_order, ElementsAre(1)); |
230 } | 220 } |
231 | 221 |
232 bool MessageLoopTaskCounter(size_t* count) { | 222 bool MessageLoopTaskCounter(size_t* count) { |
233 *count = *count + 1; | 223 *count = *count + 1; |
234 return true; | 224 return true; |
235 } | 225 } |
236 | 226 |
| 227 void NopTask() {} |
| 228 |
237 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { | 229 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { |
238 Initialize(1u); | 230 Initialize(1u); |
239 | 231 |
240 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 232 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
241 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay); | 233 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay); |
242 | 234 |
243 size_t task_count = 0; | 235 size_t task_count = 0; |
244 test_task_runner_->RunTasksWhile( | 236 test_task_runner_->RunTasksWhile( |
245 base::Bind(&MessageLoopTaskCounter, &task_count)); | 237 base::Bind(&MessageLoopTaskCounter, &task_count)); |
246 EXPECT_EQ(1u, task_count); | 238 EXPECT_EQ(1u, task_count); |
(...skipping 632 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
879 } | 871 } |
880 | 872 |
881 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 873 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
882 Initialize(1u); | 874 Initialize(1u); |
883 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 875 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
884 manager_.reset(); | 876 manager_.reset(); |
885 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); | 877 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); |
886 } | 878 } |
887 | 879 |
888 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { | 880 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { |
889 scoped_ptr<base::SimpleTestTickClock> clock(new base::SimpleTestTickClock()); | |
890 clock->Advance(base::TimeDelta::FromMicroseconds(10000)); | |
891 Initialize(2u); | 881 Initialize(2u); |
892 manager_->SetTimeSourceForTesting( | 882 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000)); |
893 make_scoped_ptr(new TestTimeSource(clock.get()))); | |
894 | 883 |
895 // With no delayed tasks. | 884 // With no delayed tasks. |
896 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 885 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
897 | 886 |
898 // With a non-delayed task. | 887 // With a non-delayed task. |
899 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 888 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
900 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 889 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
901 | 890 |
902 // With a delayed task. | 891 // With a delayed task. |
903 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 892 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
904 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 893 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
905 EXPECT_EQ(clock->NowTicks() + expected_delay, | 894 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
906 manager_->NextPendingDelayedTaskRunTime()); | 895 manager_->NextPendingDelayedTaskRunTime()); |
907 | 896 |
908 // With another delayed task in the same queue with a longer delay. | 897 // With another delayed task in the same queue with a longer delay. |
909 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 898 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
910 base::TimeDelta::FromMilliseconds(100)); | 899 base::TimeDelta::FromMilliseconds(100)); |
911 EXPECT_EQ(clock->NowTicks() + expected_delay, | 900 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
912 manager_->NextPendingDelayedTaskRunTime()); | 901 manager_->NextPendingDelayedTaskRunTime()); |
913 | 902 |
914 // With another delayed task in the same queue with a shorter delay. | 903 // With another delayed task in the same queue with a shorter delay. |
915 expected_delay = base::TimeDelta::FromMilliseconds(20); | 904 expected_delay = base::TimeDelta::FromMilliseconds(20); |
916 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 905 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
917 EXPECT_EQ(clock->NowTicks() + expected_delay, | 906 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
918 manager_->NextPendingDelayedTaskRunTime()); | 907 manager_->NextPendingDelayedTaskRunTime()); |
919 | 908 |
920 // With another delayed task in a different queue with a shorter delay. | 909 // With another delayed task in a different queue with a shorter delay. |
921 expected_delay = base::TimeDelta::FromMilliseconds(10); | 910 expected_delay = base::TimeDelta::FromMilliseconds(10); |
922 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 911 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
923 EXPECT_EQ(clock->NowTicks() + expected_delay, | 912 EXPECT_EQ(now_src_->NowTicks() + expected_delay, |
924 manager_->NextPendingDelayedTaskRunTime()); | 913 manager_->NextPendingDelayedTaskRunTime()); |
925 | 914 |
926 // Test it updates as time progresses | 915 // Test it updates as time progresses |
927 clock->Advance(expected_delay); | 916 now_src_->Advance(expected_delay); |
928 EXPECT_EQ(clock->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); | 917 EXPECT_EQ(now_src_->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); |
929 } | 918 } |
930 | 919 |
931 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { | 920 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { |
932 Initialize(3u); | 921 Initialize(3u); |
933 | 922 |
934 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 923 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
935 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 924 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
936 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 925 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
937 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 926 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
938 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 927 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. | 1350 // release its reference, and checks that it has. |
1362 runners_[0]->PostTask(FROM_HERE, | 1351 runners_[0]->PostTask(FROM_HERE, |
1363 base::Bind(&HasOneRefTask, base::Unretained(&log), | 1352 base::Bind(&HasOneRefTask, base::Unretained(&log), |
1364 base::Unretained(task_queue.get()))); | 1353 base::Unretained(task_queue.get()))); |
1365 message_loop_->RunUntilIdle(); | 1354 message_loop_->RunUntilIdle(); |
1366 | 1355 |
1367 EXPECT_THAT(log, ElementsAre(false, false, true)); | 1356 EXPECT_THAT(log, ElementsAre(false, false, true)); |
1368 } | 1357 } |
1369 | 1358 |
1370 } // namespace scheduler | 1359 } // namespace scheduler |
OLD | NEW |