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