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 "platform/scheduler/child/worker_scheduler_impl.h" | 5 #include "platform/scheduler/child/worker_scheduler_impl.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/macros.h" | 8 #include "base/macros.h" |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/strings/stringprintf.h" | 10 #include "base/strings/stringprintf.h" |
(...skipping 222 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
233 } | 233 } |
234 | 234 |
235 TEST_F(WorkerSchedulerImplTest, TestIdleTaskWhenIsNotQuiescent) { | 235 TEST_F(WorkerSchedulerImplTest, TestIdleTaskWhenIsNotQuiescent) { |
236 std::vector<std::string> timeline; | 236 std::vector<std::string> timeline; |
237 RecordTimelineEvents(&timeline); | 237 RecordTimelineEvents(&timeline); |
238 Init(); | 238 Init(); |
239 | 239 |
240 timeline.push_back("Post default task"); | 240 timeline.push_back("Post default task"); |
241 // Post a delayed task timed to occur mid way during the long idle period. | 241 // Post a delayed task timed to occur mid way during the long idle period. |
242 default_task_runner_->PostTask( | 242 default_task_runner_->PostTask( |
243 FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline), | 243 FROM_HERE, |
244 base::Unretained(clock_.get()))); | 244 base::Bind(&RecordTimelineTask, base::Unretained(&timeline), |
| 245 base::Unretained(clock_.get()))); |
245 RunUntilIdle(); | 246 RunUntilIdle(); |
246 | 247 |
247 timeline.push_back("Post idle task"); | 248 timeline.push_back("Post idle task"); |
248 idle_task_runner_->PostIdleTask(FROM_HERE, | 249 idle_task_runner_->PostIdleTask(FROM_HERE, |
249 base::Bind(&TimelineIdleTestTask, &timeline)); | 250 base::Bind(&TimelineIdleTestTask, &timeline)); |
250 | 251 |
251 RunUntilIdle(); | 252 RunUntilIdle(); |
252 | 253 |
253 std::string expected_timeline[] = {"CanEnterLongIdlePeriod @ 5", | 254 std::string expected_timeline[] = {"CanEnterLongIdlePeriod @ 5", |
254 "Post default task", | 255 "Post default task", |
255 "run RecordTimelineTask @ 5", | 256 "run RecordTimelineTask @ 5", |
256 "Post idle task", | 257 "Post idle task", |
257 "IsNotQuiescent @ 5", | 258 "IsNotQuiescent @ 5", |
258 "CanEnterLongIdlePeriod @ 305", | 259 "CanEnterLongIdlePeriod @ 305", |
259 "run TimelineIdleTestTask deadline 355"}; | 260 "run TimelineIdleTestTask deadline 355"}; |
260 | 261 |
261 EXPECT_THAT(timeline, ElementsAreArray(expected_timeline)); | 262 EXPECT_THAT(timeline, ElementsAreArray(expected_timeline)); |
262 } | 263 } |
263 | 264 |
264 TEST_F(WorkerSchedulerImplTest, TestIdleDeadlineWithPendingDelayedTask) { | 265 TEST_F(WorkerSchedulerImplTest, TestIdleDeadlineWithPendingDelayedTask) { |
265 std::vector<std::string> timeline; | 266 std::vector<std::string> timeline; |
266 RecordTimelineEvents(&timeline); | 267 RecordTimelineEvents(&timeline); |
267 Init(); | 268 Init(); |
268 | 269 |
269 timeline.push_back("Post delayed and idle tasks"); | 270 timeline.push_back("Post delayed and idle tasks"); |
270 // Post a delayed task timed to occur mid way during the long idle period. | 271 // Post a delayed task timed to occur mid way during the long idle period. |
271 default_task_runner_->PostDelayedTask( | 272 default_task_runner_->PostDelayedTask( |
272 FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline), | 273 FROM_HERE, |
273 base::Unretained(clock_.get())), | 274 base::Bind(&RecordTimelineTask, base::Unretained(&timeline), |
| 275 base::Unretained(clock_.get())), |
274 base::TimeDelta::FromMilliseconds(20)); | 276 base::TimeDelta::FromMilliseconds(20)); |
275 idle_task_runner_->PostIdleTask(FROM_HERE, | 277 idle_task_runner_->PostIdleTask(FROM_HERE, |
276 base::Bind(&TimelineIdleTestTask, &timeline)); | 278 base::Bind(&TimelineIdleTestTask, &timeline)); |
277 | 279 |
278 RunUntilIdle(); | 280 RunUntilIdle(); |
279 | 281 |
280 std::string expected_timeline[] = { | 282 std::string expected_timeline[] = { |
281 "CanEnterLongIdlePeriod @ 5", "Post delayed and idle tasks", | 283 "CanEnterLongIdlePeriod @ 5", "Post delayed and idle tasks", |
282 "CanEnterLongIdlePeriod @ 5", | 284 "CanEnterLongIdlePeriod @ 5", |
283 "run TimelineIdleTestTask deadline 25", // Note the short 20ms deadline. | 285 "run TimelineIdleTestTask deadline 25", // Note the short 20ms deadline. |
284 "run RecordTimelineTask @ 25"}; | 286 "run RecordTimelineTask @ 25"}; |
285 | 287 |
286 EXPECT_THAT(timeline, ElementsAreArray(expected_timeline)); | 288 EXPECT_THAT(timeline, ElementsAreArray(expected_timeline)); |
287 } | 289 } |
288 | 290 |
289 TEST_F(WorkerSchedulerImplTest, | 291 TEST_F(WorkerSchedulerImplTest, |
290 TestIdleDeadlineWithPendingDelayedTaskFarInTheFuture) { | 292 TestIdleDeadlineWithPendingDelayedTaskFarInTheFuture) { |
291 std::vector<std::string> timeline; | 293 std::vector<std::string> timeline; |
292 RecordTimelineEvents(&timeline); | 294 RecordTimelineEvents(&timeline); |
293 Init(); | 295 Init(); |
294 | 296 |
295 timeline.push_back("Post delayed and idle tasks"); | 297 timeline.push_back("Post delayed and idle tasks"); |
296 // Post a delayed task timed to occur well after the long idle period. | 298 // Post a delayed task timed to occur well after the long idle period. |
297 default_task_runner_->PostDelayedTask( | 299 default_task_runner_->PostDelayedTask( |
298 FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline), | 300 FROM_HERE, |
299 base::Unretained(clock_.get())), | 301 base::Bind(&RecordTimelineTask, base::Unretained(&timeline), |
| 302 base::Unretained(clock_.get())), |
300 base::TimeDelta::FromMilliseconds(500)); | 303 base::TimeDelta::FromMilliseconds(500)); |
301 idle_task_runner_->PostIdleTask(FROM_HERE, | 304 idle_task_runner_->PostIdleTask(FROM_HERE, |
302 base::Bind(&TimelineIdleTestTask, &timeline)); | 305 base::Bind(&TimelineIdleTestTask, &timeline)); |
303 | 306 |
304 RunUntilIdle(); | 307 RunUntilIdle(); |
305 | 308 |
306 std::string expected_timeline[] = { | 309 std::string expected_timeline[] = { |
307 "CanEnterLongIdlePeriod @ 5", "Post delayed and idle tasks", | 310 "CanEnterLongIdlePeriod @ 5", "Post delayed and idle tasks", |
308 "CanEnterLongIdlePeriod @ 5", | 311 "CanEnterLongIdlePeriod @ 5", |
309 "run TimelineIdleTestTask deadline 55", // Note the full 50ms deadline. | 312 "run TimelineIdleTestTask deadline 55", // Note the full 50ms deadline. |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
354 RunUntilIdle(); | 357 RunUntilIdle(); |
355 | 358 |
356 base::TimeTicks new_idle_period_deadline = | 359 base::TimeTicks new_idle_period_deadline = |
357 scheduler_->CurrentIdleTaskDeadlineForTesting(); | 360 scheduler_->CurrentIdleTaskDeadlineForTesting(); |
358 EXPECT_EQ(idle_period_deadline, new_idle_period_deadline); | 361 EXPECT_EQ(idle_period_deadline, new_idle_period_deadline); |
359 | 362 |
360 // Post a task to post an idle task. Because the system is non-quiescent a | 363 // Post a task to post an idle task. Because the system is non-quiescent a |
361 // 300ms pause will occur before the next long idle period is initiated and | 364 // 300ms pause will occur before the next long idle period is initiated and |
362 // the idle task run. | 365 // the idle task run. |
363 default_task_runner_->PostDelayedTask( | 366 default_task_runner_->PostDelayedTask( |
364 FROM_HERE, base::Bind(&PostIdleTask, base::Unretained(&timeline), | 367 FROM_HERE, |
365 base::Unretained(clock_.get()), | 368 base::Bind(&PostIdleTask, base::Unretained(&timeline), |
366 base::Unretained(idle_task_runner_.get())), | 369 base::Unretained(clock_.get()), |
| 370 base::Unretained(idle_task_runner_.get())), |
367 base::TimeDelta::FromMilliseconds(30)); | 371 base::TimeDelta::FromMilliseconds(30)); |
368 | 372 |
369 timeline.push_back("PostFirstIdleTask"); | 373 timeline.push_back("PostFirstIdleTask"); |
370 idle_task_runner_->PostIdleTask(FROM_HERE, | 374 idle_task_runner_->PostIdleTask(FROM_HERE, |
371 base::Bind(&TimelineIdleTestTask, &timeline)); | 375 base::Bind(&TimelineIdleTestTask, &timeline)); |
372 RunUntilIdle(); | 376 RunUntilIdle(); |
373 new_idle_period_deadline = scheduler_->CurrentIdleTaskDeadlineForTesting(); | 377 new_idle_period_deadline = scheduler_->CurrentIdleTaskDeadlineForTesting(); |
374 | 378 |
375 // Running a normal task will mark the system as non-quiescent. | 379 // Running a normal task will mark the system as non-quiescent. |
376 timeline.push_back("Post RecordTimelineTask"); | 380 timeline.push_back("Post RecordTimelineTask"); |
377 default_task_runner_->PostTask( | 381 default_task_runner_->PostTask( |
378 FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline), | 382 FROM_HERE, |
379 base::Unretained(clock_.get()))); | 383 base::Bind(&RecordTimelineTask, base::Unretained(&timeline), |
| 384 base::Unretained(clock_.get()))); |
380 RunUntilIdle(); | 385 RunUntilIdle(); |
381 | 386 |
382 std::string expected_timeline[] = {"RunUntilIdle begin @ 55", | 387 std::string expected_timeline[] = {"RunUntilIdle begin @ 55", |
383 "RunUntilIdle end @ 55", | 388 "RunUntilIdle end @ 55", |
384 "PostFirstIdleTask", | 389 "PostFirstIdleTask", |
385 "RunUntilIdle begin @ 55", | 390 "RunUntilIdle begin @ 55", |
386 "CanEnterLongIdlePeriod @ 55", | 391 "CanEnterLongIdlePeriod @ 55", |
387 "run TimelineIdleTestTask deadline 85", | 392 "run TimelineIdleTestTask deadline 85", |
388 "run PostIdleTask @ 85", | 393 "run PostIdleTask @ 85", |
389 "IsNotQuiescent @ 85", | 394 "IsNotQuiescent @ 85", |
390 "CanEnterLongIdlePeriod @ 385", | 395 "CanEnterLongIdlePeriod @ 385", |
391 "run TimelineIdleTestTask deadline 435", | 396 "run TimelineIdleTestTask deadline 435", |
392 "RunUntilIdle end @ 385", | 397 "RunUntilIdle end @ 385", |
393 "Post RecordTimelineTask", | 398 "Post RecordTimelineTask", |
394 "RunUntilIdle begin @ 385", | 399 "RunUntilIdle begin @ 385", |
395 "run RecordTimelineTask @ 385", | 400 "run RecordTimelineTask @ 385", |
396 "RunUntilIdle end @ 385"}; | 401 "RunUntilIdle end @ 385"}; |
397 | 402 |
398 EXPECT_THAT(timeline, ElementsAreArray(expected_timeline)); | 403 EXPECT_THAT(timeline, ElementsAreArray(expected_timeline)); |
399 } | 404 } |
400 | 405 |
401 } // namespace scheduler | 406 } // namespace scheduler |
402 } // namespace blink | 407 } // namespace blink |
OLD | NEW |