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/child/task_queue_manager.h" | 5 #include "components/scheduler/child/task_queue_manager.h" |
6 | 6 |
| 7 #include "base/test/simple_test_tick_clock.h" |
7 #include "base/threading/thread.h" | 8 #include "base/threading/thread.h" |
8 #include "cc/test/ordered_simple_task_runner.h" | 9 #include "cc/test/ordered_simple_task_runner.h" |
9 #include "cc/test/test_now_source.h" | |
10 #include "components/scheduler/child/nestable_task_runner_for_test.h" | 10 #include "components/scheduler/child/nestable_task_runner_for_test.h" |
11 #include "components/scheduler/child/scheduler_message_loop_delegate.h" | 11 #include "components/scheduler/child/scheduler_message_loop_delegate.h" |
12 #include "components/scheduler/child/task_queue_selector.h" | 12 #include "components/scheduler/child/task_queue_selector.h" |
| 13 #include "components/scheduler/child/test_always_fail_time_source.h" |
13 #include "components/scheduler/child/test_time_source.h" | 14 #include "components/scheduler/child/test_time_source.h" |
14 #include "testing/gmock/include/gmock/gmock.h" | 15 #include "testing/gmock/include/gmock/gmock.h" |
15 | 16 |
16 using testing::ElementsAre; | 17 using testing::ElementsAre; |
17 using testing::_; | 18 using testing::_; |
18 | 19 |
19 namespace scheduler { | 20 namespace scheduler { |
20 namespace { | 21 namespace { |
21 | 22 |
22 class SelectorForTest : public TaskQueueSelector { | 23 class SelectorForTest : public TaskQueueSelector { |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
108 public: | 109 public: |
109 void DeleteTaskQueueManager() { manager_.reset(); } | 110 void DeleteTaskQueueManager() { manager_.reset(); } |
110 | 111 |
111 protected: | 112 protected: |
112 enum class SelectorType { | 113 enum class SelectorType { |
113 Automatic, | 114 Automatic, |
114 Explicit, | 115 Explicit, |
115 }; | 116 }; |
116 | 117 |
117 void Initialize(size_t num_queues, SelectorType type) { | 118 void Initialize(size_t num_queues, SelectorType type) { |
118 now_src_ = cc::TestNowSource::Create(1000); | 119 now_src_ = make_scoped_ptr(new base::SimpleTestTickClock()); |
119 test_task_runner_ = | 120 now_src_->Advance(base::TimeDelta::FromInternalValue(1000)); |
120 make_scoped_refptr(new cc::OrderedSimpleTaskRunner(now_src_, false)); | 121 test_task_runner_ = make_scoped_refptr( |
| 122 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); |
121 selector_ = make_scoped_ptr(createSelectorForTest(type)); | 123 selector_ = make_scoped_ptr(createSelectorForTest(type)); |
122 manager_ = make_scoped_ptr(new TaskQueueManager( | 124 manager_ = make_scoped_ptr(new TaskQueueManager( |
123 num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()), | 125 num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()), |
124 selector_.get(), "test.scheduler")); | 126 selector_.get(), "test.scheduler")); |
125 manager_->SetTimeSourceForTesting( | 127 manager_->SetTimeSourceForTesting( |
126 make_scoped_ptr(new TestTimeSource(now_src_))); | 128 make_scoped_ptr(new TestTimeSource(now_src_.get()))); |
127 | 129 |
128 EXPECT_EQ(num_queues, selector_->work_queues().size()); | 130 EXPECT_EQ(num_queues, selector_->work_queues().size()); |
129 } | 131 } |
130 | 132 |
131 void InitializeWithRealMessageLoop(size_t num_queues, SelectorType type) { | 133 void InitializeWithRealMessageLoop(size_t num_queues, SelectorType type) { |
132 message_loop_.reset(new base::MessageLoop()); | 134 message_loop_.reset(new base::MessageLoop()); |
133 selector_ = make_scoped_ptr(createSelectorForTest(type)); | 135 selector_ = make_scoped_ptr(createSelectorForTest(type)); |
134 manager_ = make_scoped_ptr(new TaskQueueManager( | 136 manager_ = make_scoped_ptr(new TaskQueueManager( |
135 num_queues, SchedulerMessageLoopDelegate::Create(message_loop_.get()), | 137 num_queues, SchedulerMessageLoopDelegate::Create(message_loop_.get()), |
136 selector_.get(), "test.scheduler")); | 138 selector_.get(), "test.scheduler")); |
(...skipping 29 matching lines...) Expand all Loading... |
166 &TaskQueueManager::PumpPolicyToString); | 168 &TaskQueueManager::PumpPolicyToString); |
167 } | 169 } |
168 | 170 |
169 static void CheckAllWakeupPolicyToString() { | 171 static void CheckAllWakeupPolicyToString() { |
170 CallForEachEnumValue<TaskQueueManager::WakeupPolicy>( | 172 CallForEachEnumValue<TaskQueueManager::WakeupPolicy>( |
171 TaskQueueManager::WakeupPolicy::FIRST_WAKEUP_POLICY, | 173 TaskQueueManager::WakeupPolicy::FIRST_WAKEUP_POLICY, |
172 TaskQueueManager::WakeupPolicy::WAKEUP_POLICY_COUNT, | 174 TaskQueueManager::WakeupPolicy::WAKEUP_POLICY_COUNT, |
173 &TaskQueueManager::WakeupPolicyToString); | 175 &TaskQueueManager::WakeupPolicyToString); |
174 } | 176 } |
175 | 177 |
176 scoped_refptr<cc::TestNowSource> now_src_; | 178 scoped_ptr<base::SimpleTestTickClock> now_src_; |
177 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; | 179 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; |
178 scoped_ptr<SelectorForTest> selector_; | 180 scoped_ptr<SelectorForTest> selector_; |
179 scoped_ptr<TaskQueueManager> manager_; | 181 scoped_ptr<TaskQueueManager> manager_; |
180 scoped_ptr<base::MessageLoop> message_loop_; | 182 scoped_ptr<base::MessageLoop> message_loop_; |
181 }; | 183 }; |
182 | 184 |
183 void PostFromNestedRunloop(base::MessageLoop* message_loop, | 185 void PostFromNestedRunloop(base::MessageLoop* message_loop, |
184 base::SingleThreadTaskRunner* runner, | 186 base::SingleThreadTaskRunner* runner, |
185 std::vector<std::pair<base::Closure, bool>>* tasks) { | 187 std::vector<std::pair<base::Closure, bool>>* tasks) { |
186 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); | 188 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
242 test_task_runner_->RunUntilIdle(); | 244 test_task_runner_->RunUntilIdle(); |
243 EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6)); | 245 EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6)); |
244 } | 246 } |
245 | 247 |
246 void NopTask() { | 248 void NopTask() { |
247 } | 249 } |
248 | 250 |
249 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { | 251 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { |
250 Initialize(3u, SelectorType::Explicit); | 252 Initialize(3u, SelectorType::Explicit); |
251 | 253 |
252 scoped_refptr<cc::TestNowSource> now_src = cc::TestNowSource::Create(1000); | 254 scoped_ptr<base::SimpleTestTickClock> now_src( |
| 255 new base::SimpleTestTickClock()); |
| 256 now_src->Advance(base::TimeDelta::FromInternalValue(1000)); |
253 manager_->SetTimeSourceForTesting( | 257 manager_->SetTimeSourceForTesting( |
254 make_scoped_ptr(new TestTimeSource(now_src))); | 258 make_scoped_ptr(new TestAlwaysFailTimeSource(now_src.get()))); |
255 | 259 |
256 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { | 260 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { |
257 manager_->TaskRunnerForQueue(0), | 261 manager_->TaskRunnerForQueue(0), |
258 manager_->TaskRunnerForQueue(1), | 262 manager_->TaskRunnerForQueue(1), |
259 manager_->TaskRunnerForQueue(2)}; | 263 manager_->TaskRunnerForQueue(2)}; |
260 | 264 |
261 selector_->AppendQueueToService(0); | 265 selector_->AppendQueueToService(0); |
262 selector_->AppendQueueToService(1); | 266 selector_->AppendQueueToService(1); |
263 selector_->AppendQueueToService(2); | 267 selector_->AppendQueueToService(2); |
264 selector_->AppendQueueToService(0); | 268 selector_->AppendQueueToService(0); |
265 selector_->AppendQueueToService(1); | 269 selector_->AppendQueueToService(1); |
266 selector_->AppendQueueToService(2); | 270 selector_->AppendQueueToService(2); |
267 | 271 |
268 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 272 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
269 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 273 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
270 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 274 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
271 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 275 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
272 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 276 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
273 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 277 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
274 | 278 |
275 test_task_runner_->RunUntilIdle(); | 279 test_task_runner_->RunUntilIdle(); |
276 | |
277 EXPECT_EQ(0, now_src->NumNowCalls()); | |
278 } | 280 } |
279 | 281 |
280 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { | 282 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
281 InitializeWithRealMessageLoop(1u, SelectorType::Automatic); | 283 InitializeWithRealMessageLoop(1u, SelectorType::Automatic); |
282 | 284 |
283 std::vector<int> run_order; | 285 std::vector<int> run_order; |
284 scoped_refptr<base::SingleThreadTaskRunner> runner = | 286 scoped_refptr<base::SingleThreadTaskRunner> runner = |
285 manager_->TaskRunnerForQueue(0); | 287 manager_->TaskRunnerForQueue(0); |
286 | 288 |
287 runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 289 runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
(...skipping 275 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
563 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 565 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
564 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 566 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
565 delay); | 567 delay); |
566 | 568 |
567 // After pumping but before the delay period has expired, task does not run. | 569 // After pumping but before the delay period has expired, task does not run. |
568 manager_->PumpQueue(0); | 570 manager_->PumpQueue(0); |
569 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); | 571 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); |
570 EXPECT_TRUE(run_order.empty()); | 572 EXPECT_TRUE(run_order.empty()); |
571 | 573 |
572 // Once the delay has expired, pumping causes the task to run. | 574 // Once the delay has expired, pumping causes the task to run. |
573 now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(5)); | 575 now_src_->Advance(base::TimeDelta::FromMilliseconds(5)); |
574 manager_->PumpQueue(0); | 576 manager_->PumpQueue(0); |
575 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); | 577 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); |
576 test_task_runner_->RunPendingTasks(); | 578 test_task_runner_->RunPendingTasks(); |
577 EXPECT_THAT(run_order, ElementsAre(1)); | 579 EXPECT_THAT(run_order, ElementsAre(1)); |
578 } | 580 } |
579 | 581 |
580 TEST_F(TaskQueueManagerTest, ManualPumpingWithMultipleDelayedTasks) { | 582 TEST_F(TaskQueueManagerTest, ManualPumpingWithMultipleDelayedTasks) { |
581 Initialize(1u, SelectorType::Automatic); | 583 Initialize(1u, SelectorType::Automatic); |
582 manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL); | 584 manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL); |
583 | 585 |
584 std::vector<int> run_order; | 586 std::vector<int> run_order; |
585 scoped_refptr<base::SingleThreadTaskRunner> runner = | 587 scoped_refptr<base::SingleThreadTaskRunner> runner = |
586 manager_->TaskRunnerForQueue(0); | 588 manager_->TaskRunnerForQueue(0); |
587 | 589 |
588 // Posting a delayed task when pumping will apply the delay, but won't cause | 590 // Posting a delayed task when pumping will apply the delay, but won't cause |
589 // work to executed afterwards. | 591 // work to executed afterwards. |
590 base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1)); | 592 base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1)); |
591 base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10)); | 593 base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10)); |
592 base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20)); | 594 base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20)); |
593 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 595 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
594 delay1); | 596 delay1); |
595 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 597 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
596 delay2); | 598 delay2); |
597 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 599 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
598 delay3); | 600 delay3); |
599 | 601 |
600 now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(15)); | 602 now_src_->Advance(base::TimeDelta::FromMilliseconds(15)); |
601 test_task_runner_->RunUntilIdle(); | 603 test_task_runner_->RunUntilIdle(); |
602 EXPECT_TRUE(run_order.empty()); | 604 EXPECT_TRUE(run_order.empty()); |
603 | 605 |
604 // Once the delay has expired, pumping causes the task to run. | 606 // Once the delay has expired, pumping causes the task to run. |
605 manager_->PumpQueue(0); | 607 manager_->PumpQueue(0); |
606 test_task_runner_->RunUntilIdle(); | 608 test_task_runner_->RunUntilIdle(); |
607 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 609 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
608 } | 610 } |
609 | 611 |
610 TEST_F(TaskQueueManagerTest, DelayedTasksDontAutoRunWithManualPumping) { | 612 TEST_F(TaskQueueManagerTest, DelayedTasksDontAutoRunWithManualPumping) { |
(...skipping 424 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1035 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 1037 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
1036 Initialize(1u, SelectorType::Automatic); | 1038 Initialize(1u, SelectorType::Automatic); |
1037 scoped_refptr<base::SingleThreadTaskRunner> runner = | 1039 scoped_refptr<base::SingleThreadTaskRunner> runner = |
1038 manager_->TaskRunnerForQueue(0); | 1040 manager_->TaskRunnerForQueue(0); |
1039 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); | 1041 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); |
1040 manager_.reset(); | 1042 manager_.reset(); |
1041 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); | 1043 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); |
1042 } | 1044 } |
1043 | 1045 |
1044 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { | 1046 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { |
1045 scoped_refptr<cc::TestNowSource> clock(cc::TestNowSource::Create()); | 1047 scoped_ptr<base::SimpleTestTickClock> clock(new base::SimpleTestTickClock()); |
| 1048 clock->Advance(base::TimeDelta::FromInternalValue(10000)); |
1046 Initialize(2u, SelectorType::Explicit); | 1049 Initialize(2u, SelectorType::Explicit); |
1047 manager_->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock))); | 1050 manager_->SetTimeSourceForTesting( |
| 1051 make_scoped_ptr(new TestTimeSource(clock.get()))); |
1048 | 1052 |
1049 scoped_refptr<base::SingleThreadTaskRunner> runners[2] = { | 1053 scoped_refptr<base::SingleThreadTaskRunner> runners[2] = { |
1050 manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)}; | 1054 manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)}; |
1051 | 1055 |
1052 // With no delayed tasks. | 1056 // With no delayed tasks. |
1053 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 1057 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
1054 | 1058 |
1055 // With a non-delayed task. | 1059 // With a non-delayed task. |
1056 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 1060 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
1057 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 1061 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
1058 | 1062 |
1059 // With a delayed task. | 1063 // With a delayed task. |
1060 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 1064 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
1061 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 1065 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
1062 EXPECT_EQ(clock->Now() + expected_delay, | 1066 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1063 manager_->NextPendingDelayedTaskRunTime()); | 1067 manager_->NextPendingDelayedTaskRunTime()); |
1064 | 1068 |
1065 // With another delayed task in the same queue with a longer delay. | 1069 // With another delayed task in the same queue with a longer delay. |
1066 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 1070 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
1067 base::TimeDelta::FromMilliseconds(100)); | 1071 base::TimeDelta::FromMilliseconds(100)); |
1068 EXPECT_EQ(clock->Now() + expected_delay, | 1072 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1069 manager_->NextPendingDelayedTaskRunTime()); | 1073 manager_->NextPendingDelayedTaskRunTime()); |
1070 | 1074 |
1071 // With another delayed task in the same queue with a shorter delay. | 1075 // With another delayed task in the same queue with a shorter delay. |
1072 expected_delay = base::TimeDelta::FromMilliseconds(20); | 1076 expected_delay = base::TimeDelta::FromMilliseconds(20); |
1073 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 1077 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
1074 EXPECT_EQ(clock->Now() + expected_delay, | 1078 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1075 manager_->NextPendingDelayedTaskRunTime()); | 1079 manager_->NextPendingDelayedTaskRunTime()); |
1076 | 1080 |
1077 // With another delayed task in a different queue with a shorter delay. | 1081 // With another delayed task in a different queue with a shorter delay. |
1078 expected_delay = base::TimeDelta::FromMilliseconds(10); | 1082 expected_delay = base::TimeDelta::FromMilliseconds(10); |
1079 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 1083 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
1080 EXPECT_EQ(clock->Now() + expected_delay, | 1084 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1081 manager_->NextPendingDelayedTaskRunTime()); | 1085 manager_->NextPendingDelayedTaskRunTime()); |
1082 | 1086 |
1083 // Test it updates as time progresses | 1087 // Test it updates as time progresses |
1084 clock->AdvanceNow(expected_delay); | 1088 clock->Advance(expected_delay); |
1085 EXPECT_EQ(clock->Now(), manager_->NextPendingDelayedTaskRunTime()); | 1089 EXPECT_EQ(clock->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); |
1086 } | 1090 } |
1087 | 1091 |
1088 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { | 1092 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { |
1089 Initialize(3u, SelectorType::Automatic); | 1093 Initialize(3u, SelectorType::Automatic); |
1090 | 1094 |
1091 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { | 1095 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { |
1092 manager_->TaskRunnerForQueue(0), | 1096 manager_->TaskRunnerForQueue(0), |
1093 manager_->TaskRunnerForQueue(1), | 1097 manager_->TaskRunnerForQueue(1), |
1094 manager_->TaskRunnerForQueue(2)}; | 1098 manager_->TaskRunnerForQueue(2)}; |
1095 | 1099 |
1096 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 1100 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
1097 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 1101 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
1098 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 1102 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
1099 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 1103 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
1100 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 1104 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); |
1101 runners[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); | 1105 runners[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); |
1102 | 1106 |
1103 EXPECT_EQ(now_src_->Now() + delay2, | 1107 EXPECT_EQ(now_src_->NowTicks() + delay2, |
1104 manager_->NextPendingDelayedTaskRunTime()); | 1108 manager_->NextPendingDelayedTaskRunTime()); |
1105 } | 1109 } |
1106 | 1110 |
1107 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { | 1111 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { |
1108 Initialize(1u, SelectorType::Automatic); | 1112 Initialize(1u, SelectorType::Automatic); |
1109 | 1113 |
1110 scoped_refptr<base::SingleThreadTaskRunner> runner = | 1114 scoped_refptr<base::SingleThreadTaskRunner> runner = |
1111 manager_->TaskRunnerForQueue(0); | 1115 manager_->TaskRunnerForQueue(0); |
1112 runner->PostTask(FROM_HERE, | 1116 runner->PostTask(FROM_HERE, |
1113 base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, | 1117 base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1233 manager_->GetQueueState(1)); | 1237 manager_->GetQueueState(1)); |
1234 | 1238 |
1235 test_task_runner_->RunUntilIdle(); | 1239 test_task_runner_->RunUntilIdle(); |
1236 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, | 1240 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, |
1237 manager_->GetQueueState(0)); | 1241 manager_->GetQueueState(0)); |
1238 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, | 1242 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, |
1239 manager_->GetQueueState(1)); | 1243 manager_->GetQueueState(1)); |
1240 } | 1244 } |
1241 | 1245 |
1242 } // namespace scheduler | 1246 } // namespace scheduler |
OLD | NEW |