OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "platform/scheduler/base/task_queue_manager.h" | 5 #include "platform/scheduler/base/task_queue_manager.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 142 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
153 | 153 |
154 int immediate_do_work_posted_count() const { | 154 int immediate_do_work_posted_count() const { |
155 base::AutoLock lock(manager_->any_thread_lock_); | 155 base::AutoLock lock(manager_->any_thread_lock_); |
156 return manager_->any_thread().immediate_do_work_posted_count; | 156 return manager_->any_thread().immediate_do_work_posted_count; |
157 } | 157 } |
158 | 158 |
159 base::TimeTicks next_delayed_do_work_time() const { | 159 base::TimeTicks next_delayed_do_work_time() const { |
160 return manager_->next_delayed_do_work_.run_time(); | 160 return manager_->next_delayed_do_work_.run_time(); |
161 } | 161 } |
162 | 162 |
163 EnqueueOrder GetNextSequenceNumber() const { | 163 EnqueueOrder GetNextEnqueueOrder() const { |
164 return manager_->GetNextSequenceNumber(); | 164 return manager_->GetNextEnqueueOrder(base::TimeTicks()); |
165 } | 165 } |
166 | 166 |
167 void MaybeScheduleImmediateWorkLocked( | 167 void MaybeScheduleImmediateWorkLocked( |
168 const tracked_objects::Location& from_here) { | 168 const tracked_objects::Location& from_here) { |
169 MoveableAutoLock lock(manager_->any_thread_lock_); | 169 MoveableAutoLock lock(manager_->any_thread_lock_); |
170 manager_->MaybeScheduleImmediateWorkLocked(from_here, std::move(lock)); | 170 manager_->MaybeScheduleImmediateWorkLocked(from_here, std::move(lock)); |
171 } | 171 } |
172 | 172 |
173 // Runs all immediate tasks until there is no more work to do and advances | 173 // Runs all immediate tasks until there is no more work to do and advances |
174 // time if there is a pending delayed task. |per_run_time_callback| is called | 174 // time if there is a pending delayed task. |per_run_time_callback| is called |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
277 base::Unretained(&tasks_to_post_from_nested_loop))); | 277 base::Unretained(&tasks_to_post_from_nested_loop))); |
278 | 278 |
279 base::RunLoop().RunUntilIdle(); | 279 base::RunLoop().RunUntilIdle(); |
280 // We need to call Now twice, to measure the start and end of the outermost | 280 // We need to call Now twice, to measure the start and end of the outermost |
281 // task. We shouldn't call it for any of the nested tasks. | 281 // task. We shouldn't call it for any of the nested tasks. |
282 EXPECT_EQ(2, test_count_uses_time_source->now_calls_count()); | 282 EXPECT_EQ(2, test_count_uses_time_source->now_calls_count()); |
283 } | 283 } |
284 | 284 |
285 void NullTask() {} | 285 void NullTask() {} |
286 | 286 |
287 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) { | 287 void TestTask(int value, std::vector<int>* out_result) { |
288 out_result->push_back(value); | 288 out_result->push_back(value); |
289 } | 289 } |
290 | 290 |
291 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { | 291 TEST_F(TaskQueueManagerTest, SingleQueuePosting) { |
292 Initialize(1u); | 292 Initialize(1u); |
293 | 293 |
294 std::vector<EnqueueOrder> run_order; | 294 std::vector<int> run_order; |
295 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 295 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
296 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 296 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
297 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 297 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
298 | 298 |
299 test_task_runner_->RunUntilIdle(); | 299 test_task_runner_->RunUntilIdle(); |
300 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); | 300 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); |
301 } | 301 } |
302 | 302 |
303 TEST_F(TaskQueueManagerTest, MultiQueuePosting) { | 303 TEST_F(TaskQueueManagerTest, MultiQueuePosting) { |
304 Initialize(3u); | 304 Initialize(3u); |
305 | 305 |
306 std::vector<EnqueueOrder> run_order; | 306 std::vector<int> run_order; |
307 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 307 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
308 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 308 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
309 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 309 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
310 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 310 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
311 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); | 311 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); |
312 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); | 312 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); |
313 | 313 |
314 test_task_runner_->RunUntilIdle(); | 314 test_task_runner_->RunUntilIdle(); |
315 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); | 315 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); |
316 } | 316 } |
317 | 317 |
318 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { | 318 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
319 InitializeWithRealMessageLoop(1u); | 319 InitializeWithRealMessageLoop(1u); |
320 | 320 |
321 std::vector<EnqueueOrder> run_order; | 321 std::vector<int> run_order; |
322 runners_[0]->PostNonNestableTask(FROM_HERE, | 322 runners_[0]->PostNonNestableTask(FROM_HERE, |
323 base::Bind(&TestTask, 1, &run_order)); | 323 base::Bind(&TestTask, 1, &run_order)); |
324 | 324 |
325 base::RunLoop().RunUntilIdle(); | 325 base::RunLoop().RunUntilIdle(); |
326 EXPECT_THAT(run_order, ElementsAre(1)); | 326 EXPECT_THAT(run_order, ElementsAre(1)); |
327 } | 327 } |
328 | 328 |
329 TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) { | 329 TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) { |
330 InitializeWithRealMessageLoop(1u); | 330 InitializeWithRealMessageLoop(1u); |
331 | 331 |
332 std::vector<EnqueueOrder> run_order; | 332 std::vector<int> run_order; |
333 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 333 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
334 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 334 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
335 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 335 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
336 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 336 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
337 runners_[0]->PostNonNestableTask(FROM_HERE, | 337 runners_[0]->PostNonNestableTask(FROM_HERE, |
338 base::Bind(&TestTask, 5, &run_order)); | 338 base::Bind(&TestTask, 5, &run_order)); |
339 | 339 |
340 base::RunLoop().RunUntilIdle(); | 340 base::RunLoop().RunUntilIdle(); |
341 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5)); | 341 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5)); |
342 } | 342 } |
343 | 343 |
344 TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) { | 344 TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) { |
345 InitializeWithRealMessageLoop(1u); | 345 InitializeWithRealMessageLoop(1u); |
346 | 346 |
347 std::vector<EnqueueOrder> run_order; | 347 std::vector<int> run_order; |
348 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 348 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
349 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 349 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
350 | 350 |
351 std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop; | 351 std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop; |
352 tasks_to_post_from_nested_loop.push_back( | 352 tasks_to_post_from_nested_loop.push_back( |
353 std::make_pair(base::Bind(&TestTask, 3, &run_order), false)); | 353 std::make_pair(base::Bind(&TestTask, 3, &run_order), false)); |
354 tasks_to_post_from_nested_loop.push_back( | 354 tasks_to_post_from_nested_loop.push_back( |
355 std::make_pair(base::Bind(&TestTask, 4, &run_order), true)); | 355 std::make_pair(base::Bind(&TestTask, 4, &run_order), true)); |
356 tasks_to_post_from_nested_loop.push_back( | 356 tasks_to_post_from_nested_loop.push_back( |
357 std::make_pair(base::Bind(&TestTask, 5, &run_order), true)); | 357 std::make_pair(base::Bind(&TestTask, 5, &run_order), true)); |
358 | 358 |
359 runners_[0]->PostTask( | 359 runners_[0]->PostTask( |
360 FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), | 360 FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), |
361 base::RetainedRef(runners_[0]), | 361 base::RetainedRef(runners_[0]), |
362 base::Unretained(&tasks_to_post_from_nested_loop))); | 362 base::Unretained(&tasks_to_post_from_nested_loop))); |
363 | 363 |
364 base::RunLoop().RunUntilIdle(); | 364 base::RunLoop().RunUntilIdle(); |
365 // Note we expect task 3 to run last because it's non-nestable. | 365 // Note we expect task 3 to run last because it's non-nestable. |
366 EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3)); | 366 EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3)); |
367 } | 367 } |
368 | 368 |
369 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_ImmediateTask) { | 369 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_ImmediateTask) { |
370 Initialize(1u); | 370 Initialize(1u); |
371 | 371 |
372 std::vector<EnqueueOrder> run_order; | 372 std::vector<int> run_order; |
373 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); | 373 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); |
374 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 374 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
375 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); | 375 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); |
376 | 376 |
377 // Move the task into the |immediate_work_queue|. | 377 // Move the task into the |immediate_work_queue|. |
378 EXPECT_TRUE(runners_[0]->immediate_work_queue()->Empty()); | 378 EXPECT_TRUE(runners_[0]->immediate_work_queue()->Empty()); |
379 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 379 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
380 runners_[0]->CreateQueueEnabledVoter(); | 380 runners_[0]->CreateQueueEnabledVoter(); |
381 voter->SetQueueEnabled(false); | 381 voter->SetQueueEnabled(false); |
382 test_task_runner_->RunUntilIdle(); | 382 test_task_runner_->RunUntilIdle(); |
383 EXPECT_FALSE(runners_[0]->immediate_work_queue()->Empty()); | 383 EXPECT_FALSE(runners_[0]->immediate_work_queue()->Empty()); |
384 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); | 384 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); |
385 | 385 |
386 // Run the task, making the queue empty. | 386 // Run the task, making the queue empty. |
387 voter->SetQueueEnabled(true); | 387 voter->SetQueueEnabled(true); |
388 test_task_runner_->RunUntilIdle(); | 388 test_task_runner_->RunUntilIdle(); |
389 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); | 389 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); |
390 } | 390 } |
391 | 391 |
392 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTask) { | 392 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTask) { |
393 Initialize(1u); | 393 Initialize(1u); |
394 | 394 |
395 std::vector<EnqueueOrder> run_order; | 395 std::vector<int> run_order; |
396 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 396 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
397 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 397 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
398 delay); | 398 delay); |
399 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); | 399 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); |
400 now_src_->Advance(delay); | 400 now_src_->Advance(delay); |
401 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); | 401 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); |
402 | 402 |
403 // Move the task into the |delayed_work_queue|. | 403 // Move the task into the |delayed_work_queue|. |
404 WakeUpReadyDelayedQueues(LazyNow(now_src_.get())); | 404 WakeUpReadyDelayedQueues(LazyNow(now_src_.get())); |
405 EXPECT_FALSE(runners_[0]->delayed_work_queue()->Empty()); | 405 EXPECT_FALSE(runners_[0]->delayed_work_queue()->Empty()); |
406 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); | 406 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); |
407 | 407 |
408 // Run the task, making the queue empty. | 408 // Run the task, making the queue empty. |
409 test_task_runner_->RunUntilIdle(); | 409 test_task_runner_->RunUntilIdle(); |
410 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); | 410 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); |
411 } | 411 } |
412 | 412 |
413 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) { | 413 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) { |
414 Initialize(1u); | 414 Initialize(1u); |
415 | 415 |
416 std::vector<EnqueueOrder> run_order; | 416 std::vector<int> run_order; |
417 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 417 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
418 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 418 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
419 delay); | 419 delay); |
420 EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime()); | 420 EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime()); |
421 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); | 421 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); |
422 EXPECT_TRUE(run_order.empty()); | 422 EXPECT_TRUE(run_order.empty()); |
423 | 423 |
424 // The task doesn't run before the delay has completed. | 424 // The task doesn't run before the delay has completed. |
425 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9)); | 425 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9)); |
426 EXPECT_TRUE(run_order.empty()); | 426 EXPECT_TRUE(run_order.empty()); |
(...skipping 17 matching lines...) Expand all Loading... |
444 | 444 |
445 size_t task_count = 0; | 445 size_t task_count = 0; |
446 test_task_runner_->RunTasksWhile( | 446 test_task_runner_->RunTasksWhile( |
447 base::Bind(&MessageLoopTaskCounter, &task_count)); | 447 base::Bind(&MessageLoopTaskCounter, &task_count)); |
448 EXPECT_EQ(1u, task_count); | 448 EXPECT_EQ(1u, task_count); |
449 } | 449 } |
450 | 450 |
451 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_DecendingOrder) { | 451 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_DecendingOrder) { |
452 Initialize(1u); | 452 Initialize(1u); |
453 | 453 |
454 std::vector<EnqueueOrder> run_order; | 454 std::vector<int> run_order; |
455 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 455 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
456 base::TimeDelta::FromMilliseconds(10)); | 456 base::TimeDelta::FromMilliseconds(10)); |
457 | 457 |
458 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 458 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
459 base::TimeDelta::FromMilliseconds(8)); | 459 base::TimeDelta::FromMilliseconds(8)); |
460 | 460 |
461 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 461 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
462 base::TimeDelta::FromMilliseconds(5)); | 462 base::TimeDelta::FromMilliseconds(5)); |
463 | 463 |
464 EXPECT_EQ(base::TimeDelta::FromMilliseconds(5), | 464 EXPECT_EQ(base::TimeDelta::FromMilliseconds(5), |
465 test_task_runner_->DelayToNextTaskTime()); | 465 test_task_runner_->DelayToNextTaskTime()); |
466 | 466 |
467 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); | 467 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); |
468 EXPECT_THAT(run_order, ElementsAre(3)); | 468 EXPECT_THAT(run_order, ElementsAre(3)); |
469 EXPECT_EQ(base::TimeDelta::FromMilliseconds(3), | 469 EXPECT_EQ(base::TimeDelta::FromMilliseconds(3), |
470 test_task_runner_->DelayToNextTaskTime()); | 470 test_task_runner_->DelayToNextTaskTime()); |
471 | 471 |
472 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(3)); | 472 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(3)); |
473 EXPECT_THAT(run_order, ElementsAre(3, 2)); | 473 EXPECT_THAT(run_order, ElementsAre(3, 2)); |
474 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2), | 474 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2), |
475 test_task_runner_->DelayToNextTaskTime()); | 475 test_task_runner_->DelayToNextTaskTime()); |
476 | 476 |
477 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(2)); | 477 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(2)); |
478 EXPECT_THAT(run_order, ElementsAre(3, 2, 1)); | 478 EXPECT_THAT(run_order, ElementsAre(3, 2, 1)); |
479 } | 479 } |
480 | 480 |
481 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_AscendingOrder) { | 481 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_AscendingOrder) { |
482 Initialize(1u); | 482 Initialize(1u); |
483 | 483 |
484 std::vector<EnqueueOrder> run_order; | 484 std::vector<int> run_order; |
485 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 485 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
486 base::TimeDelta::FromMilliseconds(1)); | 486 base::TimeDelta::FromMilliseconds(1)); |
487 | 487 |
488 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 488 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
489 base::TimeDelta::FromMilliseconds(5)); | 489 base::TimeDelta::FromMilliseconds(5)); |
490 | 490 |
491 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 491 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
492 base::TimeDelta::FromMilliseconds(10)); | 492 base::TimeDelta::FromMilliseconds(10)); |
493 | 493 |
494 EXPECT_EQ(base::TimeDelta::FromMilliseconds(1), | 494 EXPECT_EQ(base::TimeDelta::FromMilliseconds(1), |
495 test_task_runner_->DelayToNextTaskTime()); | 495 test_task_runner_->DelayToNextTaskTime()); |
496 | 496 |
497 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); | 497 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); |
498 EXPECT_THAT(run_order, ElementsAre(1)); | 498 EXPECT_THAT(run_order, ElementsAre(1)); |
499 EXPECT_EQ(base::TimeDelta::FromMilliseconds(4), | 499 EXPECT_EQ(base::TimeDelta::FromMilliseconds(4), |
500 test_task_runner_->DelayToNextTaskTime()); | 500 test_task_runner_->DelayToNextTaskTime()); |
501 | 501 |
502 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(4)); | 502 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(4)); |
503 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 503 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
504 EXPECT_EQ(base::TimeDelta::FromMilliseconds(5), | 504 EXPECT_EQ(base::TimeDelta::FromMilliseconds(5), |
505 test_task_runner_->DelayToNextTaskTime()); | 505 test_task_runner_->DelayToNextTaskTime()); |
506 | 506 |
507 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); | 507 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5)); |
508 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); | 508 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); |
509 } | 509 } |
510 | 510 |
511 TEST_F(TaskQueueManagerTest, PostDelayedTask_SharesUnderlyingDelayedTasks) { | 511 TEST_F(TaskQueueManagerTest, PostDelayedTask_SharesUnderlyingDelayedTasks) { |
512 Initialize(1u); | 512 Initialize(1u); |
513 | 513 |
514 std::vector<EnqueueOrder> run_order; | 514 std::vector<int> run_order; |
515 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 515 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
516 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 516 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
517 delay); | 517 delay); |
518 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 518 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
519 delay); | 519 delay); |
520 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 520 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
521 delay); | 521 delay); |
522 | 522 |
523 EXPECT_EQ(1u, test_task_runner_->NumPendingTasks()); | 523 EXPECT_EQ(1u, test_task_runner_->NumPendingTasks()); |
524 } | 524 } |
(...skipping 23 matching lines...) Expand all Loading... |
548 | 548 |
549 manager_.reset(); | 549 manager_.reset(); |
550 | 550 |
551 EXPECT_EQ(2, TestObject::destructor_count__); | 551 EXPECT_EQ(2, TestObject::destructor_count__); |
552 } | 552 } |
553 | 553 |
554 TEST_F(TaskQueueManagerTest, InsertAndRemoveFence) { | 554 TEST_F(TaskQueueManagerTest, InsertAndRemoveFence) { |
555 Initialize(1u); | 555 Initialize(1u); |
556 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 556 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
557 | 557 |
558 std::vector<EnqueueOrder> run_order; | 558 std::vector<int> run_order; |
559 // Posting a task when pumping is disabled doesn't result in work getting | 559 // Posting a task when pumping is disabled doesn't result in work getting |
560 // posted. | 560 // posted. |
561 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 561 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
562 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); | 562 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); |
563 | 563 |
564 // However polling still works. | 564 // However polling still works. |
565 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); | 565 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); |
566 | 566 |
567 // After removing the fence the task runs normally. | 567 // After removing the fence the task runs normally. |
568 runners_[0]->RemoveFence(); | 568 runners_[0]->RemoveFence(); |
569 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); | 569 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); |
570 test_task_runner_->RunUntilIdle(); | 570 test_task_runner_->RunUntilIdle(); |
571 EXPECT_THAT(run_order, ElementsAre(1)); | 571 EXPECT_THAT(run_order, ElementsAre(1)); |
572 } | 572 } |
573 | 573 |
574 TEST_F(TaskQueueManagerTest, RemovingFenceForDisabledQueueDoesNotPostDoWork) { | 574 TEST_F(TaskQueueManagerTest, RemovingFenceForDisabledQueueDoesNotPostDoWork) { |
575 Initialize(1u); | 575 Initialize(1u); |
576 | 576 |
577 std::vector<EnqueueOrder> run_order; | 577 std::vector<int> run_order; |
578 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 578 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
579 runners_[0]->CreateQueueEnabledVoter(); | 579 runners_[0]->CreateQueueEnabledVoter(); |
580 voter->SetQueueEnabled(false); | 580 voter->SetQueueEnabled(false); |
581 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 581 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
582 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 582 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
583 | 583 |
584 runners_[0]->RemoveFence(); | 584 runners_[0]->RemoveFence(); |
585 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); | 585 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); |
586 } | 586 } |
587 | 587 |
588 TEST_F(TaskQueueManagerTest, EnablingFencedQueueDoesNotPostDoWork) { | 588 TEST_F(TaskQueueManagerTest, EnablingFencedQueueDoesNotPostDoWork) { |
589 Initialize(1u); | 589 Initialize(1u); |
590 | 590 |
591 std::vector<EnqueueOrder> run_order; | 591 std::vector<int> run_order; |
592 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 592 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
593 runners_[0]->CreateQueueEnabledVoter(); | 593 runners_[0]->CreateQueueEnabledVoter(); |
594 voter->SetQueueEnabled(false); | 594 voter->SetQueueEnabled(false); |
595 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 595 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
596 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 596 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
597 | 597 |
598 voter->SetQueueEnabled(true); | 598 voter->SetQueueEnabled(true); |
599 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); | 599 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); |
600 } | 600 } |
601 | 601 |
602 TEST_F(TaskQueueManagerTest, DenyRunning_BeforePosting) { | 602 TEST_F(TaskQueueManagerTest, DenyRunning_BeforePosting) { |
603 Initialize(1u); | 603 Initialize(1u); |
604 | 604 |
605 std::vector<EnqueueOrder> run_order; | 605 std::vector<int> run_order; |
606 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 606 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
607 runners_[0]->CreateQueueEnabledVoter(); | 607 runners_[0]->CreateQueueEnabledVoter(); |
608 voter->SetQueueEnabled(false); | 608 voter->SetQueueEnabled(false); |
609 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 609 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
610 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); | 610 EXPECT_FALSE(test_task_runner_->HasPendingTasks()); |
611 | 611 |
612 test_task_runner_->RunUntilIdle(); | 612 test_task_runner_->RunUntilIdle(); |
613 EXPECT_TRUE(run_order.empty()); | 613 EXPECT_TRUE(run_order.empty()); |
614 | 614 |
615 voter->SetQueueEnabled(true); | 615 voter->SetQueueEnabled(true); |
616 test_task_runner_->RunUntilIdle(); | 616 test_task_runner_->RunUntilIdle(); |
617 EXPECT_THAT(run_order, ElementsAre(1)); | 617 EXPECT_THAT(run_order, ElementsAre(1)); |
618 } | 618 } |
619 | 619 |
620 TEST_F(TaskQueueManagerTest, DenyRunning_AfterPosting) { | 620 TEST_F(TaskQueueManagerTest, DenyRunning_AfterPosting) { |
621 Initialize(1u); | 621 Initialize(1u); |
622 | 622 |
623 std::vector<EnqueueOrder> run_order; | 623 std::vector<int> run_order; |
624 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 624 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
625 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 625 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
626 runners_[0]->CreateQueueEnabledVoter(); | 626 runners_[0]->CreateQueueEnabledVoter(); |
627 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); | 627 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); |
628 voter->SetQueueEnabled(false); | 628 voter->SetQueueEnabled(false); |
629 | 629 |
630 test_task_runner_->RunUntilIdle(); | 630 test_task_runner_->RunUntilIdle(); |
631 EXPECT_TRUE(run_order.empty()); | 631 EXPECT_TRUE(run_order.empty()); |
632 | 632 |
633 voter->SetQueueEnabled(true); | 633 voter->SetQueueEnabled(true); |
634 test_task_runner_->RunUntilIdle(); | 634 test_task_runner_->RunUntilIdle(); |
635 EXPECT_THAT(run_order, ElementsAre(1)); | 635 EXPECT_THAT(run_order, ElementsAre(1)); |
636 } | 636 } |
637 | 637 |
638 TEST_F(TaskQueueManagerTest, DenyRunning_AfterRemovingFence) { | 638 TEST_F(TaskQueueManagerTest, DenyRunning_AfterRemovingFence) { |
639 Initialize(1u); | 639 Initialize(1u); |
640 | 640 |
641 std::vector<EnqueueOrder> run_order; | 641 std::vector<int> run_order; |
642 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 642 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
643 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 643 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
644 runners_[0]->CreateQueueEnabledVoter(); | 644 runners_[0]->CreateQueueEnabledVoter(); |
645 voter->SetQueueEnabled(false); | 645 voter->SetQueueEnabled(false); |
646 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 646 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
647 | 647 |
648 test_task_runner_->RunUntilIdle(); | 648 test_task_runner_->RunUntilIdle(); |
649 EXPECT_TRUE(run_order.empty()); | 649 EXPECT_TRUE(run_order.empty()); |
650 | 650 |
651 runners_[0]->RemoveFence(); | 651 runners_[0]->RemoveFence(); |
652 voter->SetQueueEnabled(true); | 652 voter->SetQueueEnabled(true); |
653 test_task_runner_->RunUntilIdle(); | 653 test_task_runner_->RunUntilIdle(); |
654 EXPECT_THAT(run_order, ElementsAre(1)); | 654 EXPECT_THAT(run_order, ElementsAre(1)); |
655 } | 655 } |
656 | 656 |
657 TEST_F(TaskQueueManagerTest, RemovingFenceWithDelayedTask) { | 657 TEST_F(TaskQueueManagerTest, RemovingFenceWithDelayedTask) { |
658 Initialize(1u); | 658 Initialize(1u); |
659 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 659 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
660 | 660 |
661 std::vector<EnqueueOrder> run_order; | 661 std::vector<int> run_order; |
662 // Posting a delayed task when fenced will apply the delay, but won't cause | 662 // Posting a delayed task when fenced will apply the delay, but won't cause |
663 // work to executed afterwards. | 663 // work to executed afterwards. |
664 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 664 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
665 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 665 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
666 delay); | 666 delay); |
667 | 667 |
668 // The task does not run even though it's delay is up. | 668 // The task does not run even though it's delay is up. |
669 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10)); | 669 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10)); |
670 EXPECT_TRUE(run_order.empty()); | 670 EXPECT_TRUE(run_order.empty()); |
671 | 671 |
672 // Removing the fence causes the task to run. | 672 // Removing the fence causes the task to run. |
673 runners_[0]->RemoveFence(); | 673 runners_[0]->RemoveFence(); |
674 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); | 674 EXPECT_TRUE(test_task_runner_->HasPendingTasks()); |
675 test_task_runner_->RunPendingTasks(); | 675 test_task_runner_->RunPendingTasks(); |
676 EXPECT_THAT(run_order, ElementsAre(1)); | 676 EXPECT_THAT(run_order, ElementsAre(1)); |
677 } | 677 } |
678 | 678 |
679 TEST_F(TaskQueueManagerTest, RemovingFenceWithMultipleDelayedTasks) { | 679 TEST_F(TaskQueueManagerTest, RemovingFenceWithMultipleDelayedTasks) { |
680 Initialize(1u); | 680 Initialize(1u); |
681 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 681 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
682 | 682 |
683 std::vector<EnqueueOrder> run_order; | 683 std::vector<int> run_order; |
684 // Posting a delayed task when fenced will apply the delay, but won't cause | 684 // Posting a delayed task when fenced will apply the delay, but won't cause |
685 // work to executed afterwards. | 685 // work to executed afterwards. |
686 base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1)); | 686 base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1)); |
687 base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10)); | 687 base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10)); |
688 base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20)); | 688 base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20)); |
689 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 689 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
690 delay1); | 690 delay1); |
691 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 691 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
692 delay2); | 692 delay2); |
693 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 693 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
694 delay3); | 694 delay3); |
695 | 695 |
696 now_src_->Advance(base::TimeDelta::FromMilliseconds(15)); | 696 now_src_->Advance(base::TimeDelta::FromMilliseconds(15)); |
697 test_task_runner_->RunUntilIdle(); | 697 test_task_runner_->RunUntilIdle(); |
698 EXPECT_TRUE(run_order.empty()); | 698 EXPECT_TRUE(run_order.empty()); |
699 | 699 |
700 // Removing the fence causes the ready tasks to run. | 700 // Removing the fence causes the ready tasks to run. |
701 runners_[0]->RemoveFence(); | 701 runners_[0]->RemoveFence(); |
702 test_task_runner_->RunUntilIdle(); | 702 test_task_runner_->RunUntilIdle(); |
703 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 703 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
704 } | 704 } |
705 | 705 |
706 TEST_F(TaskQueueManagerTest, InsertFencePreventsDelayedTasksFromRunning) { | 706 TEST_F(TaskQueueManagerTest, InsertFencePreventsDelayedTasksFromRunning) { |
707 Initialize(1u); | 707 Initialize(1u); |
708 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 708 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
709 | 709 |
710 std::vector<EnqueueOrder> run_order; | 710 std::vector<int> run_order; |
711 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); | 711 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); |
712 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 712 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
713 delay); | 713 delay); |
714 | 714 |
715 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10)); | 715 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10)); |
716 EXPECT_TRUE(run_order.empty()); | 716 EXPECT_TRUE(run_order.empty()); |
717 } | 717 } |
718 | 718 |
719 TEST_F(TaskQueueManagerTest, MultipleFences) { | 719 TEST_F(TaskQueueManagerTest, MultipleFences) { |
720 Initialize(1u); | 720 Initialize(1u); |
721 | 721 |
722 std::vector<EnqueueOrder> run_order; | 722 std::vector<int> run_order; |
723 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 723 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
724 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 724 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
725 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 725 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
726 | 726 |
727 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 727 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
728 test_task_runner_->RunUntilIdle(); | 728 test_task_runner_->RunUntilIdle(); |
729 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 729 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
730 | 730 |
731 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 731 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
732 // Subsequent tasks should be blocked. | 732 // Subsequent tasks should be blocked. |
733 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 733 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
734 test_task_runner_->RunUntilIdle(); | 734 test_task_runner_->RunUntilIdle(); |
735 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); | 735 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); |
736 } | 736 } |
737 | 737 |
738 TEST_F(TaskQueueManagerTest, InsertFenceThenImmediatlyRemoveDoesNotBlock) { | 738 TEST_F(TaskQueueManagerTest, InsertFenceThenImmediatlyRemoveDoesNotBlock) { |
739 Initialize(1u); | 739 Initialize(1u); |
740 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 740 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
741 runners_[0]->RemoveFence(); | 741 runners_[0]->RemoveFence(); |
742 | 742 |
743 std::vector<EnqueueOrder> run_order; | 743 std::vector<int> run_order; |
744 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 744 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
745 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 745 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
746 | 746 |
747 test_task_runner_->RunUntilIdle(); | 747 test_task_runner_->RunUntilIdle(); |
748 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 748 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
749 } | 749 } |
750 | 750 |
751 TEST_F(TaskQueueManagerTest, InsertFencePostThenRemoveDoesNotBlock) { | 751 TEST_F(TaskQueueManagerTest, InsertFencePostThenRemoveDoesNotBlock) { |
752 Initialize(1u); | 752 Initialize(1u); |
753 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 753 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
754 | 754 |
755 std::vector<EnqueueOrder> run_order; | 755 std::vector<int> run_order; |
756 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 756 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
757 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 757 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
758 runners_[0]->RemoveFence(); | 758 runners_[0]->RemoveFence(); |
759 | 759 |
760 test_task_runner_->RunUntilIdle(); | 760 test_task_runner_->RunUntilIdle(); |
761 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 761 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
762 } | 762 } |
763 | 763 |
764 TEST_F(TaskQueueManagerTest, MultipleFencesWithInitiallyEmptyQueue) { | 764 TEST_F(TaskQueueManagerTest, MultipleFencesWithInitiallyEmptyQueue) { |
765 Initialize(1u); | 765 Initialize(1u); |
766 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 766 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
767 | 767 |
768 std::vector<EnqueueOrder> run_order; | 768 std::vector<int> run_order; |
769 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 769 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
770 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 770 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
771 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 771 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
772 test_task_runner_->RunUntilIdle(); | 772 test_task_runner_->RunUntilIdle(); |
773 EXPECT_THAT(run_order, ElementsAre(1)); | 773 EXPECT_THAT(run_order, ElementsAre(1)); |
774 } | 774 } |
775 | 775 |
776 TEST_F(TaskQueueManagerTest, BlockedByFence) { | 776 TEST_F(TaskQueueManagerTest, BlockedByFence) { |
777 Initialize(1u); | 777 Initialize(1u); |
778 EXPECT_FALSE(runners_[0]->BlockedByFence()); | 778 EXPECT_FALSE(runners_[0]->BlockedByFence()); |
(...skipping 22 matching lines...) Expand all Loading... |
801 | 801 |
802 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 802 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
803 EXPECT_FALSE(runners_[0]->BlockedByFence()); | 803 EXPECT_FALSE(runners_[0]->BlockedByFence()); |
804 | 804 |
805 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME); | 805 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME); |
806 EXPECT_TRUE(runners_[0]->BlockedByFence()); | 806 EXPECT_TRUE(runners_[0]->BlockedByFence()); |
807 } | 807 } |
808 | 808 |
809 void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner, | 809 void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner, |
810 int countdown, | 810 int countdown, |
811 std::vector<EnqueueOrder>* out_result) { | 811 std::vector<int>* out_result) { |
812 out_result->push_back(countdown); | 812 out_result->push_back(countdown); |
813 if (--countdown) { | 813 if (--countdown) { |
814 runner->PostTask(FROM_HERE, | 814 runner->PostTask(FROM_HERE, |
815 Bind(&ReentrantTestTask, runner, countdown, out_result)); | 815 Bind(&ReentrantTestTask, runner, countdown, out_result)); |
816 } | 816 } |
817 } | 817 } |
818 | 818 |
819 TEST_F(TaskQueueManagerTest, ReentrantPosting) { | 819 TEST_F(TaskQueueManagerTest, ReentrantPosting) { |
820 Initialize(1u); | 820 Initialize(1u); |
821 | 821 |
822 std::vector<EnqueueOrder> run_order; | 822 std::vector<int> run_order; |
823 runners_[0]->PostTask(FROM_HERE, | 823 runners_[0]->PostTask(FROM_HERE, |
824 Bind(&ReentrantTestTask, runners_[0], 3, &run_order)); | 824 Bind(&ReentrantTestTask, runners_[0], 3, &run_order)); |
825 | 825 |
826 test_task_runner_->RunUntilIdle(); | 826 test_task_runner_->RunUntilIdle(); |
827 EXPECT_THAT(run_order, ElementsAre(3, 2, 1)); | 827 EXPECT_THAT(run_order, ElementsAre(3, 2, 1)); |
828 } | 828 } |
829 | 829 |
830 TEST_F(TaskQueueManagerTest, NoTasksAfterShutdown) { | 830 TEST_F(TaskQueueManagerTest, NoTasksAfterShutdown) { |
831 Initialize(1u); | 831 Initialize(1u); |
832 | 832 |
833 std::vector<EnqueueOrder> run_order; | 833 std::vector<int> run_order; |
834 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 834 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
835 manager_.reset(); | 835 manager_.reset(); |
836 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 836 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
837 | 837 |
838 test_task_runner_->RunUntilIdle(); | 838 test_task_runner_->RunUntilIdle(); |
839 EXPECT_TRUE(run_order.empty()); | 839 EXPECT_TRUE(run_order.empty()); |
840 } | 840 } |
841 | 841 |
842 void PostTaskToRunner(scoped_refptr<base::SingleThreadTaskRunner> runner, | 842 void PostTaskToRunner(scoped_refptr<base::SingleThreadTaskRunner> runner, |
843 std::vector<EnqueueOrder>* run_order) { | 843 std::vector<int>* run_order) { |
844 runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, run_order)); | 844 runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, run_order)); |
845 } | 845 } |
846 | 846 |
847 TEST_F(TaskQueueManagerTest, PostFromThread) { | 847 TEST_F(TaskQueueManagerTest, PostFromThread) { |
848 InitializeWithRealMessageLoop(1u); | 848 InitializeWithRealMessageLoop(1u); |
849 | 849 |
850 std::vector<EnqueueOrder> run_order; | 850 std::vector<int> run_order; |
851 base::Thread thread("TestThread"); | 851 base::Thread thread("TestThread"); |
852 thread.Start(); | 852 thread.Start(); |
853 thread.task_runner()->PostTask( | 853 thread.task_runner()->PostTask( |
854 FROM_HERE, base::Bind(&PostTaskToRunner, runners_[0], &run_order)); | 854 FROM_HERE, base::Bind(&PostTaskToRunner, runners_[0], &run_order)); |
855 thread.Stop(); | 855 thread.Stop(); |
856 | 856 |
857 base::RunLoop().RunUntilIdle(); | 857 base::RunLoop().RunUntilIdle(); |
858 EXPECT_THAT(run_order, ElementsAre(1)); | 858 EXPECT_THAT(run_order, ElementsAre(1)); |
859 } | 859 } |
860 | 860 |
(...skipping 14 matching lines...) Expand all Loading... |
875 test_task_runner_->RunPendingTasks(); | 875 test_task_runner_->RunPendingTasks(); |
876 // NOTE without the executing_task_ check in MaybeScheduleDoWork there | 876 // NOTE without the executing_task_ check in MaybeScheduleDoWork there |
877 // will be two tasks here. | 877 // will be two tasks here. |
878 EXPECT_EQ(1u, test_task_runner_->NumPendingTasks()); | 878 EXPECT_EQ(1u, test_task_runner_->NumPendingTasks()); |
879 EXPECT_EQ(1, run_count); | 879 EXPECT_EQ(1, run_count); |
880 } | 880 } |
881 | 881 |
882 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) { | 882 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) { |
883 InitializeWithRealMessageLoop(1u); | 883 InitializeWithRealMessageLoop(1u); |
884 | 884 |
885 std::vector<EnqueueOrder> run_order; | 885 std::vector<int> run_order; |
886 std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop; | 886 std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop; |
887 tasks_to_post_from_nested_loop.push_back( | 887 tasks_to_post_from_nested_loop.push_back( |
888 std::make_pair(base::Bind(&TestTask, 1, &run_order), true)); | 888 std::make_pair(base::Bind(&TestTask, 1, &run_order), true)); |
889 | 889 |
890 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order)); | 890 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order)); |
891 runners_[0]->PostTask( | 891 runners_[0]->PostTask( |
892 FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), | 892 FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), |
893 base::RetainedRef(runners_[0]), | 893 base::RetainedRef(runners_[0]), |
894 base::Unretained(&tasks_to_post_from_nested_loop))); | 894 base::Unretained(&tasks_to_post_from_nested_loop))); |
895 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 895 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
896 | 896 |
897 base::RunLoop().RunUntilIdle(); | 897 base::RunLoop().RunUntilIdle(); |
898 | 898 |
899 EXPECT_THAT(run_order, ElementsAre(0, 2, 1)); | 899 EXPECT_THAT(run_order, ElementsAre(0, 2, 1)); |
900 } | 900 } |
901 | 901 |
902 TEST_F(TaskQueueManagerTest, WorkBatching) { | 902 TEST_F(TaskQueueManagerTest, WorkBatching) { |
903 Initialize(1u); | 903 Initialize(1u); |
904 | 904 |
905 manager_->SetWorkBatchSize(2); | 905 manager_->SetWorkBatchSize(2); |
906 | 906 |
907 std::vector<EnqueueOrder> run_order; | 907 std::vector<int> run_order; |
908 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 908 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
909 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 909 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
910 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 910 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
911 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 911 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); |
912 | 912 |
913 // Running one task in the host message loop should cause two posted tasks to | 913 // Running one task in the host message loop should cause two posted tasks to |
914 // get executed. | 914 // get executed. |
915 EXPECT_EQ(test_task_runner_->NumPendingTasks(), 1u); | 915 EXPECT_EQ(test_task_runner_->NumPendingTasks(), 1u); |
916 test_task_runner_->RunPendingTasks(); | 916 test_task_runner_->RunPendingTasks(); |
917 EXPECT_THAT(run_order, ElementsAre(1, 2)); | 917 EXPECT_THAT(run_order, ElementsAre(1, 2)); |
(...skipping 10 matching lines...) Expand all Loading... |
928 MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task)); | 928 MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task)); |
929 }; | 929 }; |
930 | 930 |
931 TEST_F(TaskQueueManagerTest, TaskObserverAdding) { | 931 TEST_F(TaskQueueManagerTest, TaskObserverAdding) { |
932 InitializeWithRealMessageLoop(1u); | 932 InitializeWithRealMessageLoop(1u); |
933 MockTaskObserver observer; | 933 MockTaskObserver observer; |
934 | 934 |
935 manager_->SetWorkBatchSize(2); | 935 manager_->SetWorkBatchSize(2); |
936 manager_->AddTaskObserver(&observer); | 936 manager_->AddTaskObserver(&observer); |
937 | 937 |
938 std::vector<EnqueueOrder> run_order; | 938 std::vector<int> run_order; |
939 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 939 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
940 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 940 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
941 | 941 |
942 EXPECT_CALL(observer, WillProcessTask(_)).Times(2); | 942 EXPECT_CALL(observer, WillProcessTask(_)).Times(2); |
943 EXPECT_CALL(observer, DidProcessTask(_)).Times(2); | 943 EXPECT_CALL(observer, DidProcessTask(_)).Times(2); |
944 base::RunLoop().RunUntilIdle(); | 944 base::RunLoop().RunUntilIdle(); |
945 } | 945 } |
946 | 946 |
947 TEST_F(TaskQueueManagerTest, TaskObserverRemoving) { | 947 TEST_F(TaskQueueManagerTest, TaskObserverRemoving) { |
948 InitializeWithRealMessageLoop(1u); | 948 InitializeWithRealMessageLoop(1u); |
949 MockTaskObserver observer; | 949 MockTaskObserver observer; |
950 manager_->SetWorkBatchSize(2); | 950 manager_->SetWorkBatchSize(2); |
951 manager_->AddTaskObserver(&observer); | 951 manager_->AddTaskObserver(&observer); |
952 manager_->RemoveTaskObserver(&observer); | 952 manager_->RemoveTaskObserver(&observer); |
953 | 953 |
954 std::vector<EnqueueOrder> run_order; | 954 std::vector<int> run_order; |
955 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 955 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
956 | 956 |
957 EXPECT_CALL(observer, WillProcessTask(_)).Times(0); | 957 EXPECT_CALL(observer, WillProcessTask(_)).Times(0); |
958 EXPECT_CALL(observer, DidProcessTask(_)).Times(0); | 958 EXPECT_CALL(observer, DidProcessTask(_)).Times(0); |
959 | 959 |
960 base::RunLoop().RunUntilIdle(); | 960 base::RunLoop().RunUntilIdle(); |
961 } | 961 } |
962 | 962 |
963 void RemoveObserverTask(TaskQueueManager* manager, | 963 void RemoveObserverTask(TaskQueueManager* manager, |
964 base::MessageLoop::TaskObserver* observer) { | 964 base::MessageLoop::TaskObserver* observer) { |
(...skipping 14 matching lines...) Expand all Loading... |
979 base::RunLoop().RunUntilIdle(); | 979 base::RunLoop().RunUntilIdle(); |
980 } | 980 } |
981 | 981 |
982 TEST_F(TaskQueueManagerTest, QueueTaskObserverAdding) { | 982 TEST_F(TaskQueueManagerTest, QueueTaskObserverAdding) { |
983 InitializeWithRealMessageLoop(2u); | 983 InitializeWithRealMessageLoop(2u); |
984 MockTaskObserver observer; | 984 MockTaskObserver observer; |
985 | 985 |
986 manager_->SetWorkBatchSize(2); | 986 manager_->SetWorkBatchSize(2); |
987 runners_[0]->AddTaskObserver(&observer); | 987 runners_[0]->AddTaskObserver(&observer); |
988 | 988 |
989 std::vector<EnqueueOrder> run_order; | 989 std::vector<int> run_order; |
990 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 990 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
991 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 991 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
992 | 992 |
993 EXPECT_CALL(observer, WillProcessTask(_)).Times(1); | 993 EXPECT_CALL(observer, WillProcessTask(_)).Times(1); |
994 EXPECT_CALL(observer, DidProcessTask(_)).Times(1); | 994 EXPECT_CALL(observer, DidProcessTask(_)).Times(1); |
995 base::RunLoop().RunUntilIdle(); | 995 base::RunLoop().RunUntilIdle(); |
996 } | 996 } |
997 | 997 |
998 TEST_F(TaskQueueManagerTest, QueueTaskObserverRemoving) { | 998 TEST_F(TaskQueueManagerTest, QueueTaskObserverRemoving) { |
999 InitializeWithRealMessageLoop(1u); | 999 InitializeWithRealMessageLoop(1u); |
1000 MockTaskObserver observer; | 1000 MockTaskObserver observer; |
1001 manager_->SetWorkBatchSize(2); | 1001 manager_->SetWorkBatchSize(2); |
1002 runners_[0]->AddTaskObserver(&observer); | 1002 runners_[0]->AddTaskObserver(&observer); |
1003 runners_[0]->RemoveTaskObserver(&observer); | 1003 runners_[0]->RemoveTaskObserver(&observer); |
1004 | 1004 |
1005 std::vector<EnqueueOrder> run_order; | 1005 std::vector<int> run_order; |
1006 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 1006 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
1007 | 1007 |
1008 EXPECT_CALL(observer, WillProcessTask(_)).Times(0); | 1008 EXPECT_CALL(observer, WillProcessTask(_)).Times(0); |
1009 EXPECT_CALL(observer, DidProcessTask(_)).Times(0); | 1009 EXPECT_CALL(observer, DidProcessTask(_)).Times(0); |
1010 | 1010 |
1011 base::RunLoop().RunUntilIdle(); | 1011 base::RunLoop().RunUntilIdle(); |
1012 } | 1012 } |
1013 | 1013 |
1014 void RemoveQueueObserverTask(scoped_refptr<TaskQueue> queue, | 1014 void RemoveQueueObserverTask(scoped_refptr<TaskQueue> queue, |
1015 base::MessageLoop::TaskObserver* observer) { | 1015 base::MessageLoop::TaskObserver* observer) { |
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1170 now_src_->Advance(base::TimeDelta::FromMilliseconds(2)); | 1170 now_src_->Advance(base::TimeDelta::FromMilliseconds(2)); |
1171 WakeUpReadyDelayedQueues(LazyNow(now_src_.get())); | 1171 WakeUpReadyDelayedQueues(LazyNow(now_src_.get())); |
1172 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); | 1172 EXPECT_TRUE(runners_[0]->HasPendingImmediateWork()); |
1173 | 1173 |
1174 test_task_runner_->RunUntilIdle(); | 1174 test_task_runner_->RunUntilIdle(); |
1175 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); | 1175 EXPECT_FALSE(runners_[0]->HasPendingImmediateWork()); |
1176 } | 1176 } |
1177 | 1177 |
1178 void ExpensiveTestTask(int value, | 1178 void ExpensiveTestTask(int value, |
1179 base::SimpleTestTickClock* clock, | 1179 base::SimpleTestTickClock* clock, |
1180 std::vector<EnqueueOrder>* out_result) { | 1180 std::vector<int>* out_result) { |
1181 out_result->push_back(value); | 1181 out_result->push_back(value); |
1182 clock->Advance(base::TimeDelta::FromMilliseconds(1)); | 1182 clock->Advance(base::TimeDelta::FromMilliseconds(1)); |
1183 } | 1183 } |
1184 | 1184 |
1185 TEST_F(TaskQueueManagerTest, ImmediateAndDelayedTaskInterleaving) { | 1185 TEST_F(TaskQueueManagerTest, ImmediateAndDelayedTaskInterleaving) { |
1186 Initialize(1u); | 1186 Initialize(1u); |
1187 | 1187 |
1188 std::vector<EnqueueOrder> run_order; | 1188 std::vector<int> run_order; |
1189 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); | 1189 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
1190 for (int i = 10; i < 19; i++) { | 1190 for (int i = 10; i < 19; i++) { |
1191 runners_[0]->PostDelayedTask( | 1191 runners_[0]->PostDelayedTask( |
1192 FROM_HERE, | 1192 FROM_HERE, |
1193 base::Bind(&ExpensiveTestTask, i, now_src_.get(), &run_order), delay); | 1193 base::Bind(&ExpensiveTestTask, i, now_src_.get(), &run_order), delay); |
1194 } | 1194 } |
1195 | 1195 |
1196 test_task_runner_->RunForPeriod(delay); | 1196 test_task_runner_->RunForPeriod(delay); |
1197 | 1197 |
1198 for (int i = 0; i < 9; i++) { | 1198 for (int i = 0; i < 9; i++) { |
1199 runners_[0]->PostTask(FROM_HERE, base::Bind(&ExpensiveTestTask, i, | 1199 runners_[0]->PostTask(FROM_HERE, base::Bind(&ExpensiveTestTask, i, |
1200 now_src_.get(), &run_order)); | 1200 now_src_.get(), &run_order)); |
1201 } | 1201 } |
1202 | 1202 |
1203 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 1203 test_task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
1204 test_task_runner_->RunUntilIdle(); | 1204 test_task_runner_->RunUntilIdle(); |
1205 | 1205 |
1206 // Delayed tasks are not allowed to starve out immediate work which is why | 1206 // Delayed tasks are not allowed to starve out immediate work which is why |
1207 // some of the immediate tasks run out of order. | 1207 // some of the immediate tasks run out of order. |
1208 int expected_run_order[] = {10, 11, 12, 13, 0, 14, 15, 16, 1, | 1208 int expected_run_order[] = {10, 11, 12, 13, 0, 14, 15, 16, 1, |
1209 17, 18, 2, 3, 4, 5, 6, 7, 8}; | 1209 17, 18, 2, 3, 4, 5, 6, 7, 8}; |
1210 EXPECT_THAT(run_order, ElementsAreArray(expected_run_order)); | 1210 EXPECT_THAT(run_order, ElementsAreArray(expected_run_order)); |
1211 } | 1211 } |
1212 | 1212 |
1213 TEST_F(TaskQueueManagerTest, | 1213 TEST_F(TaskQueueManagerTest, |
1214 DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_SameQueue) { | 1214 DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_SameQueue) { |
1215 Initialize(1u); | 1215 Initialize(1u); |
1216 | 1216 |
1217 std::vector<EnqueueOrder> run_order; | 1217 std::vector<int> run_order; |
1218 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); | 1218 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
1219 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 1219 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
1220 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 1220 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
1221 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1221 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1222 delay); | 1222 delay); |
1223 | 1223 |
1224 now_src_->Advance(delay * 2); | 1224 now_src_->Advance(delay * 2); |
1225 test_task_runner_->RunUntilIdle(); | 1225 test_task_runner_->RunUntilIdle(); |
1226 | 1226 |
1227 EXPECT_THAT(run_order, ElementsAre(2, 3, 1)); | 1227 EXPECT_THAT(run_order, ElementsAre(2, 3, 1)); |
1228 } | 1228 } |
1229 | 1229 |
1230 TEST_F(TaskQueueManagerTest, | 1230 TEST_F(TaskQueueManagerTest, |
1231 DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_DifferentQueues) { | 1231 DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_DifferentQueues) { |
1232 Initialize(2u); | 1232 Initialize(2u); |
1233 | 1233 |
1234 std::vector<EnqueueOrder> run_order; | 1234 std::vector<int> run_order; |
1235 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); | 1235 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
1236 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 1236 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
1237 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 1237 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
1238 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1238 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1239 delay); | 1239 delay); |
1240 | 1240 |
1241 now_src_->Advance(delay * 2); | 1241 now_src_->Advance(delay * 2); |
1242 test_task_runner_->RunUntilIdle(); | 1242 test_task_runner_->RunUntilIdle(); |
1243 | 1243 |
1244 EXPECT_THAT(run_order, ElementsAre(2, 3, 1)); | 1244 EXPECT_THAT(run_order, ElementsAre(2, 3, 1)); |
1245 } | 1245 } |
1246 | 1246 |
1247 TEST_F(TaskQueueManagerTest, DelayedTaskDoesNotSkipAHeadOfShorterDelayedTask) { | 1247 TEST_F(TaskQueueManagerTest, DelayedTaskDoesNotSkipAHeadOfShorterDelayedTask) { |
1248 Initialize(2u); | 1248 Initialize(2u); |
1249 | 1249 |
1250 std::vector<EnqueueOrder> run_order; | 1250 std::vector<int> run_order; |
1251 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10); | 1251 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10); |
1252 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); | 1252 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); |
1253 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1253 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1254 delay1); | 1254 delay1); |
1255 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1255 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1256 delay2); | 1256 delay2); |
1257 | 1257 |
1258 now_src_->Advance(delay1 * 2); | 1258 now_src_->Advance(delay1 * 2); |
1259 test_task_runner_->RunUntilIdle(); | 1259 test_task_runner_->RunUntilIdle(); |
1260 | 1260 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1294 | 1294 |
1295 class SequenceNumberCapturingTaskObserver | 1295 class SequenceNumberCapturingTaskObserver |
1296 : public base::MessageLoop::TaskObserver { | 1296 : public base::MessageLoop::TaskObserver { |
1297 public: | 1297 public: |
1298 // MessageLoop::TaskObserver overrides. | 1298 // MessageLoop::TaskObserver overrides. |
1299 void WillProcessTask(const base::PendingTask& pending_task) override {} | 1299 void WillProcessTask(const base::PendingTask& pending_task) override {} |
1300 void DidProcessTask(const base::PendingTask& pending_task) override { | 1300 void DidProcessTask(const base::PendingTask& pending_task) override { |
1301 sequence_numbers_.push_back(pending_task.sequence_num); | 1301 sequence_numbers_.push_back(pending_task.sequence_num); |
1302 } | 1302 } |
1303 | 1303 |
1304 const std::vector<EnqueueOrder>& sequence_numbers() const { | 1304 const std::vector<int>& sequence_numbers() const { return sequence_numbers_; } |
1305 return sequence_numbers_; | |
1306 } | |
1307 | 1305 |
1308 private: | 1306 private: |
1309 std::vector<EnqueueOrder> sequence_numbers_; | 1307 std::vector<int> sequence_numbers_; |
1310 }; | 1308 }; |
1311 | 1309 |
1312 TEST_F(TaskQueueManagerTest, SequenceNumSetWhenTaskIsPosted) { | 1310 TEST_F(TaskQueueManagerTest, DelayedTasksRunInOrder) { |
1313 Initialize(1u); | 1311 Initialize(1u); |
1314 | 1312 |
1315 SequenceNumberCapturingTaskObserver observer; | 1313 SequenceNumberCapturingTaskObserver observer; |
1316 manager_->AddTaskObserver(&observer); | 1314 manager_->AddTaskObserver(&observer); |
1317 | 1315 |
1318 // Register four tasks that will run in reverse order. | 1316 // Register four tasks that will run in reverse order. Note that since we |
1319 std::vector<EnqueueOrder> run_order; | 1317 // don't strict guarantees about the relative ordering of immediate and |
| 1318 // delayed tasks, in this scenario the immediate task runs last. |
| 1319 std::vector<int> run_order; |
1320 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1320 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1321 base::TimeDelta::FromMilliseconds(30)); | 1321 base::TimeDelta::FromMilliseconds(30)); |
1322 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1322 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1323 base::TimeDelta::FromMilliseconds(20)); | 1323 base::TimeDelta::FromMilliseconds(20)); |
1324 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 1324 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
1325 base::TimeDelta::FromMilliseconds(10)); | 1325 base::TimeDelta::FromMilliseconds(10)); |
1326 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); | 1326 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order)); |
1327 | 1327 |
1328 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40)); | 1328 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40)); |
1329 ASSERT_THAT(run_order, ElementsAre(4, 3, 2, 1)); | 1329 ASSERT_THAT(run_order, ElementsAre(3, 2, 1, 0)); |
1330 | 1330 |
1331 // The sequence numbers are a one-based monotonically incrememting counter | 1331 // The sequence numbers are a one-based monotonically incrementing counter |
1332 // which should be set when the task is posted rather than when it's enqueued | 1332 // which should be set when the task is posted rather than when it's enqueued |
1333 // onto the Incoming queue. This counter starts with 2. | 1333 // onto the Incoming queue. This counter starts with 2. |
1334 EXPECT_THAT(observer.sequence_numbers(), ElementsAre(5, 4, 3, 2)); | 1334 EXPECT_THAT(observer.sequence_numbers(), ElementsAre(4, 3, 2, 5)); |
1335 | 1335 |
1336 manager_->RemoveTaskObserver(&observer); | 1336 manager_->RemoveTaskObserver(&observer); |
1337 } | 1337 } |
1338 | 1338 |
1339 TEST_F(TaskQueueManagerTest, NewTaskQueues) { | 1339 TEST_F(TaskQueueManagerTest, NewTaskQueues) { |
1340 Initialize(1u); | 1340 Initialize(1u); |
1341 | 1341 |
1342 scoped_refptr<internal::TaskQueueImpl> queue1 = | 1342 scoped_refptr<internal::TaskQueueImpl> queue1 = |
1343 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); | 1343 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); |
1344 scoped_refptr<internal::TaskQueueImpl> queue2 = | 1344 scoped_refptr<internal::TaskQueueImpl> queue2 = |
1345 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); | 1345 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); |
1346 scoped_refptr<internal::TaskQueueImpl> queue3 = | 1346 scoped_refptr<internal::TaskQueueImpl> queue3 = |
1347 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); | 1347 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); |
1348 | 1348 |
1349 ASSERT_NE(queue1, queue2); | 1349 ASSERT_NE(queue1, queue2); |
1350 ASSERT_NE(queue1, queue3); | 1350 ASSERT_NE(queue1, queue3); |
1351 ASSERT_NE(queue2, queue3); | 1351 ASSERT_NE(queue2, queue3); |
1352 | 1352 |
1353 std::vector<EnqueueOrder> run_order; | 1353 std::vector<int> run_order; |
1354 queue1->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 1354 queue1->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
1355 queue2->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 1355 queue2->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
1356 queue3->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 1356 queue3->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
1357 test_task_runner_->RunUntilIdle(); | 1357 test_task_runner_->RunUntilIdle(); |
1358 | 1358 |
1359 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); | 1359 EXPECT_THAT(run_order, ElementsAre(1, 2, 3)); |
1360 } | 1360 } |
1361 | 1361 |
1362 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue) { | 1362 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue) { |
1363 Initialize(1u); | 1363 Initialize(1u); |
1364 | 1364 |
1365 scoped_refptr<internal::TaskQueueImpl> queue1 = | 1365 scoped_refptr<internal::TaskQueueImpl> queue1 = |
1366 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); | 1366 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); |
1367 scoped_refptr<internal::TaskQueueImpl> queue2 = | 1367 scoped_refptr<internal::TaskQueueImpl> queue2 = |
1368 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); | 1368 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); |
1369 scoped_refptr<internal::TaskQueueImpl> queue3 = | 1369 scoped_refptr<internal::TaskQueueImpl> queue3 = |
1370 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); | 1370 manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)); |
1371 | 1371 |
1372 ASSERT_NE(queue1, queue2); | 1372 ASSERT_NE(queue1, queue2); |
1373 ASSERT_NE(queue1, queue3); | 1373 ASSERT_NE(queue1, queue3); |
1374 ASSERT_NE(queue2, queue3); | 1374 ASSERT_NE(queue2, queue3); |
1375 | 1375 |
1376 std::vector<EnqueueOrder> run_order; | 1376 std::vector<int> run_order; |
1377 queue1->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 1377 queue1->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
1378 queue2->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 1378 queue2->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
1379 queue3->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 1379 queue3->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
1380 | 1380 |
1381 queue2->UnregisterTaskQueue(); | 1381 queue2->UnregisterTaskQueue(); |
1382 test_task_runner_->RunUntilIdle(); | 1382 test_task_runner_->RunUntilIdle(); |
1383 | 1383 |
1384 EXPECT_THAT(run_order, ElementsAre(1, 3)); | 1384 EXPECT_THAT(run_order, ElementsAre(1, 3)); |
1385 } | 1385 } |
1386 | 1386 |
1387 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_WithDelayedTasks) { | 1387 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_WithDelayedTasks) { |
1388 Initialize(2u); | 1388 Initialize(2u); |
1389 | 1389 |
1390 // Register three delayed tasks | 1390 // Register three delayed tasks |
1391 std::vector<EnqueueOrder> run_order; | 1391 std::vector<int> run_order; |
1392 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1392 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1393 base::TimeDelta::FromMilliseconds(10)); | 1393 base::TimeDelta::FromMilliseconds(10)); |
1394 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1394 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1395 base::TimeDelta::FromMilliseconds(20)); | 1395 base::TimeDelta::FromMilliseconds(20)); |
1396 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 1396 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
1397 base::TimeDelta::FromMilliseconds(30)); | 1397 base::TimeDelta::FromMilliseconds(30)); |
1398 | 1398 |
1399 runners_[1]->UnregisterTaskQueue(); | 1399 runners_[1]->UnregisterTaskQueue(); |
1400 test_task_runner_->RunUntilIdle(); | 1400 test_task_runner_->RunUntilIdle(); |
1401 | 1401 |
1402 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40)); | 1402 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40)); |
1403 ASSERT_THAT(run_order, ElementsAre(1, 3)); | 1403 ASSERT_THAT(run_order, ElementsAre(1, 3)); |
1404 } | 1404 } |
1405 | 1405 |
1406 namespace { | 1406 namespace { |
1407 void UnregisterQueue(scoped_refptr<internal::TaskQueueImpl> queue) { | 1407 void UnregisterQueue(scoped_refptr<internal::TaskQueueImpl> queue) { |
1408 queue->UnregisterTaskQueue(); | 1408 queue->UnregisterTaskQueue(); |
1409 } | 1409 } |
1410 } | 1410 } |
1411 | 1411 |
1412 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_InTasks) { | 1412 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_InTasks) { |
1413 Initialize(3u); | 1413 Initialize(3u); |
1414 | 1414 |
1415 std::vector<EnqueueOrder> run_order; | 1415 std::vector<int> run_order; |
1416 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 1416 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
1417 runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[1])); | 1417 runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[1])); |
1418 runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[2])); | 1418 runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[2])); |
1419 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); | 1419 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); |
1420 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); | 1420 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); |
1421 | 1421 |
1422 test_task_runner_->RunUntilIdle(); | 1422 test_task_runner_->RunUntilIdle(); |
1423 ASSERT_THAT(run_order, ElementsAre(1)); | 1423 ASSERT_THAT(run_order, ElementsAre(1)); |
1424 } | 1424 } |
1425 | 1425 |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1546 base::TimeTicks start_time = manager_->Delegate()->NowTicks(); | 1546 base::TimeTicks start_time = manager_->Delegate()->NowTicks(); |
1547 std::unique_ptr<VirtualTimeDomain> domain_a( | 1547 std::unique_ptr<VirtualTimeDomain> domain_a( |
1548 new VirtualTimeDomain(start_time)); | 1548 new VirtualTimeDomain(start_time)); |
1549 std::unique_ptr<VirtualTimeDomain> domain_b( | 1549 std::unique_ptr<VirtualTimeDomain> domain_b( |
1550 new VirtualTimeDomain(start_time)); | 1550 new VirtualTimeDomain(start_time)); |
1551 manager_->RegisterTimeDomain(domain_a.get()); | 1551 manager_->RegisterTimeDomain(domain_a.get()); |
1552 manager_->RegisterTimeDomain(domain_b.get()); | 1552 manager_->RegisterTimeDomain(domain_b.get()); |
1553 runners_[0]->SetTimeDomain(domain_a.get()); | 1553 runners_[0]->SetTimeDomain(domain_a.get()); |
1554 runners_[1]->SetTimeDomain(domain_b.get()); | 1554 runners_[1]->SetTimeDomain(domain_b.get()); |
1555 | 1555 |
1556 std::vector<EnqueueOrder> run_order; | 1556 std::vector<int> run_order; |
1557 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1557 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1558 base::TimeDelta::FromMilliseconds(10)); | 1558 base::TimeDelta::FromMilliseconds(10)); |
1559 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1559 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1560 base::TimeDelta::FromMilliseconds(20)); | 1560 base::TimeDelta::FromMilliseconds(20)); |
1561 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 1561 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
1562 base::TimeDelta::FromMilliseconds(30)); | 1562 base::TimeDelta::FromMilliseconds(30)); |
1563 | 1563 |
1564 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), | 1564 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), |
1565 base::TimeDelta::FromMilliseconds(10)); | 1565 base::TimeDelta::FromMilliseconds(10)); |
1566 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order), | 1566 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order), |
(...skipping 22 matching lines...) Expand all Loading... |
1589 | 1589 |
1590 TEST_F(TaskQueueManagerTest, TimeDomainMigration) { | 1590 TEST_F(TaskQueueManagerTest, TimeDomainMigration) { |
1591 Initialize(1u); | 1591 Initialize(1u); |
1592 | 1592 |
1593 base::TimeTicks start_time = manager_->Delegate()->NowTicks(); | 1593 base::TimeTicks start_time = manager_->Delegate()->NowTicks(); |
1594 std::unique_ptr<VirtualTimeDomain> domain_a( | 1594 std::unique_ptr<VirtualTimeDomain> domain_a( |
1595 new VirtualTimeDomain(start_time)); | 1595 new VirtualTimeDomain(start_time)); |
1596 manager_->RegisterTimeDomain(domain_a.get()); | 1596 manager_->RegisterTimeDomain(domain_a.get()); |
1597 runners_[0]->SetTimeDomain(domain_a.get()); | 1597 runners_[0]->SetTimeDomain(domain_a.get()); |
1598 | 1598 |
1599 std::vector<EnqueueOrder> run_order; | 1599 std::vector<int> run_order; |
1600 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1600 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1601 base::TimeDelta::FromMilliseconds(10)); | 1601 base::TimeDelta::FromMilliseconds(10)); |
1602 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), | 1602 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order), |
1603 base::TimeDelta::FromMilliseconds(20)); | 1603 base::TimeDelta::FromMilliseconds(20)); |
1604 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), | 1604 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order), |
1605 base::TimeDelta::FromMilliseconds(30)); | 1605 base::TimeDelta::FromMilliseconds(30)); |
1606 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), | 1606 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order), |
1607 base::TimeDelta::FromMilliseconds(40)); | 1607 base::TimeDelta::FromMilliseconds(40)); |
1608 | 1608 |
1609 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20)); | 1609 domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20)); |
(...skipping 23 matching lines...) Expand all Loading... |
1633 | 1633 |
1634 base::TimeTicks start_time = manager_->Delegate()->NowTicks(); | 1634 base::TimeTicks start_time = manager_->Delegate()->NowTicks(); |
1635 std::unique_ptr<VirtualTimeDomain> domain_a( | 1635 std::unique_ptr<VirtualTimeDomain> domain_a( |
1636 new VirtualTimeDomain(start_time)); | 1636 new VirtualTimeDomain(start_time)); |
1637 std::unique_ptr<VirtualTimeDomain> domain_b( | 1637 std::unique_ptr<VirtualTimeDomain> domain_b( |
1638 new VirtualTimeDomain(start_time)); | 1638 new VirtualTimeDomain(start_time)); |
1639 manager_->RegisterTimeDomain(domain_a.get()); | 1639 manager_->RegisterTimeDomain(domain_a.get()); |
1640 manager_->RegisterTimeDomain(domain_b.get()); | 1640 manager_->RegisterTimeDomain(domain_b.get()); |
1641 | 1641 |
1642 runners_[0]->SetTimeDomain(domain_a.get()); | 1642 runners_[0]->SetTimeDomain(domain_a.get()); |
1643 std::vector<EnqueueOrder> run_order; | 1643 std::vector<int> run_order; |
1644 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); | 1644 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order)); |
1645 runners_[0]->SetTimeDomain(domain_b.get()); | 1645 runners_[0]->SetTimeDomain(domain_b.get()); |
1646 | 1646 |
1647 test_task_runner_->RunUntilIdle(); | 1647 test_task_runner_->RunUntilIdle(); |
1648 EXPECT_THAT(run_order, ElementsAre(1)); | 1648 EXPECT_THAT(run_order, ElementsAre(1)); |
1649 | 1649 |
1650 runners_[0]->UnregisterTaskQueue(); | 1650 runners_[0]->UnregisterTaskQueue(); |
1651 | 1651 |
1652 manager_->UnregisterTimeDomain(domain_a.get()); | 1652 manager_->UnregisterTimeDomain(domain_a.get()); |
1653 manager_->UnregisterTimeDomain(domain_b.get()); | 1653 manager_->UnregisterTimeDomain(domain_b.get()); |
1654 } | 1654 } |
1655 | 1655 |
1656 TEST_F(TaskQueueManagerTest, | 1656 TEST_F(TaskQueueManagerTest, |
1657 PostDelayedTasksReverseOrderAlternatingTimeDomains) { | 1657 PostDelayedTasksReverseOrderAlternatingTimeDomains) { |
1658 Initialize(1u); | 1658 Initialize(1u); |
1659 | 1659 |
1660 std::vector<EnqueueOrder> run_order; | 1660 std::vector<int> run_order; |
1661 | 1661 |
1662 std::unique_ptr<RealTimeDomain> domain_a(new RealTimeDomain("test")); | 1662 std::unique_ptr<RealTimeDomain> domain_a(new RealTimeDomain("test")); |
1663 std::unique_ptr<RealTimeDomain> domain_b(new RealTimeDomain("test")); | 1663 std::unique_ptr<RealTimeDomain> domain_b(new RealTimeDomain("test")); |
1664 manager_->RegisterTimeDomain(domain_a.get()); | 1664 manager_->RegisterTimeDomain(domain_a.get()); |
1665 manager_->RegisterTimeDomain(domain_b.get()); | 1665 manager_->RegisterTimeDomain(domain_b.get()); |
1666 | 1666 |
1667 runners_[0]->SetTimeDomain(domain_a.get()); | 1667 runners_[0]->SetTimeDomain(domain_a.get()); |
1668 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), | 1668 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order), |
1669 base::TimeDelta::FromMilliseconds(40)); | 1669 base::TimeDelta::FromMilliseconds(40)); |
1670 | 1670 |
(...skipping 1039 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2710 run_loop.QuitClosure(), base::RetainedRef(runners_[0])), | 2710 run_loop.QuitClosure(), base::RetainedRef(runners_[0])), |
2711 base::TimeDelta::FromMilliseconds(100)); | 2711 base::TimeDelta::FromMilliseconds(100)); |
2712 | 2712 |
2713 now_src_->Advance(base::TimeDelta::FromMilliseconds(200)); | 2713 now_src_->Advance(base::TimeDelta::FromMilliseconds(200)); |
2714 run_loop.Run(); | 2714 run_loop.Run(); |
2715 } | 2715 } |
2716 | 2716 |
2717 TEST_F(TaskQueueManagerTest, CouldTaskRun_DisableAndReenable) { | 2717 TEST_F(TaskQueueManagerTest, CouldTaskRun_DisableAndReenable) { |
2718 Initialize(1u); | 2718 Initialize(1u); |
2719 | 2719 |
2720 EnqueueOrder enqueue_order = GetNextSequenceNumber(); | 2720 EnqueueOrder enqueue_order = GetNextEnqueueOrder(); |
2721 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); | 2721 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); |
2722 | 2722 |
2723 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 2723 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
2724 runners_[0]->CreateQueueEnabledVoter(); | 2724 runners_[0]->CreateQueueEnabledVoter(); |
2725 voter->SetQueueEnabled(false); | 2725 voter->SetQueueEnabled(false); |
2726 EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order)); | 2726 EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order)); |
2727 | 2727 |
2728 voter->SetQueueEnabled(true); | 2728 voter->SetQueueEnabled(true); |
2729 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); | 2729 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); |
2730 } | 2730 } |
2731 | 2731 |
2732 TEST_F(TaskQueueManagerTest, CouldTaskRun_Fence) { | 2732 TEST_F(TaskQueueManagerTest, CouldTaskRun_Fence) { |
2733 Initialize(1u); | 2733 Initialize(1u); |
2734 | 2734 |
2735 EnqueueOrder enqueue_order = GetNextSequenceNumber(); | 2735 EnqueueOrder enqueue_order = GetNextEnqueueOrder(); |
2736 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); | 2736 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); |
2737 | 2737 |
2738 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 2738 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
2739 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); | 2739 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); |
2740 | 2740 |
2741 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME); | 2741 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME); |
2742 EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order)); | 2742 EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order)); |
2743 | 2743 |
2744 runners_[0]->RemoveFence(); | 2744 runners_[0]->RemoveFence(); |
2745 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); | 2745 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); |
2746 } | 2746 } |
2747 | 2747 |
2748 TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) { | 2748 TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) { |
2749 Initialize(1u); | 2749 Initialize(1u); |
2750 | 2750 |
2751 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 2751 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
2752 | 2752 |
2753 EnqueueOrder enqueue_order = GetNextSequenceNumber(); | 2753 EnqueueOrder enqueue_order = GetNextEnqueueOrder(); |
2754 EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order)); | 2754 EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order)); |
2755 | 2755 |
2756 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); | 2756 runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW); |
2757 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); | 2757 EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order)); |
2758 } | 2758 } |
2759 | 2759 |
2760 TEST_F(TaskQueueManagerTest, DelayedDoWorkNotPostedForDisabledQueue) { | 2760 TEST_F(TaskQueueManagerTest, DelayedDoWorkNotPostedForDisabledQueue) { |
2761 Initialize(1u); | 2761 Initialize(1u); |
2762 | 2762 |
2763 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), | 2763 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2871 manager_->RegisterTimeDomain(domain.get()); | 2871 manager_->RegisterTimeDomain(domain.get()); |
2872 runners_[0]->SetTimeDomain(domain.get()); | 2872 runners_[0]->SetTimeDomain(domain.get()); |
2873 | 2873 |
2874 // Tidy up. | 2874 // Tidy up. |
2875 runners_[0]->UnregisterTaskQueue(); | 2875 runners_[0]->UnregisterTaskQueue(); |
2876 manager_->UnregisterTimeDomain(domain.get()); | 2876 manager_->UnregisterTimeDomain(domain.get()); |
2877 } | 2877 } |
2878 | 2878 |
2879 } // namespace scheduler | 2879 } // namespace scheduler |
2880 } // namespace blink | 2880 } // namespace blink |
OLD | NEW |