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_time_source.h" | 13 #include "components/scheduler/child/test_time_source.h" |
14 #include "testing/gmock/include/gmock/gmock.h" | 14 #include "testing/gmock/include/gmock/gmock.h" |
15 | 15 |
16 using testing::ElementsAre; | 16 using testing::ElementsAre; |
17 using testing::_; | 17 using testing::_; |
18 | 18 |
19 namespace scheduler { | 19 namespace scheduler { |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
108 public: | 108 public: |
109 void DeleteTaskQueueManager() { manager_.reset(); } | 109 void DeleteTaskQueueManager() { manager_.reset(); } |
110 | 110 |
111 protected: | 111 protected: |
112 enum class SelectorType { | 112 enum class SelectorType { |
113 Automatic, | 113 Automatic, |
114 Explicit, | 114 Explicit, |
115 }; | 115 }; |
116 | 116 |
117 void Initialize(size_t num_queues, SelectorType type) { | 117 void Initialize(size_t num_queues, SelectorType type) { |
118 now_src_ = cc::TestNowSource::Create(1000); | 118 now_src_ = new base::SimpleTestTickClock(); |
119 now_src_->Advance(base::TimeDelta::FromInternalValue(1000)); | |
119 test_task_runner_ = | 120 test_task_runner_ = |
120 make_scoped_refptr(new cc::OrderedSimpleTaskRunner(now_src_, false)); | 121 make_scoped_refptr(new cc::OrderedSimpleTaskRunner(now_src_, false)); |
121 selector_ = make_scoped_ptr(createSelectorForTest(type)); | 122 selector_ = make_scoped_ptr(createSelectorForTest(type)); |
122 manager_ = make_scoped_ptr(new TaskQueueManager( | 123 manager_ = make_scoped_ptr(new TaskQueueManager( |
123 num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()), | 124 num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()), |
124 selector_.get(), "test.scheduler")); | 125 selector_.get(), "test.scheduler")); |
125 manager_->SetTimeSourceForTesting( | 126 manager_->SetTimeSourceForTesting( |
126 make_scoped_ptr(new TestTimeSource(now_src_))); | 127 make_scoped_ptr(new TestTimeSource(now_src_))); |
127 | 128 |
128 EXPECT_EQ(num_queues, selector_->work_queues().size()); | 129 EXPECT_EQ(num_queues, selector_->work_queues().size()); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
166 &TaskQueueManager::PumpPolicyToString); | 167 &TaskQueueManager::PumpPolicyToString); |
167 } | 168 } |
168 | 169 |
169 static void CheckAllWakeupPolicyToString() { | 170 static void CheckAllWakeupPolicyToString() { |
170 CallForEachEnumValue<TaskQueueManager::WakeupPolicy>( | 171 CallForEachEnumValue<TaskQueueManager::WakeupPolicy>( |
171 TaskQueueManager::WakeupPolicy::FIRST_WAKEUP_POLICY, | 172 TaskQueueManager::WakeupPolicy::FIRST_WAKEUP_POLICY, |
172 TaskQueueManager::WakeupPolicy::WAKEUP_POLICY_COUNT, | 173 TaskQueueManager::WakeupPolicy::WAKEUP_POLICY_COUNT, |
173 &TaskQueueManager::WakeupPolicyToString); | 174 &TaskQueueManager::WakeupPolicyToString); |
174 } | 175 } |
175 | 176 |
176 scoped_refptr<cc::TestNowSource> now_src_; | 177 base::SimpleTestTickClock* now_src_; |
177 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; | 178 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; |
178 scoped_ptr<SelectorForTest> selector_; | 179 scoped_ptr<SelectorForTest> selector_; |
179 scoped_ptr<TaskQueueManager> manager_; | 180 scoped_ptr<TaskQueueManager> manager_; |
180 scoped_ptr<base::MessageLoop> message_loop_; | 181 scoped_ptr<base::MessageLoop> message_loop_; |
181 }; | 182 }; |
182 | 183 |
183 void PostFromNestedRunloop(base::MessageLoop* message_loop, | 184 void PostFromNestedRunloop(base::MessageLoop* message_loop, |
184 base::SingleThreadTaskRunner* runner, | 185 base::SingleThreadTaskRunner* runner, |
185 std::vector<std::pair<base::Closure, bool>>* tasks) { | 186 std::vector<std::pair<base::Closure, bool>>* tasks) { |
186 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); | 187 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
239 runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); | 240 runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); |
240 runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); | 241 runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); |
241 | 242 |
242 test_task_runner_->RunUntilIdle(); | 243 test_task_runner_->RunUntilIdle(); |
243 EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6)); | 244 EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6)); |
244 } | 245 } |
245 | 246 |
246 void NopTask() { | 247 void NopTask() { |
247 } | 248 } |
248 | 249 |
249 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { | 250 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) { |
mithro-old
2015/05/29 08:26:48
Sami, this seems like a very weird test - any idea
Sami
2015/05/29 14:00:58
The idea is to avoid reading the current time anyw
mithro-old
2015/06/01 03:37:37
Yeah, maybe we should log a cleanup bug about chan
Ankur Verma
2015/06/01 05:30:44
Should i exclude this cleanup request for this par
mithro-old
2015/06/01 07:32:15
I logged a bug about this issue at https://code.go
Ankur Verma
2015/06/01 09:21:40
Yes i understand. I am thinking of renaming the te
mithro-old
2015/06/01 11:31:20
I don't think you want booleans or anything inside
Ankur Verma
2015/06/03 14:56:10
Done.
| |
250 Initialize(3u, SelectorType::Explicit); | 251 Initialize(3u, SelectorType::Explicit); |
251 | 252 |
252 scoped_refptr<cc::TestNowSource> now_src = cc::TestNowSource::Create(1000); | 253 base::SimpleTestTickClock* now_src = new base::SimpleTestTickClock(); |
254 now_src->Advance(base::TimeDelta::FromInternalValue(1000)); | |
253 manager_->SetTimeSourceForTesting( | 255 manager_->SetTimeSourceForTesting( |
254 make_scoped_ptr(new TestTimeSource(now_src))); | 256 make_scoped_ptr(new TestTimeSource(now_src))); |
255 | 257 |
256 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { | 258 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { |
257 manager_->TaskRunnerForQueue(0), | 259 manager_->TaskRunnerForQueue(0), |
258 manager_->TaskRunnerForQueue(1), | 260 manager_->TaskRunnerForQueue(1), |
259 manager_->TaskRunnerForQueue(2)}; | 261 manager_->TaskRunnerForQueue(2)}; |
260 | 262 |
261 selector_->AppendQueueToService(0); | 263 selector_->AppendQueueToService(0); |
262 selector_->AppendQueueToService(1); | 264 selector_->AppendQueueToService(1); |
263 selector_->AppendQueueToService(2); | 265 selector_->AppendQueueToService(2); |
264 selector_->AppendQueueToService(0); | 266 selector_->AppendQueueToService(0); |
265 selector_->AppendQueueToService(1); | 267 selector_->AppendQueueToService(1); |
266 selector_->AppendQueueToService(2); | 268 selector_->AppendQueueToService(2); |
267 | 269 |
268 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 270 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
269 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 271 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
270 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 272 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
271 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 273 runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
272 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 274 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
273 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 275 runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
274 | 276 |
275 test_task_runner_->RunUntilIdle(); | 277 test_task_runner_->RunUntilIdle(); |
276 | 278 |
277 EXPECT_EQ(0, now_src->NumNowCalls()); | 279 TestTimeSource* test_time_src = |
280 static_cast<TestTimeSource*>(manager_->GetTimeSourceForTesting()); | |
281 EXPECT_EQ(0, test_time_src->NumNowCalls()); | |
278 } | 282 } |
279 | 283 |
280 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { | 284 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
281 InitializeWithRealMessageLoop(1u, SelectorType::Automatic); | 285 InitializeWithRealMessageLoop(1u, SelectorType::Automatic); |
282 | 286 |
283 std::vector<int> run_order; | 287 std::vector<int> run_order; |
284 scoped_refptr<base::SingleThreadTaskRunner> runner = | 288 scoped_refptr<base::SingleThreadTaskRunner> runner = |
285 manager_->TaskRunnerForQueue(0); | 289 manager_->TaskRunnerForQueue(0); |
286 | 290 |
287 runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 291 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)); | 567 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
564 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 568 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
565 delay); | 569 delay); |
566 | 570 |
567 // After pumping but before the delay period has expired, task does not run. | 571 // After pumping but before the delay period has expired, task does not run. |
568 manager_->PumpQueue(0); | 572 manager_->PumpQueue(0); |
569 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); | 573 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); |
570 EXPECT_TRUE(run_order.empty()); | 574 EXPECT_TRUE(run_order.empty()); |
571 | 575 |
572 // Once the delay has expired, pumping causes the task to run. | 576 // Once the delay has expired, pumping causes the task to run. |
573 now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(5)); | 577 now_src_->Advance(base::TimeDelta::FromMilliseconds(5)); |
574 manager_->PumpQueue(0); | 578 manager_->PumpQueue(0); |
575 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); | 579 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); |
576 test_task_runner_->RunPendingTasks(); | 580 test_task_runner_->RunPendingTasks(); |
577 EXPECT_THAT(run_order, ElementsAre(1)); | 581 EXPECT_THAT(run_order, ElementsAre(1)); |
578 } | 582 } |
579 | 583 |
580 TEST_F(TaskQueueManagerTest, ManualPumpingWithMultipleDelayedTasks) { | 584 TEST_F(TaskQueueManagerTest, ManualPumpingWithMultipleDelayedTasks) { |
581 Initialize(1u, SelectorType::Automatic); | 585 Initialize(1u, SelectorType::Automatic); |
582 manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL); | 586 manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL); |
583 | 587 |
584 std::vector<int> run_order; | 588 std::vector<int> run_order; |
585 scoped_refptr<base::SingleThreadTaskRunner> runner = | 589 scoped_refptr<base::SingleThreadTaskRunner> runner = |
586 manager_->TaskRunnerForQueue(0); | 590 manager_->TaskRunnerForQueue(0); |
587 | 591 |
588 // Posting a delayed task when pumping will apply the delay, but won't cause | 592 // Posting a delayed task when pumping will apply the delay, but won't cause |
589 // work to executed afterwards. | 593 // work to executed afterwards. |
590 base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1)); | 594 base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1)); |
591 base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10)); | 595 base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10)); |
592 base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20)); | 596 base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20)); |
593 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 597 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
594 delay1); | 598 delay1); |
595 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 599 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
596 delay2); | 600 delay2); |
597 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 601 runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
598 delay3); | 602 delay3); |
599 | 603 |
600 now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(15)); | 604 now_src_->Advance(base::TimeDelta::FromMilliseconds(15)); |
601 test_task_runner_->RunUntilIdle(); | 605 test_task_runner_->RunUntilIdle(); |
602 EXPECT_TRUE(run_order.empty()); | 606 EXPECT_TRUE(run_order.empty()); |
603 | 607 |
604 // Once the delay has expired, pumping causes the task to run. | 608 // Once the delay has expired, pumping causes the task to run. |
605 manager_->PumpQueue(0); | 609 manager_->PumpQueue(0); |
606 test_task_runner_->RunUntilIdle(); | 610 test_task_runner_->RunUntilIdle(); |
607 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 611 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
608 } | 612 } |
609 | 613 |
610 TEST_F(TaskQueueManagerTest, DelayedTasksDontAutoRunWithManualPumping) { | 614 TEST_F(TaskQueueManagerTest, DelayedTasksDontAutoRunWithManualPumping) { |
(...skipping 424 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1035 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { | 1039 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { |
1036 Initialize(1u, SelectorType::Automatic); | 1040 Initialize(1u, SelectorType::Automatic); |
1037 scoped_refptr<base::SingleThreadTaskRunner> runner = | 1041 scoped_refptr<base::SingleThreadTaskRunner> runner = |
1038 manager_->TaskRunnerForQueue(0); | 1042 manager_->TaskRunnerForQueue(0); |
1039 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); | 1043 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); |
1040 manager_.reset(); | 1044 manager_.reset(); |
1041 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); | 1045 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); |
1042 } | 1046 } |
1043 | 1047 |
1044 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { | 1048 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { |
1045 scoped_refptr<cc::TestNowSource> clock(cc::TestNowSource::Create()); | 1049 base::SimpleTestTickClock* clock = new base::SimpleTestTickClock(); |
1050 clock->Advance(base::TimeDelta::FromInternalValue(10000)); | |
Sami
2015/05/29 14:00:58
Where did the value 10000 come from?
Ankur Verma
2015/06/01 05:30:44
cc::TestNowSource::Create() had internally started
| |
1046 Initialize(2u, SelectorType::Explicit); | 1051 Initialize(2u, SelectorType::Explicit); |
1047 manager_->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock))); | 1052 manager_->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock))); |
1048 | 1053 |
1049 scoped_refptr<base::SingleThreadTaskRunner> runners[2] = { | 1054 scoped_refptr<base::SingleThreadTaskRunner> runners[2] = { |
1050 manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)}; | 1055 manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)}; |
1051 | 1056 |
1052 // With no delayed tasks. | 1057 // With no delayed tasks. |
1053 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 1058 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
1054 | 1059 |
1055 // With a non-delayed task. | 1060 // With a non-delayed task. |
1056 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); | 1061 runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); |
1057 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); | 1062 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); |
1058 | 1063 |
1059 // With a delayed task. | 1064 // With a delayed task. |
1060 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); | 1065 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); |
1061 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 1066 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
1062 EXPECT_EQ(clock->Now() + expected_delay, | 1067 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1063 manager_->NextPendingDelayedTaskRunTime()); | 1068 manager_->NextPendingDelayedTaskRunTime()); |
1064 | 1069 |
1065 // With another delayed task in the same queue with a longer delay. | 1070 // With another delayed task in the same queue with a longer delay. |
1066 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 1071 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
1067 base::TimeDelta::FromMilliseconds(100)); | 1072 base::TimeDelta::FromMilliseconds(100)); |
1068 EXPECT_EQ(clock->Now() + expected_delay, | 1073 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1069 manager_->NextPendingDelayedTaskRunTime()); | 1074 manager_->NextPendingDelayedTaskRunTime()); |
1070 | 1075 |
1071 // With another delayed task in the same queue with a shorter delay. | 1076 // With another delayed task in the same queue with a shorter delay. |
1072 expected_delay = base::TimeDelta::FromMilliseconds(20); | 1077 expected_delay = base::TimeDelta::FromMilliseconds(20); |
1073 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 1078 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
1074 EXPECT_EQ(clock->Now() + expected_delay, | 1079 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1075 manager_->NextPendingDelayedTaskRunTime()); | 1080 manager_->NextPendingDelayedTaskRunTime()); |
1076 | 1081 |
1077 // With another delayed task in a different queue with a shorter delay. | 1082 // With another delayed task in a different queue with a shorter delay. |
1078 expected_delay = base::TimeDelta::FromMilliseconds(10); | 1083 expected_delay = base::TimeDelta::FromMilliseconds(10); |
1079 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); | 1084 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); |
1080 EXPECT_EQ(clock->Now() + expected_delay, | 1085 EXPECT_EQ(clock->NowTicks() + expected_delay, |
1081 manager_->NextPendingDelayedTaskRunTime()); | 1086 manager_->NextPendingDelayedTaskRunTime()); |
1082 | 1087 |
1083 // Test it updates as time progresses | 1088 // Test it updates as time progresses |
1084 clock->AdvanceNow(expected_delay); | 1089 clock->Advance(expected_delay); |
1085 EXPECT_EQ(clock->Now(), manager_->NextPendingDelayedTaskRunTime()); | 1090 EXPECT_EQ(clock->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); |
1086 } | 1091 } |
1087 | 1092 |
1088 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { | 1093 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { |
1089 Initialize(3u, SelectorType::Automatic); | 1094 Initialize(3u, SelectorType::Automatic); |
1090 | 1095 |
1091 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { | 1096 scoped_refptr<base::SingleThreadTaskRunner> runners[3] = { |
1092 manager_->TaskRunnerForQueue(0), | 1097 manager_->TaskRunnerForQueue(0), |
1093 manager_->TaskRunnerForQueue(1), | 1098 manager_->TaskRunnerForQueue(1), |
1094 manager_->TaskRunnerForQueue(2)}; | 1099 manager_->TaskRunnerForQueue(2)}; |
1095 | 1100 |
1096 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); | 1101 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); |
1097 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 1102 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
1098 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); | 1103 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); |
1099 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); | 1104 runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); |
1100 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); | 1105 runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); |
1101 runners[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); | 1106 runners[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3); |
1102 | 1107 |
1103 EXPECT_EQ(now_src_->Now() + delay2, | 1108 EXPECT_EQ(now_src_->NowTicks() + delay2, |
1104 manager_->NextPendingDelayedTaskRunTime()); | 1109 manager_->NextPendingDelayedTaskRunTime()); |
1105 } | 1110 } |
1106 | 1111 |
1107 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { | 1112 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) { |
1108 Initialize(1u, SelectorType::Automatic); | 1113 Initialize(1u, SelectorType::Automatic); |
1109 | 1114 |
1110 scoped_refptr<base::SingleThreadTaskRunner> runner = | 1115 scoped_refptr<base::SingleThreadTaskRunner> runner = |
1111 manager_->TaskRunnerForQueue(0); | 1116 manager_->TaskRunnerForQueue(0); |
1112 runner->PostTask(FROM_HERE, | 1117 runner->PostTask(FROM_HERE, |
1113 base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, | 1118 base::Bind(&TaskQueueManagerTest::DeleteTaskQueueManager, |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1233 manager_->GetQueueState(1)); | 1238 manager_->GetQueueState(1)); |
1234 | 1239 |
1235 test_task_runner_->RunUntilIdle(); | 1240 test_task_runner_->RunUntilIdle(); |
1236 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, | 1241 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, |
1237 manager_->GetQueueState(0)); | 1242 manager_->GetQueueState(0)); |
1238 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, | 1243 EXPECT_EQ(TaskQueueManager::QueueState::EMPTY, |
1239 manager_->GetQueueState(1)); | 1244 manager_->GetQueueState(1)); |
1240 } | 1245 } |
1241 | 1246 |
1242 } // namespace scheduler | 1247 } // namespace scheduler |
OLD | NEW |