OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/idle_helper.h" | 5 #include "components/scheduler/child/idle_helper.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
| 8 #include "base/test/simple_test_tick_clock.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_helper.h" | 11 #include "components/scheduler/child/scheduler_helper.h" |
12 #include "components/scheduler/child/scheduler_message_loop_delegate.h" | 12 #include "components/scheduler/child/scheduler_message_loop_delegate.h" |
13 #include "components/scheduler/child/task_queue_manager.h" | 13 #include "components/scheduler/child/task_queue_manager.h" |
14 #include "components/scheduler/child/test_time_source.h" | 14 #include "components/scheduler/child/test_time_source.h" |
15 #include "testing/gmock/include/gmock/gmock.h" | 15 #include "testing/gmock/include/gmock/gmock.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 | 17 |
18 using testing::_; | 18 using testing::_; |
19 using testing::AnyNumber; | 19 using testing::AnyNumber; |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
78 base::TimeDelta delay) { | 78 base::TimeDelta delay) { |
79 if (num_repeats > 1) { | 79 if (num_repeats > 1) { |
80 task_runner->PostDelayedTask( | 80 task_runner->PostDelayedTask( |
81 FROM_HERE, base::Bind(&RepeatingTask, base::Unretained(task_runner), | 81 FROM_HERE, base::Bind(&RepeatingTask, base::Unretained(task_runner), |
82 num_repeats - 1, delay), | 82 num_repeats - 1, delay), |
83 delay); | 83 delay); |
84 } | 84 } |
85 } | 85 } |
86 | 86 |
87 void UpdateClockToDeadlineIdleTestTask( | 87 void UpdateClockToDeadlineIdleTestTask( |
88 scoped_refptr<cc::TestNowSource> clock, | 88 base::SimpleTestTickClock* clock, |
89 base::SingleThreadTaskRunner* task_runner, | 89 base::SingleThreadTaskRunner* task_runner, |
90 int* run_count, | 90 int* run_count, |
91 base::TimeTicks deadline) { | 91 base::TimeTicks deadline) { |
92 clock->SetNow(deadline); | 92 clock->Advance(deadline - clock->NowTicks()); |
93 // Due to the way in which OrderedSimpleTestRunner orders tasks and the fact | 93 // Due to the way in which OrderedSimpleTestRunner orders tasks and the fact |
94 // that we updated the time within a task, the delayed pending task to call | 94 // that we updated the time within a task, the delayed pending task to call |
95 // EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so | 95 // EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so |
96 // post a normal task here to ensure it runs before the next idle task. | 96 // post a normal task here to ensure it runs before the next idle task. |
97 task_runner->PostTask(FROM_HERE, base::Bind(NullTask)); | 97 task_runner->PostTask(FROM_HERE, base::Bind(NullTask)); |
98 (*run_count)++; | 98 (*run_count)++; |
99 } | 99 } |
100 | 100 |
101 scoped_refptr<NestableSingleThreadTaskRunner> | 101 scoped_refptr<NestableSingleThreadTaskRunner> |
102 CreateNestableSingleThreadTaskRunner( | 102 CreateNestableSingleThreadTaskRunner( |
(...skipping 28 matching lines...) Expand all Loading... |
131 base::TimeDelta* next_long_idle_period_delay_out)); | 131 base::TimeDelta* next_long_idle_period_delay_out)); |
132 | 132 |
133 MOCK_METHOD0(IsNotQuiescent, void()); | 133 MOCK_METHOD0(IsNotQuiescent, void()); |
134 }; | 134 }; |
135 | 135 |
136 class BaseIdleHelperTest : public testing::Test { | 136 class BaseIdleHelperTest : public testing::Test { |
137 public: | 137 public: |
138 BaseIdleHelperTest( | 138 BaseIdleHelperTest( |
139 base::MessageLoop* message_loop, | 139 base::MessageLoop* message_loop, |
140 base::TimeDelta required_quiescence_duration_before_long_idle_period) | 140 base::TimeDelta required_quiescence_duration_before_long_idle_period) |
141 : clock_(cc::TestNowSource::Create(5000)), | 141 : clock_(new base::SimpleTestTickClock()), message_loop_(message_loop) { |
142 mock_task_runner_(message_loop | 142 clock_->Advance(base::TimeDelta::FromInternalValue(5000)); |
143 ? nullptr | 143 mock_task_runner_ = |
144 : new cc::OrderedSimpleTaskRunner(clock_, false)), | 144 message_loop ? nullptr |
145 message_loop_(message_loop), | 145 : new cc::OrderedSimpleTaskRunner(clock_.get(), false); |
146 nestable_task_runner_( | 146 nestable_task_runner_ = |
147 CreateNestableSingleThreadTaskRunner(message_loop, | 147 CreateNestableSingleThreadTaskRunner(message_loop, mock_task_runner_); |
148 mock_task_runner_)), | 148 scheduler_helper_ = make_scoped_ptr( |
149 scheduler_helper_( | 149 new SchedulerHelper(nestable_task_runner_, "test.idle", |
150 new SchedulerHelper(nestable_task_runner_, | 150 TRACE_DISABLED_BY_DEFAULT("test.idle"), |
151 "test.idle", | 151 SchedulerHelper::TASK_QUEUE_COUNT + 1)); |
152 TRACE_DISABLED_BY_DEFAULT("test.idle"), | 152 idle_helper_ = make_scoped_ptr(new IdleHelperForTest( |
153 SchedulerHelper::TASK_QUEUE_COUNT + 1)), | 153 scheduler_helper_.get(), |
154 idle_helper_(new IdleHelperForTest( | 154 required_quiescence_duration_before_long_idle_period)); |
155 scheduler_helper_.get(), | 155 default_task_runner_ = scheduler_helper_->DefaultTaskRunner(); |
156 required_quiescence_duration_before_long_idle_period)), | 156 idle_task_runner_ = idle_helper_->IdleTaskRunner(); |
157 default_task_runner_(scheduler_helper_->DefaultTaskRunner()), | |
158 idle_task_runner_(idle_helper_->IdleTaskRunner()) { | |
159 scheduler_helper_->SetTimeSourceForTesting( | 157 scheduler_helper_->SetTimeSourceForTesting( |
160 make_scoped_ptr(new TestTimeSource(clock_))); | 158 make_scoped_ptr(new TestTimeSource(clock_.get()))); |
161 scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting( | 159 scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting( |
162 make_scoped_ptr(new TestTimeSource(clock_))); | 160 make_scoped_ptr(new TestTimeSource(clock_.get()))); |
163 } | 161 } |
164 | 162 |
165 ~BaseIdleHelperTest() override {} | 163 ~BaseIdleHelperTest() override {} |
166 | 164 |
167 void TearDown() override { | 165 void TearDown() override { |
168 DCHECK(!mock_task_runner_.get() || !message_loop_.get()); | 166 DCHECK(!mock_task_runner_.get() || !message_loop_.get()); |
169 if (mock_task_runner_.get()) { | 167 if (mock_task_runner_.get()) { |
170 // Check that all tests stop posting tasks. | 168 // Check that all tests stop posting tasks. |
171 mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 169 mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
172 while (mock_task_runner_->RunUntilIdle()) { | 170 while (mock_task_runner_->RunUntilIdle()) { |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
207 return base::TimeDelta::FromMilliseconds( | 205 return base::TimeDelta::FromMilliseconds( |
208 IdleHelper::kMaximumIdlePeriodMillis); | 206 IdleHelper::kMaximumIdlePeriodMillis); |
209 } | 207 } |
210 | 208 |
211 base::TimeTicks CurrentIdleTaskDeadlineForTesting() { | 209 base::TimeTicks CurrentIdleTaskDeadlineForTesting() { |
212 base::TimeTicks deadline; | 210 base::TimeTicks deadline; |
213 idle_helper_->CurrentIdleTaskDeadlineCallback(&deadline); | 211 idle_helper_->CurrentIdleTaskDeadlineCallback(&deadline); |
214 return deadline; | 212 return deadline; |
215 } | 213 } |
216 | 214 |
217 scoped_refptr<cc::TestNowSource> clock_; | 215 scoped_ptr<base::SimpleTestTickClock> clock_; |
218 // Only one of mock_task_runner_ or message_loop_ will be set. | 216 // Only one of mock_task_runner_ or message_loop_ will be set. |
219 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; | 217 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; |
220 scoped_ptr<base::MessageLoop> message_loop_; | 218 scoped_ptr<base::MessageLoop> message_loop_; |
221 | 219 |
222 scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_; | 220 scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_; |
223 scoped_ptr<SchedulerHelper> scheduler_helper_; | 221 scoped_ptr<SchedulerHelper> scheduler_helper_; |
224 scoped_ptr<IdleHelperForTest> idle_helper_; | 222 scoped_ptr<IdleHelperForTest> idle_helper_; |
225 scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_; | 223 scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_; |
226 scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_; | 224 scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_; |
227 | 225 |
(...skipping 10 matching lines...) Expand all Loading... |
238 return scheduler_helper_->GetTaskQueueManagerForTesting(); | 236 return scheduler_helper_->GetTaskQueueManagerForTesting(); |
239 } | 237 } |
240 | 238 |
241 private: | 239 private: |
242 DISALLOW_COPY_AND_ASSIGN(IdleHelperTest); | 240 DISALLOW_COPY_AND_ASSIGN(IdleHelperTest); |
243 }; | 241 }; |
244 | 242 |
245 TEST_F(IdleHelperTest, TestPostIdleTask) { | 243 TEST_F(IdleHelperTest, TestPostIdleTask) { |
246 int run_count = 0; | 244 int run_count = 0; |
247 base::TimeTicks expected_deadline = | 245 base::TimeTicks expected_deadline = |
248 clock_->Now() + base::TimeDelta::FromMilliseconds(2300); | 246 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300); |
249 base::TimeTicks deadline_in_task; | 247 base::TimeTicks deadline_in_task; |
250 | 248 |
251 clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100)); | 249 clock_->Advance(base::TimeDelta::FromMilliseconds(100)); |
252 idle_task_runner_->PostIdleTask( | 250 idle_task_runner_->PostIdleTask( |
253 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 251 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
254 | 252 |
255 RunUntilIdle(); | 253 RunUntilIdle(); |
256 EXPECT_EQ(0, run_count); | 254 EXPECT_EQ(0, run_count); |
257 | 255 |
258 idle_helper_->StartIdlePeriod( | 256 idle_helper_->StartIdlePeriod( |
259 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 257 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
260 expected_deadline, true); | 258 expected_deadline, true); |
261 RunUntilIdle(); | 259 RunUntilIdle(); |
262 EXPECT_EQ(1, run_count); | 260 EXPECT_EQ(1, run_count); |
263 EXPECT_EQ(expected_deadline, deadline_in_task); | 261 EXPECT_EQ(expected_deadline, deadline_in_task); |
264 } | 262 } |
265 | 263 |
266 TEST_F(IdleHelperTest, TestPostIdleTask_EndIdlePeriod) { | 264 TEST_F(IdleHelperTest, TestPostIdleTask_EndIdlePeriod) { |
267 int run_count = 0; | 265 int run_count = 0; |
268 base::TimeTicks deadline_in_task; | 266 base::TimeTicks deadline_in_task; |
269 | 267 |
270 clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100)); | 268 clock_->Advance(base::TimeDelta::FromMilliseconds(100)); |
271 idle_task_runner_->PostIdleTask( | 269 idle_task_runner_->PostIdleTask( |
272 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 270 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
273 | 271 |
274 RunUntilIdle(); | 272 RunUntilIdle(); |
275 EXPECT_EQ(0, run_count); | 273 EXPECT_EQ(0, run_count); |
276 | 274 |
277 idle_helper_->StartIdlePeriod( | 275 idle_helper_->StartIdlePeriod( |
278 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 276 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
279 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 277 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
280 idle_helper_->EndIdlePeriod(); | 278 idle_helper_->EndIdlePeriod(); |
281 RunUntilIdle(); | 279 RunUntilIdle(); |
282 EXPECT_EQ(0, run_count); | 280 EXPECT_EQ(0, run_count); |
283 } | 281 } |
284 | 282 |
285 TEST_F(IdleHelperTest, TestRepostingIdleTask) { | 283 TEST_F(IdleHelperTest, TestRepostingIdleTask) { |
286 int run_count = 0; | 284 int run_count = 0; |
287 | 285 |
288 max_idle_task_reposts = 2; | 286 max_idle_task_reposts = 2; |
289 idle_task_runner_->PostIdleTask( | 287 idle_task_runner_->PostIdleTask( |
290 FROM_HERE, | 288 FROM_HERE, |
291 base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count)); | 289 base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count)); |
292 idle_helper_->StartIdlePeriod( | 290 idle_helper_->StartIdlePeriod( |
293 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 291 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
294 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 292 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
295 RunUntilIdle(); | 293 RunUntilIdle(); |
296 EXPECT_EQ(1, run_count); | 294 EXPECT_EQ(1, run_count); |
297 | 295 |
298 // Reposted tasks shouldn't run until next idle period. | 296 // Reposted tasks shouldn't run until next idle period. |
299 RunUntilIdle(); | 297 RunUntilIdle(); |
300 EXPECT_EQ(1, run_count); | 298 EXPECT_EQ(1, run_count); |
301 | 299 |
302 idle_helper_->StartIdlePeriod( | 300 idle_helper_->StartIdlePeriod( |
303 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 301 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
304 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 302 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
305 RunUntilIdle(); | 303 RunUntilIdle(); |
306 EXPECT_EQ(2, run_count); | 304 EXPECT_EQ(2, run_count); |
307 } | 305 } |
308 | 306 |
309 TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) { | 307 TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) { |
310 int run_count = 0; | 308 int run_count = 0; |
311 | 309 |
312 // Post two UpdateClockToDeadlineIdleTestTask tasks. | 310 // Post two UpdateClockToDeadlineIdleTestTask tasks. |
313 idle_task_runner_->PostIdleTask( | 311 idle_task_runner_->PostIdleTask( |
314 FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, | 312 FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), |
315 default_task_runner_, &run_count)); | 313 default_task_runner_, &run_count)); |
316 idle_task_runner_->PostIdleTask( | 314 idle_task_runner_->PostIdleTask( |
317 FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, | 315 FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), |
318 default_task_runner_, &run_count)); | 316 default_task_runner_, &run_count)); |
319 | 317 |
320 idle_helper_->StartIdlePeriod( | 318 idle_helper_->StartIdlePeriod( |
321 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 319 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
322 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 320 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
323 RunUntilIdle(); | 321 RunUntilIdle(); |
324 // Only the first idle task should execute since it's used up the deadline. | 322 // Only the first idle task should execute since it's used up the deadline. |
325 EXPECT_EQ(1, run_count); | 323 EXPECT_EQ(1, run_count); |
326 | 324 |
327 idle_helper_->EndIdlePeriod(); | 325 idle_helper_->EndIdlePeriod(); |
328 idle_helper_->StartIdlePeriod( | 326 idle_helper_->StartIdlePeriod( |
329 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 327 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
330 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 328 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
331 RunUntilIdle(); | 329 RunUntilIdle(); |
332 // Second task should be run on the next idle period. | 330 // Second task should be run on the next idle period. |
333 EXPECT_EQ(2, run_count); | 331 EXPECT_EQ(2, run_count); |
334 } | 332 } |
335 | 333 |
336 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) { | 334 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) { |
337 base::TimeTicks deadline_in_task; | 335 base::TimeTicks deadline_in_task; |
338 int run_count = 0; | 336 int run_count = 0; |
339 | 337 |
340 idle_task_runner_->PostIdleTaskAfterWakeup( | 338 idle_task_runner_->PostIdleTaskAfterWakeup( |
341 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 339 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
342 | 340 |
343 idle_helper_->StartIdlePeriod( | 341 idle_helper_->StartIdlePeriod( |
344 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 342 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
345 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 343 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
346 RunUntilIdle(); | 344 RunUntilIdle(); |
347 // Shouldn't run yet as no other task woke up the scheduler. | 345 // Shouldn't run yet as no other task woke up the scheduler. |
348 EXPECT_EQ(0, run_count); | 346 EXPECT_EQ(0, run_count); |
349 | 347 |
350 idle_task_runner_->PostIdleTaskAfterWakeup( | 348 idle_task_runner_->PostIdleTaskAfterWakeup( |
351 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 349 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
352 | 350 |
353 idle_helper_->StartIdlePeriod( | 351 idle_helper_->StartIdlePeriod( |
354 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 352 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
355 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 353 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
356 RunUntilIdle(); | 354 RunUntilIdle(); |
357 // Another after wakeup idle task shouldn't wake the scheduler. | 355 // Another after wakeup idle task shouldn't wake the scheduler. |
358 EXPECT_EQ(0, run_count); | 356 EXPECT_EQ(0, run_count); |
359 | 357 |
360 default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask)); | 358 default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask)); |
361 | 359 |
362 RunUntilIdle(); | 360 RunUntilIdle(); |
363 // Must start a new idle period before idle task runs. | 361 // Must start a new idle period before idle task runs. |
364 idle_helper_->StartIdlePeriod( | 362 idle_helper_->StartIdlePeriod( |
365 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 363 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
366 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 364 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
367 RunUntilIdle(); | 365 RunUntilIdle(); |
368 // Execution of default task queue task should trigger execution of idle task. | 366 // Execution of default task queue task should trigger execution of idle task. |
369 EXPECT_EQ(2, run_count); | 367 EXPECT_EQ(2, run_count); |
370 } | 368 } |
371 | 369 |
372 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) { | 370 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) { |
373 base::TimeTicks deadline_in_task; | 371 base::TimeTicks deadline_in_task; |
374 int run_count = 0; | 372 int run_count = 0; |
375 | 373 |
376 idle_task_runner_->PostIdleTaskAfterWakeup( | 374 idle_task_runner_->PostIdleTaskAfterWakeup( |
377 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 375 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
378 default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask)); | 376 default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask)); |
379 | 377 |
380 RunUntilIdle(); | 378 RunUntilIdle(); |
381 // Must start a new idle period before idle task runs. | 379 // Must start a new idle period before idle task runs. |
382 idle_helper_->StartIdlePeriod( | 380 idle_helper_->StartIdlePeriod( |
383 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 381 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
384 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 382 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
385 RunUntilIdle(); | 383 RunUntilIdle(); |
386 // Should run as the scheduler was already awakened by the normal task. | 384 // Should run as the scheduler was already awakened by the normal task. |
387 EXPECT_EQ(1, run_count); | 385 EXPECT_EQ(1, run_count); |
388 } | 386 } |
389 | 387 |
390 TEST_F(IdleHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) { | 388 TEST_F(IdleHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) { |
391 base::TimeTicks deadline_in_task; | 389 base::TimeTicks deadline_in_task; |
392 int run_count = 0; | 390 int run_count = 0; |
393 | 391 |
394 idle_task_runner_->PostIdleTaskAfterWakeup( | 392 idle_task_runner_->PostIdleTaskAfterWakeup( |
395 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 393 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
396 idle_task_runner_->PostIdleTask( | 394 idle_task_runner_->PostIdleTask( |
397 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 395 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
398 | 396 |
399 idle_helper_->StartIdlePeriod( | 397 idle_helper_->StartIdlePeriod( |
400 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 398 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
401 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 399 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
402 RunUntilIdle(); | 400 RunUntilIdle(); |
403 // Must start a new idle period before after-wakeup idle task runs. | 401 // Must start a new idle period before after-wakeup idle task runs. |
404 idle_helper_->StartIdlePeriod( | 402 idle_helper_->StartIdlePeriod( |
405 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 403 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
406 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 404 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
407 RunUntilIdle(); | 405 RunUntilIdle(); |
408 // Normal idle task should wake up after-wakeup idle task. | 406 // Normal idle task should wake up after-wakeup idle task. |
409 EXPECT_EQ(2, run_count); | 407 EXPECT_EQ(2, run_count); |
410 } | 408 } |
411 | 409 |
412 TEST_F(IdleHelperTest, TestDelayedEndIdlePeriod) { | 410 TEST_F(IdleHelperTest, TestDelayedEndIdlePeriod) { |
413 mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 411 mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
414 | 412 |
415 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 413 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
416 .Times(2) | 414 .Times(2) |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
468 std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) { | 466 std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) { |
469 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get()); | 467 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get()); |
470 for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) { | 468 for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) { |
471 if (pair.second) { | 469 if (pair.second) { |
472 idle_task_runner_->PostIdleTask(FROM_HERE, pair.first); | 470 idle_task_runner_->PostIdleTask(FROM_HERE, pair.first); |
473 } else { | 471 } else { |
474 idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first); | 472 idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first); |
475 } | 473 } |
476 } | 474 } |
477 idle_helper_->StartIdlePeriod( | 475 idle_helper_->StartIdlePeriod( |
478 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 476 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
479 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 477 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
480 message_loop_->RunUntilIdle(); | 478 message_loop_->RunUntilIdle(); |
481 } | 479 } |
482 | 480 |
483 private: | 481 private: |
484 DISALLOW_COPY_AND_ASSIGN(IdleHelperWithMessageLoopTest); | 482 DISALLOW_COPY_AND_ASSIGN(IdleHelperWithMessageLoopTest); |
485 }; | 483 }; |
486 | 484 |
487 TEST_F(IdleHelperWithMessageLoopTest, | 485 TEST_F(IdleHelperWithMessageLoopTest, |
488 NonNestableIdleTaskDoesntExecuteInNestedLoop) { | 486 NonNestableIdleTaskDoesntExecuteInNestedLoop) { |
489 std::vector<std::string> order; | 487 std::vector<std::string> order; |
(...skipping 14 matching lines...) Expand all Loading... |
504 tasks_to_post_from_nested_loop.push_back(std::make_pair( | 502 tasks_to_post_from_nested_loop.push_back(std::make_pair( |
505 base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true)); | 503 base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true)); |
506 | 504 |
507 default_task_runner_->PostTask( | 505 default_task_runner_->PostTask( |
508 FROM_HERE, | 506 FROM_HERE, |
509 base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop, | 507 base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop, |
510 base::Unretained(this), | 508 base::Unretained(this), |
511 base::Unretained(&tasks_to_post_from_nested_loop))); | 509 base::Unretained(&tasks_to_post_from_nested_loop))); |
512 | 510 |
513 idle_helper_->StartIdlePeriod( | 511 idle_helper_->StartIdlePeriod( |
514 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 512 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
515 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 513 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
516 RunUntilIdle(); | 514 RunUntilIdle(); |
517 // Note we expect task 3 to run last because it's non-nestable. | 515 // Note we expect task 3 to run last because it's non-nestable. |
518 EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"), | 516 EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"), |
519 std::string("4"), std::string("5"), | 517 std::string("4"), std::string("5"), |
520 std::string("3"))); | 518 std::string("3"))); |
521 } | 519 } |
522 | 520 |
523 TEST_F(IdleHelperTest, TestLongIdlePeriod) { | 521 TEST_F(IdleHelperTest, TestLongIdlePeriod) { |
524 base::TimeTicks expected_deadline = | 522 base::TimeTicks expected_deadline = |
525 clock_->Now() + maximum_idle_period_duration(); | 523 clock_->NowTicks() + maximum_idle_period_duration(); |
526 base::TimeTicks deadline_in_task; | 524 base::TimeTicks deadline_in_task; |
527 int run_count = 0; | 525 int run_count = 0; |
528 | 526 |
529 idle_task_runner_->PostIdleTask( | 527 idle_task_runner_->PostIdleTask( |
530 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 528 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
531 | 529 |
532 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 530 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
533 .Times(2) | 531 .Times(2) |
534 .WillRepeatedly(Return(true)); | 532 .WillRepeatedly(Return(true)); |
535 | 533 |
536 RunUntilIdle(); | 534 RunUntilIdle(); |
537 EXPECT_EQ(0, run_count); // Shouldn't run yet as no idle period. | 535 EXPECT_EQ(0, run_count); // Shouldn't run yet as no idle period. |
538 | 536 |
539 idle_helper_->EnableLongIdlePeriod(); | 537 idle_helper_->EnableLongIdlePeriod(); |
540 RunUntilIdle(); | 538 RunUntilIdle(); |
541 EXPECT_EQ(1, run_count); // Should have run in a long idle time. | 539 EXPECT_EQ(1, run_count); // Should have run in a long idle time. |
542 EXPECT_EQ(expected_deadline, deadline_in_task); | 540 EXPECT_EQ(expected_deadline, deadline_in_task); |
543 } | 541 } |
544 | 542 |
545 TEST_F(IdleHelperTest, TestLongIdlePeriodWithPendingDelayedTask) { | 543 TEST_F(IdleHelperTest, TestLongIdlePeriodWithPendingDelayedTask) { |
546 base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30); | 544 base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30); |
547 base::TimeTicks expected_deadline = clock_->Now() + pending_task_delay; | 545 base::TimeTicks expected_deadline = clock_->NowTicks() + pending_task_delay; |
548 base::TimeTicks deadline_in_task; | 546 base::TimeTicks deadline_in_task; |
549 int run_count = 0; | 547 int run_count = 0; |
550 | 548 |
551 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 549 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
552 .Times(2) | 550 .Times(2) |
553 .WillRepeatedly(Return(true)); | 551 .WillRepeatedly(Return(true)); |
554 | 552 |
555 idle_task_runner_->PostIdleTask( | 553 idle_task_runner_->PostIdleTask( |
556 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 554 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
557 default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask), | 555 default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask), |
(...skipping 11 matching lines...) Expand all Loading... |
569 int run_count = 0; | 567 int run_count = 0; |
570 | 568 |
571 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 569 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
572 .Times(3) | 570 .Times(3) |
573 .WillRepeatedly(Return(true)); | 571 .WillRepeatedly(Return(true)); |
574 | 572 |
575 default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask), | 573 default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask), |
576 pending_task_delay); | 574 pending_task_delay); |
577 | 575 |
578 // Advance clock until after delayed task was meant to be run. | 576 // Advance clock until after delayed task was meant to be run. |
579 clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(20)); | 577 clock_->Advance(base::TimeDelta::FromMilliseconds(20)); |
580 | 578 |
581 // Post an idle task and then EnableLongIdlePeriod. Since there is a late | 579 // Post an idle task and then EnableLongIdlePeriod. Since there is a late |
582 // pending delayed task this shouldn't actually start an idle period. | 580 // pending delayed task this shouldn't actually start an idle period. |
583 idle_task_runner_->PostIdleTask( | 581 idle_task_runner_->PostIdleTask( |
584 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 582 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
585 idle_helper_->EnableLongIdlePeriod(); | 583 idle_helper_->EnableLongIdlePeriod(); |
586 RunUntilIdle(); | 584 RunUntilIdle(); |
587 EXPECT_EQ(0, run_count); | 585 EXPECT_EQ(0, run_count); |
588 | 586 |
589 // After the delayed task has been run we should trigger an idle period. | 587 // After the delayed task has been run we should trigger an idle period. |
590 clock_->AdvanceNow(maximum_idle_period_duration()); | 588 clock_->Advance(maximum_idle_period_duration()); |
591 RunUntilIdle(); | 589 RunUntilIdle(); |
592 EXPECT_EQ(1, run_count); | 590 EXPECT_EQ(1, run_count); |
593 } | 591 } |
594 | 592 |
595 TEST_F(IdleHelperTest, TestLongIdlePeriodRepeating) { | 593 TEST_F(IdleHelperTest, TestLongIdlePeriodRepeating) { |
596 int run_count = 0; | 594 int run_count = 0; |
597 | 595 |
598 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 596 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
599 .Times(2) | 597 .Times(2) |
600 .WillRepeatedly(Return(true)); | 598 .WillRepeatedly(Return(true)); |
601 | 599 |
602 max_idle_task_reposts = 3; | 600 max_idle_task_reposts = 3; |
603 idle_task_runner_->PostIdleTask( | 601 idle_task_runner_->PostIdleTask( |
604 FROM_HERE, | 602 FROM_HERE, |
605 base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count)); | 603 base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count)); |
606 | 604 |
607 idle_helper_->EnableLongIdlePeriod(); | 605 idle_helper_->EnableLongIdlePeriod(); |
608 RunUntilIdle(); | 606 RunUntilIdle(); |
609 EXPECT_EQ(1, run_count); // Should only run once per idle period. | 607 EXPECT_EQ(1, run_count); // Should only run once per idle period. |
610 | 608 |
611 // Advance time to start of next long idle period and check task reposted task | 609 // Advance time to start of next long idle period and check task reposted task |
612 // gets run. | 610 // gets run. |
613 clock_->AdvanceNow(maximum_idle_period_duration()); | 611 clock_->Advance(maximum_idle_period_duration()); |
614 RunUntilIdle(); | 612 RunUntilIdle(); |
615 EXPECT_EQ(2, run_count); | 613 EXPECT_EQ(2, run_count); |
616 | 614 |
617 // Advance time to start of next long idle period then end the idle period and | 615 // Advance time to start of next long idle period then end the idle period and |
618 // check the task doesn't get run. | 616 // check the task doesn't get run. |
619 clock_->AdvanceNow(maximum_idle_period_duration()); | 617 clock_->Advance(maximum_idle_period_duration()); |
620 idle_helper_->EndIdlePeriod(); | 618 idle_helper_->EndIdlePeriod(); |
621 RunUntilIdle(); | 619 RunUntilIdle(); |
622 EXPECT_EQ(2, run_count); | 620 EXPECT_EQ(2, run_count); |
623 } | 621 } |
624 | 622 |
625 TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) { | 623 TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) { |
626 base::TimeTicks deadline_in_task; | 624 base::TimeTicks deadline_in_task; |
627 int run_count = 0; | 625 int run_count = 0; |
628 | 626 |
629 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 627 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
630 .Times(3) | 628 .Times(3) |
631 .WillRepeatedly(Return(true)); | 629 .WillRepeatedly(Return(true)); |
632 | 630 |
633 // Start a long idle period and get the time it should end. | 631 // Start a long idle period and get the time it should end. |
634 idle_helper_->EnableLongIdlePeriod(); | 632 idle_helper_->EnableLongIdlePeriod(); |
635 // The scheduler should not run the initiate_next_long_idle_period task if | 633 // The scheduler should not run the initiate_next_long_idle_period task if |
636 // there are no idle tasks and no other task woke up the scheduler, thus | 634 // there are no idle tasks and no other task woke up the scheduler, thus |
637 // the idle period deadline shouldn't update at the end of the current long | 635 // the idle period deadline shouldn't update at the end of the current long |
638 // idle period. | 636 // idle period. |
639 base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); | 637 base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); |
640 clock_->AdvanceNow(maximum_idle_period_duration()); | 638 clock_->Advance(maximum_idle_period_duration()); |
641 RunUntilIdle(); | 639 RunUntilIdle(); |
642 | 640 |
643 base::TimeTicks new_idle_period_deadline = | 641 base::TimeTicks new_idle_period_deadline = |
644 CurrentIdleTaskDeadlineForTesting(); | 642 CurrentIdleTaskDeadlineForTesting(); |
645 EXPECT_EQ(idle_period_deadline, new_idle_period_deadline); | 643 EXPECT_EQ(idle_period_deadline, new_idle_period_deadline); |
646 | 644 |
647 // Posting a after-wakeup idle task also shouldn't wake the scheduler or | 645 // Posting a after-wakeup idle task also shouldn't wake the scheduler or |
648 // initiate the next long idle period. | 646 // initiate the next long idle period. |
649 idle_task_runner_->PostIdleTaskAfterWakeup( | 647 idle_task_runner_->PostIdleTaskAfterWakeup( |
650 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 648 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
651 RunUntilIdle(); | 649 RunUntilIdle(); |
652 new_idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); | 650 new_idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); |
653 EXPECT_EQ(idle_period_deadline, new_idle_period_deadline); | 651 EXPECT_EQ(idle_period_deadline, new_idle_period_deadline); |
654 EXPECT_EQ(0, run_count); | 652 EXPECT_EQ(0, run_count); |
655 | 653 |
656 // Running a normal task should initiate a new long idle period though. | 654 // Running a normal task should initiate a new long idle period though. |
657 default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask)); | 655 default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask)); |
658 RunUntilIdle(); | 656 RunUntilIdle(); |
659 new_idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); | 657 new_idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); |
660 EXPECT_EQ(idle_period_deadline + maximum_idle_period_duration(), | 658 EXPECT_EQ(idle_period_deadline + maximum_idle_period_duration(), |
661 new_idle_period_deadline); | 659 new_idle_period_deadline); |
662 | 660 |
663 EXPECT_EQ(1, run_count); | 661 EXPECT_EQ(1, run_count); |
664 } | 662 } |
665 | 663 |
666 TEST_F(IdleHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) { | 664 TEST_F(IdleHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) { |
667 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(1000); | 665 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(1000); |
668 base::TimeDelta halfDelay = base::TimeDelta::FromMilliseconds(500); | 666 base::TimeDelta halfDelay = base::TimeDelta::FromMilliseconds(500); |
669 base::TimeTicks delayOver = clock_->Now() + delay; | 667 base::TimeTicks delayOver = clock_->NowTicks() + delay; |
670 base::TimeTicks deadline_in_task; | 668 base::TimeTicks deadline_in_task; |
671 int run_count = 0; | 669 int run_count = 0; |
672 | 670 |
673 ON_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) | 671 ON_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)) |
674 .WillByDefault(Invoke( | 672 .WillByDefault(Invoke( |
675 [delay, delayOver](base::TimeTicks now, | 673 [delay, delayOver](base::TimeTicks now, |
676 base::TimeDelta* next_long_idle_period_delay_out) { | 674 base::TimeDelta* next_long_idle_period_delay_out) { |
677 if (now >= delayOver) | 675 if (now >= delayOver) |
678 return true; | 676 return true; |
679 *next_long_idle_period_delay_out = delay; | 677 *next_long_idle_period_delay_out = delay; |
680 return false; | 678 return false; |
681 })); | 679 })); |
682 | 680 |
683 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(3); | 681 EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(3); |
684 | 682 |
685 idle_task_runner_->PostIdleTask( | 683 idle_task_runner_->PostIdleTask( |
686 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 684 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
687 | 685 |
688 // Make sure Idle tasks don't run until the delay has occured. | 686 // Make sure Idle tasks don't run until the delay has occured. |
689 idle_helper_->EnableLongIdlePeriod(); | 687 idle_helper_->EnableLongIdlePeriod(); |
690 RunUntilIdle(); | 688 RunUntilIdle(); |
691 EXPECT_EQ(0, run_count); | 689 EXPECT_EQ(0, run_count); |
692 | 690 |
693 clock_->AdvanceNow(halfDelay); | 691 clock_->Advance(halfDelay); |
694 RunUntilIdle(); | 692 RunUntilIdle(); |
695 EXPECT_EQ(0, run_count); | 693 EXPECT_EQ(0, run_count); |
696 | 694 |
697 // Delay is finished, idle task should run. | 695 // Delay is finished, idle task should run. |
698 clock_->AdvanceNow(halfDelay); | 696 clock_->Advance(halfDelay); |
699 RunUntilIdle(); | 697 RunUntilIdle(); |
700 EXPECT_EQ(1, run_count); | 698 EXPECT_EQ(1, run_count); |
701 } | 699 } |
702 | 700 |
703 void TestCanExceedIdleDeadlineIfRequiredTask(IdleHelperForTest* idle_helper, | 701 void TestCanExceedIdleDeadlineIfRequiredTask(IdleHelperForTest* idle_helper, |
704 bool* can_exceed_idle_deadline_out, | 702 bool* can_exceed_idle_deadline_out, |
705 int* run_count, | 703 int* run_count, |
706 base::TimeTicks deadline) { | 704 base::TimeTicks deadline) { |
707 *can_exceed_idle_deadline_out = | 705 *can_exceed_idle_deadline_out = |
708 idle_helper->CanExceedIdleDeadlineIfRequired(); | 706 idle_helper->CanExceedIdleDeadlineIfRequired(); |
(...skipping 10 matching lines...) Expand all Loading... |
719 | 717 |
720 // Should return false if not in an idle period. | 718 // Should return false if not in an idle period. |
721 EXPECT_FALSE(idle_helper_->CanExceedIdleDeadlineIfRequired()); | 719 EXPECT_FALSE(idle_helper_->CanExceedIdleDeadlineIfRequired()); |
722 | 720 |
723 // Should return false for short idle periods. | 721 // Should return false for short idle periods. |
724 idle_task_runner_->PostIdleTask( | 722 idle_task_runner_->PostIdleTask( |
725 FROM_HERE, | 723 FROM_HERE, |
726 base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), | 724 base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), |
727 &can_exceed_idle_deadline, &run_count)); | 725 &can_exceed_idle_deadline, &run_count)); |
728 idle_helper_->StartIdlePeriod( | 726 idle_helper_->StartIdlePeriod( |
729 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), | 727 IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
730 clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); | 728 clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
731 RunUntilIdle(); | 729 RunUntilIdle(); |
732 EXPECT_EQ(1, run_count); | 730 EXPECT_EQ(1, run_count); |
733 EXPECT_FALSE(can_exceed_idle_deadline); | 731 EXPECT_FALSE(can_exceed_idle_deadline); |
734 | 732 |
735 // Should return false for a long idle period which is shortened due to a | 733 // Should return false for a long idle period which is shortened due to a |
736 // pending delayed task. | 734 // pending delayed task. |
737 default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask), | 735 default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask), |
738 base::TimeDelta::FromMilliseconds(10)); | 736 base::TimeDelta::FromMilliseconds(10)); |
739 idle_task_runner_->PostIdleTask( | 737 idle_task_runner_->PostIdleTask( |
740 FROM_HERE, | 738 FROM_HERE, |
741 base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), | 739 base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), |
742 &can_exceed_idle_deadline, &run_count)); | 740 &can_exceed_idle_deadline, &run_count)); |
743 idle_helper_->EnableLongIdlePeriod(); | 741 idle_helper_->EnableLongIdlePeriod(); |
744 RunUntilIdle(); | 742 RunUntilIdle(); |
745 EXPECT_EQ(2, run_count); | 743 EXPECT_EQ(2, run_count); |
746 EXPECT_FALSE(can_exceed_idle_deadline); | 744 EXPECT_FALSE(can_exceed_idle_deadline); |
747 | 745 |
748 // Next long idle period will be for the maximum time, so | 746 // Next long idle period will be for the maximum time, so |
749 // CanExceedIdleDeadlineIfRequired should return true. | 747 // CanExceedIdleDeadlineIfRequired should return true. |
750 clock_->AdvanceNow(maximum_idle_period_duration()); | 748 clock_->Advance(maximum_idle_period_duration()); |
751 idle_task_runner_->PostIdleTask( | 749 idle_task_runner_->PostIdleTask( |
752 FROM_HERE, | 750 FROM_HERE, |
753 base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), | 751 base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), |
754 &can_exceed_idle_deadline, &run_count)); | 752 &can_exceed_idle_deadline, &run_count)); |
755 RunUntilIdle(); | 753 RunUntilIdle(); |
756 EXPECT_EQ(3, run_count); | 754 EXPECT_EQ(3, run_count); |
757 EXPECT_TRUE(can_exceed_idle_deadline); | 755 EXPECT_TRUE(can_exceed_idle_deadline); |
758 } | 756 } |
759 | 757 |
760 class IdleHelperWithQuiescencePeriodTest : public BaseIdleHelperTest { | 758 class IdleHelperWithQuiescencePeriodTest : public BaseIdleHelperTest { |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
829 // Run a repeating task so we're deemed to be busy for the next 400ms. | 827 // Run a repeating task so we're deemed to be busy for the next 400ms. |
830 default_task_runner_->PostTask( | 828 default_task_runner_->PostTask( |
831 FROM_HERE, | 829 FROM_HERE, |
832 base::Bind(&RepeatingTask, base::Unretained(default_task_runner_.get()), | 830 base::Bind(&RepeatingTask, base::Unretained(default_task_runner_.get()), |
833 10, base::TimeDelta::FromMilliseconds(40))); | 831 10, base::TimeDelta::FromMilliseconds(40))); |
834 | 832 |
835 int run_count = 0; | 833 int run_count = 0; |
836 // In this scenario EnableLongIdlePeriod deems us not to be quiescent 5x in | 834 // In this scenario EnableLongIdlePeriod deems us not to be quiescent 5x in |
837 // a row. | 835 // a row. |
838 base::TimeTicks expected_deadline = | 836 base::TimeTicks expected_deadline = |
839 clock_->Now() + base::TimeDelta::FromMilliseconds(5 * kQuiescenceDelayMs + | 837 clock_->NowTicks() + base::TimeDelta::FromMilliseconds( |
840 kLongIdlePeriodMs); | 838 5 * kQuiescenceDelayMs + kLongIdlePeriodMs); |
841 base::TimeTicks deadline_in_task; | 839 base::TimeTicks deadline_in_task; |
842 idle_task_runner_->PostIdleTask( | 840 idle_task_runner_->PostIdleTask( |
843 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 841 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
844 | 842 |
845 idle_helper_->EnableLongIdlePeriod(); | 843 idle_helper_->EnableLongIdlePeriod(); |
846 RunUntilIdle(); | 844 RunUntilIdle(); |
847 EXPECT_EQ(1, run_count); | 845 EXPECT_EQ(1, run_count); |
848 EXPECT_EQ(expected_deadline, deadline_in_task); | 846 EXPECT_EQ(expected_deadline, deadline_in_task); |
849 } | 847 } |
850 | 848 |
(...skipping 14 matching lines...) Expand all Loading... |
865 // EnableLongIdlePeriod task was posted on an after wakeup runner. | 863 // EnableLongIdlePeriod task was posted on an after wakeup runner. |
866 idle_task_runner_->PostIdleTask( | 864 idle_task_runner_->PostIdleTask( |
867 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); | 865 FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
868 RunUntilIdle(); | 866 RunUntilIdle(); |
869 EXPECT_EQ(0, run_count); | 867 EXPECT_EQ(0, run_count); |
870 | 868 |
871 // Post a normal task to wake the system up. The idle task won't run | 869 // Post a normal task to wake the system up. The idle task won't run |
872 // immediately because the system isn't judged to be quiescent until the | 870 // immediately because the system isn't judged to be quiescent until the |
873 // second time EnableLongIdlePeriod is run. | 871 // second time EnableLongIdlePeriod is run. |
874 base::TimeTicks expected_deadline = | 872 base::TimeTicks expected_deadline = |
875 clock_->Now() + | 873 clock_->NowTicks() + |
876 base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs); | 874 base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs); |
877 default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask)); | 875 default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask)); |
878 RunUntilIdle(); | 876 RunUntilIdle(); |
879 | 877 |
880 EXPECT_EQ(1, run_count); | 878 EXPECT_EQ(1, run_count); |
881 EXPECT_EQ(expected_deadline, deadline_in_task); | 879 EXPECT_EQ(expected_deadline, deadline_in_task); |
882 } | 880 } |
883 | 881 |
884 } // namespace scheduler | 882 } // namespace scheduler |
OLD | NEW |