content/renderer/scheduler/task_queue_manager_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/scheduler/task_queue_manager.h"
   6
   7 #include "base/test/test_simple_task_runner.h"
   8 #include "base/threading/thread.h"
   9 #include "cc/test/test_now_source.h"
  10 #include "content/renderer/scheduler/task_queue_selector.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12
  13 using testing::ElementsAre;
  14 using testing::_;
  15
  16 namespace content {
  17 namespace {
  18
  19 class SelectorForTest : public TaskQueueSelector {
  20  public:
  21   SelectorForTest() {}
  22
  23   void RegisterWorkQueues(
  24       const std::vector<const base::TaskQueue*>& work_queues) override {
  25     work_queues_ = work_queues;
  26   }
  27
  28   bool SelectWorkQueueToService(size_t* out_queue_index) override {
  29     if (queues_to_service_.empty())
  30       return false;
  31     *out_queue_index = queues_to_service_.front();
  32     queues_to_service_.pop_front();
  33     return true;
  34   }
  35
  36   void AppendQueueToService(size_t queue_index) {
  37     queues_to_service_.push_back(queue_index);
  38   }
  39
  40   const std::vector<const base::TaskQueue*>& work_queues() {
  41     return work_queues_;
  42   }
  43
  44   void AsValueInto(base::trace_event::TracedValue* state) const override {
  45   }
  46
  47  private:
  48   std::deque<size_t> queues_to_service_;
  49   std::vector<const base::TaskQueue*> work_queues_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(SelectorForTest);
  52 };
  53
  54 class TaskQueueManagerTest : public testing::Test {
  55  protected:
  56   void Initialize(size_t num_queues) {
  57     test_task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner());
  58     selector_ = make_scoped_ptr(new SelectorForTest);
  59     manager_ = make_scoped_ptr(
  60         new TaskQueueManager(num_queues, test_task_runner_, selector_.get()));
  61     EXPECT_EQ(num_queues, selector_->work_queues().size());
  62   }
  63
  64   void InitializeWithRealMessageLoop(size_t num_queues) {
  65     message_loop_.reset(new base::MessageLoop());
  66     selector_ = make_scoped_ptr(new SelectorForTest);
  67     manager_ = make_scoped_ptr(new TaskQueueManager(
  68         num_queues, message_loop_->task_runner(), selector_.get()));
  69     EXPECT_EQ(num_queues, selector_->work_queues().size());
  70   }
  71
  72   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
  73   scoped_ptr<SelectorForTest> selector_;
  74   scoped_ptr<TaskQueueManager> manager_;
  75   scoped_ptr<base::MessageLoop> message_loop_;
  76 };
  77
  78 void PostFromNestedRunloop(base::MessageLoop* message_loop,
  79                            base::SingleThreadTaskRunner* runner,
  80                            std::vector<std::pair<base::Closure, bool>>* tasks) {
  81   base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
  82   for (std::pair<base::Closure, bool>& pair : *tasks) {
  83     if (pair.second) {
  84       runner->PostTask(FROM_HERE, pair.first);
  85     } else {
  86       runner->PostNonNestableTask(FROM_HERE, pair.first);
  87     }
  88   }
  89   message_loop->RunUntilIdle();
  90 }
  91
  92 void TestTask(int value, std::vector<int>* out_result) {
  93   out_result->push_back(value);
  94 }
  95
  96 TEST_F(TaskQueueManagerTest, SingleQueuePosting) {
  97   Initialize(1u);
  98
  99   std::vector<int> run_order;
 100   scoped_refptr<base::SingleThreadTaskRunner> runner =
 101       manager_->TaskRunnerForQueue(0);
 102
 103   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 104   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 105   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 106
 107   selector_->AppendQueueToService(0);
 108   selector_->AppendQueueToService(0);
 109   selector_->AppendQueueToService(0);
 110
 111   test_task_runner_->RunUntilIdle();
 112   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 113 }
 114
 115 TEST_F(TaskQueueManagerTest, MultiQueuePosting) {
 116   Initialize(3u);
 117
 118   std::vector<int> run_order;
 119   scoped_refptr<base::SingleThreadTaskRunner> runners[3] = {
 120       manager_->TaskRunnerForQueue(0),
 121       manager_->TaskRunnerForQueue(1),
 122       manager_->TaskRunnerForQueue(2)};
 123
 124   selector_->AppendQueueToService(0);
 125   selector_->AppendQueueToService(1);
 126   selector_->AppendQueueToService(2);
 127   selector_->AppendQueueToService(0);
 128   selector_->AppendQueueToService(1);
 129   selector_->AppendQueueToService(2);
 130
 131   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 132   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 133   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 134   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 135   runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order));
 136   runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order));
 137
 138   test_task_runner_->RunUntilIdle();
 139   EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6));
 140 }
 141
 142 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) {
 143   InitializeWithRealMessageLoop(1u);
 144
 145   std::vector<int> run_order;
 146   scoped_refptr<base::SingleThreadTaskRunner> runner =
 147       manager_->TaskRunnerForQueue(0);
 148
 149   selector_->AppendQueueToService(0);
 150
 151   runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 152
 153   message_loop_->RunUntilIdle();
 154   EXPECT_THAT(run_order, ElementsAre(1));
 155 }
 156
 157 TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) {
 158   InitializeWithRealMessageLoop(1u);
 159
 160   std::vector<int> run_order;
 161   scoped_refptr<base::SingleThreadTaskRunner> runner =
 162       manager_->TaskRunnerForQueue(0);
 163
 164   selector_->AppendQueueToService(0);
 165   selector_->AppendQueueToService(0);
 166   selector_->AppendQueueToService(0);
 167   selector_->AppendQueueToService(0);
 168   selector_->AppendQueueToService(0);
 169
 170   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 171   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 172   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 173   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 174   runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order));
 175
 176   message_loop_->RunUntilIdle();
 177   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5));
 178 }
 179
 180 TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) {
 181   InitializeWithRealMessageLoop(1u);
 182
 183   std::vector<int> run_order;
 184   scoped_refptr<base::SingleThreadTaskRunner> runner =
 185       manager_->TaskRunnerForQueue(0);
 186
 187   selector_->AppendQueueToService(0);
 188   selector_->AppendQueueToService(0);
 189   selector_->AppendQueueToService(0);
 190   selector_->AppendQueueToService(0);
 191   selector_->AppendQueueToService(0);
 192   selector_->AppendQueueToService(0);
 193
 194   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 195   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 196
 197   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
 198   tasks_to_post_from_nested_loop.push_back(
 199       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
 200   tasks_to_post_from_nested_loop.push_back(
 201       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
 202   tasks_to_post_from_nested_loop.push_back(
 203       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 204
 205   runner->PostTask(
 206       FROM_HERE,
 207       base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
 208                  base::Unretained(&tasks_to_post_from_nested_loop)));
 209
 210   message_loop_->RunUntilIdle();
 211   // Note we expect task 3 to run last because it's non-nestable.
 212   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 213 }
 214
 215 TEST_F(TaskQueueManagerTest, QueuePolling) {
 216   Initialize(1u);
 217
 218   std::vector<int> run_order;
 219   scoped_refptr<base::SingleThreadTaskRunner> runner =
 220       manager_->TaskRunnerForQueue(0);
 221
 222   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 223   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 224   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 225
 226   selector_->AppendQueueToService(0);
 227   test_task_runner_->RunUntilIdle();
 228   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 229 }
 230
 231 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) {
 232   Initialize(1u);
 233
 234   std::vector<int> run_order;
 235   scoped_refptr<base::SingleThreadTaskRunner> runner =
 236       manager_->TaskRunnerForQueue(0);
 237
 238   selector_->AppendQueueToService(0);
 239
 240   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 241   runner->PostDelayedTask(
 242       FROM_HERE, base::Bind(&TestTask, 1, &run_order), delay);
 243   EXPECT_EQ(delay, test_task_runner_->NextPendingTaskDelay());
 244   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 245   EXPECT_TRUE(run_order.empty());
 246
 247   // The task is inserted to the incoming queue only after the delay.
 248   test_task_runner_->RunPendingTasks();
 249   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 250   EXPECT_TRUE(run_order.empty());
 251
 252   // After the delay the task runs normally.
 253   selector_->AppendQueueToService(0);
 254   test_task_runner_->RunUntilIdle();
 255   EXPECT_THAT(run_order, ElementsAre(1));
 256 }
 257
 258 TEST_F(TaskQueueManagerTest, DelayedTaskDoesNotStayDelayed) {
 259   Initialize(1u);
 260
 261   std::vector<int> run_order;
 262   scoped_refptr<base::SingleThreadTaskRunner> runner =
 263       manager_->TaskRunnerForQueue(0);
 264
 265   selector_->AppendQueueToService(0);
 266
 267   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 268   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 269                           delay);
 270   test_task_runner_->RunPendingTasks();
 271
 272   // Reload the work queue so we see the next pending task. It should no longer
 273   // be marked as delayed.
 274   manager_->PumpQueue(0);
 275   EXPECT_TRUE(selector_->work_queues()[0]->front().delayed_run_time.is_null());
 276
 277   // Let the task run normally.
 278   selector_->AppendQueueToService(0);
 279   test_task_runner_->RunUntilIdle();
 280   EXPECT_THAT(run_order, ElementsAre(1));
 281 }
 282
 283 TEST_F(TaskQueueManagerTest, ManualPumping) {
 284   Initialize(1u);
 285   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 286
 287   std::vector<int> run_order;
 288   scoped_refptr<base::SingleThreadTaskRunner> runner =
 289       manager_->TaskRunnerForQueue(0);
 290
 291   // Posting a task when pumping is disabled doesn't result in work getting
 292   // posted.
 293   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 294   EXPECT_FALSE(test_task_runner_->HasPendingTask());
 295
 296   // However polling still works.
 297   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 298
 299   // After pumping the task runs normally.
 300   manager_->PumpQueue(0);
 301   EXPECT_TRUE(test_task_runner_->HasPendingTask());
 302   selector_->AppendQueueToService(0);
 303   test_task_runner_->RunUntilIdle();
 304   EXPECT_THAT(run_order, ElementsAre(1));
 305 }
 306
 307 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) {
 308   Initialize(1u);
 309   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 310
 311   std::vector<int> run_order;
 312   scoped_refptr<base::SingleThreadTaskRunner> runner =
 313       manager_->TaskRunnerForQueue(0);
 314
 315   // Posting a task when pumping is disabled doesn't result in work getting
 316   // posted.
 317   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 318   EXPECT_FALSE(test_task_runner_->HasPendingTask());
 319
 320   // When pumping is enabled the task runs normally.
 321   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AUTO);
 322   EXPECT_TRUE(test_task_runner_->HasPendingTask());
 323   selector_->AppendQueueToService(0);
 324   test_task_runner_->RunUntilIdle();
 325   EXPECT_THAT(run_order, ElementsAre(1));
 326 }
 327
 328 TEST_F(TaskQueueManagerTest, DenyRunning) {
 329   Initialize(1u);
 330
 331   std::vector<int> run_order;
 332   scoped_refptr<base::SingleThreadTaskRunner> runner =
 333       manager_->TaskRunnerForQueue(0);
 334   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 335
 336   // Since we haven't appended a work queue to be selected, the task doesn't
 337   // run.
 338   test_task_runner_->RunUntilIdle();
 339   EXPECT_TRUE(run_order.empty());
 340
 341   // Pumping the queue again with a selected work queue runs the task.
 342   manager_->PumpQueue(0);
 343   selector_->AppendQueueToService(0);
 344   test_task_runner_->RunUntilIdle();
 345   EXPECT_THAT(run_order, ElementsAre(1));
 346 }
 347
 348 TEST_F(TaskQueueManagerTest, ManualPumpingWithDelayedTask) {
 349   Initialize(1u);
 350   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 351
 352   std::vector<int> run_order;
 353   scoped_refptr<base::SingleThreadTaskRunner> runner =
 354       manager_->TaskRunnerForQueue(0);
 355
 356   // Posting a delayed task when pumping will apply the delay, but won't cause
 357   // work to executed afterwards.
 358   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 359   runner->PostDelayedTask(
 360       FROM_HERE, base::Bind(&TestTask, 1, &run_order), delay);
 361   test_task_runner_->RunUntilIdle();
 362   EXPECT_TRUE(run_order.empty());
 363
 364   // After pumping the task runs normally.
 365   manager_->PumpQueue(0);
 366   EXPECT_TRUE(test_task_runner_->HasPendingTask());
 367   selector_->AppendQueueToService(0);
 368   test_task_runner_->RunUntilIdle();
 369   EXPECT_THAT(run_order, ElementsAre(1));
 370 }
 371
 372 TEST_F(TaskQueueManagerTest, ManualPumpingWithNonEmptyWorkQueue) {
 373   Initialize(1u);
 374   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 375
 376   std::vector<int> run_order;
 377   scoped_refptr<base::SingleThreadTaskRunner> runner =
 378       manager_->TaskRunnerForQueue(0);
 379
 380   // Posting two tasks and pumping twice should result in two tasks in the work
 381   // queue.
 382   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 383   manager_->PumpQueue(0);
 384   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 385   manager_->PumpQueue(0);
 386
 387   EXPECT_EQ(2u, selector_->work_queues()[0]->size());
 388 }
 389
 390 void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
 391                        int countdown,
 392                        std::vector<int>* out_result) {
 393   out_result->push_back(countdown);
 394   if (--countdown) {
 395     runner->PostTask(FROM_HERE,
 396                      Bind(&ReentrantTestTask, runner, countdown, out_result));
 397   }
 398 }
 399
 400 TEST_F(TaskQueueManagerTest, ReentrantPosting) {
 401   Initialize(1u);
 402
 403   std::vector<int> run_order;
 404   scoped_refptr<base::SingleThreadTaskRunner> runner =
 405       manager_->TaskRunnerForQueue(0);
 406
 407   runner->PostTask(FROM_HERE, Bind(&ReentrantTestTask, runner, 3, &run_order));
 408
 409   selector_->AppendQueueToService(0);
 410   selector_->AppendQueueToService(0);
 411   selector_->AppendQueueToService(0);
 412
 413   test_task_runner_->RunUntilIdle();
 414   EXPECT_THAT(run_order, ElementsAre(3, 2, 1));
 415 }
 416
 417 TEST_F(TaskQueueManagerTest, NoTasksAfterShutdown) {
 418   Initialize(1u);
 419
 420   std::vector<int> run_order;
 421   scoped_refptr<base::SingleThreadTaskRunner> runner =
 422       manager_->TaskRunnerForQueue(0);
 423
 424   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 425   manager_.reset();
 426   selector_.reset();
 427   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 428
 429   test_task_runner_->RunUntilIdle();
 430   EXPECT_TRUE(run_order.empty());
 431 }
 432
 433 void PostTaskToRunner(scoped_refptr<base::SingleThreadTaskRunner> runner,
 434                       std::vector<int>* run_order) {
 435   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, run_order));
 436 }
 437
 438 TEST_F(TaskQueueManagerTest, PostFromThread) {
 439   InitializeWithRealMessageLoop(1u);
 440
 441   std::vector<int> run_order;
 442   scoped_refptr<base::SingleThreadTaskRunner> runner =
 443       manager_->TaskRunnerForQueue(0);
 444
 445   base::Thread thread("TestThread");
 446   thread.Start();
 447   thread.message_loop()->PostTask(
 448       FROM_HERE, base::Bind(&PostTaskToRunner, runner, &run_order));
 449   thread.Stop();
 450
 451   selector_->AppendQueueToService(0);
 452   message_loop_->RunUntilIdle();
 453   EXPECT_THAT(run_order, ElementsAre(1));
 454 }
 455
 456 void RePostingTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
 457                        int* run_count) {
 458   (*run_count)++;
 459   runner->PostTask(
 460       FROM_HERE,
 461       Bind(&RePostingTestTask, base::Unretained(runner.get()), run_count));
 462 }
 463
 464 TEST_F(TaskQueueManagerTest, DoWorkCantPostItselfMultipleTimes) {
 465   Initialize(1u);
 466   scoped_refptr<base::SingleThreadTaskRunner> runner =
 467       manager_->TaskRunnerForQueue(0);
 468
 469   int run_count = 0;
 470   runner->PostTask(FROM_HERE,
 471                    base::Bind(&RePostingTestTask, runner, &run_count));
 472
 473   selector_->AppendQueueToService(0);
 474   selector_->AppendQueueToService(0);
 475   selector_->AppendQueueToService(0);
 476
 477   test_task_runner_->RunPendingTasks();
 478   // NOTE without the executing_task_ check in MaybePostDoWorkOnMainRunner there
 479   // will be two tasks here.
 480   EXPECT_EQ(1u, test_task_runner_->GetPendingTasks().size());
 481   EXPECT_EQ(1, run_count);
 482 }
 483
 484 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) {
 485   InitializeWithRealMessageLoop(1u);
 486
 487   selector_->AppendQueueToService(0);
 488   selector_->AppendQueueToService(0);
 489   selector_->AppendQueueToService(0);
 490   selector_->AppendQueueToService(0);
 491
 492   std::vector<int> run_order;
 493   scoped_refptr<base::SingleThreadTaskRunner> runner =
 494       manager_->TaskRunnerForQueue(0);
 495
 496   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
 497   tasks_to_post_from_nested_loop.push_back(
 498       std::make_pair(base::Bind(&TestTask, 1, &run_order), true));
 499
 500   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
 501   runner->PostTask(
 502       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
 503                             base::Unretained(&tasks_to_post_from_nested_loop)));
 504   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 505
 506   message_loop_->RunUntilIdle();
 507
 508   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 509 }
 510
 511 TEST_F(TaskQueueManagerTest, WorkBatching) {
 512   Initialize(1u);
 513
 514   manager_->SetWorkBatchSize(2);
 515
 516   std::vector<int> run_order;
 517   scoped_refptr<base::SingleThreadTaskRunner> runner =
 518       manager_->TaskRunnerForQueue(0);
 519
 520   selector_->AppendQueueToService(0);
 521   selector_->AppendQueueToService(0);
 522   selector_->AppendQueueToService(0);
 523   selector_->AppendQueueToService(0);
 524
 525   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 526   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 527   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 528   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 529
 530   // Running one task in the host message loop should cause two posted tasks to
 531   // get executed.
 532   EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 1u);
 533   test_task_runner_->RunPendingTasks();
 534   EXPECT_THAT(run_order, ElementsAre(1, 2));
 535
 536   // The second task runs the remaining two posted tasks.
 537   EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 1u);
 538   test_task_runner_->RunPendingTasks();
 539   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4));
 540 }
 541
 542 void AdvanceNowTestTask(int value,
 543                         std::vector<int>* out_result,
 544                         scoped_refptr<cc::TestNowSource> time_source,
 545                         base::TimeDelta delta) {
 546   TestTask(value, out_result);
 547   time_source->AdvanceNow(delta);
 548 }
 549
 550 TEST_F(TaskQueueManagerTest, InterruptWorkBatchForDelayedTask) {
 551   scoped_refptr<cc::TestNowSource> clock(cc::TestNowSource::Create());
 552   Initialize(1u);
 553
 554   manager_->SetWorkBatchSize(2);
 555   manager_->SetTimeSourceForTesting(clock);
 556
 557   std::vector<int> run_order;
 558   scoped_refptr<base::SingleThreadTaskRunner> runner =
 559       manager_->TaskRunnerForQueue(0);
 560
 561   selector_->AppendQueueToService(0);
 562   selector_->AppendQueueToService(0);
 563   selector_->AppendQueueToService(0);
 564
 565   base::TimeDelta delta(base::TimeDelta::FromMilliseconds(10));
 566   runner->PostTask(
 567       FROM_HERE, base::Bind(&AdvanceNowTestTask, 2, &run_order, clock, delta));
 568   runner->PostTask(
 569       FROM_HERE, base::Bind(&AdvanceNowTestTask, 3, &run_order, clock, delta));
 570
 571   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(5));
 572   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 573                           delay);
 574
 575   // At this point we have two posted tasks: one for DoWork and one of the
 576   // delayed task. Only the first non-delayed task should get executed because
 577   // the work batch is interrupted by the pending delayed task.
 578   EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 2u);
 579   test_task_runner_->RunPendingTasks();
 580   EXPECT_THAT(run_order, ElementsAre(2));
 581
 582   // Running all remaining tasks should execute both pending tasks.
 583   test_task_runner_->RunUntilIdle();
 584   EXPECT_THAT(run_order, ElementsAre(2, 3, 1));
 585 }
 586
 587 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeup) {
 588   Initialize(2u);
 589   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 590
 591   std::vector<int> run_order;
 592   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 593       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 594
 595   selector_->AppendQueueToService(1);
 596   selector_->AppendQueueToService(0);
 597   selector_->AppendQueueToService(0);
 598
 599   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 600   test_task_runner_->RunUntilIdle();
 601   EXPECT_TRUE(run_order.empty());  // Shouldn't run - no other task to wake TQM.
 602
 603   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 604   test_task_runner_->RunUntilIdle();
 605   EXPECT_TRUE(run_order.empty());  // Still shouldn't wake TQM.
 606
 607   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 608   test_task_runner_->RunUntilIdle();
 609   // Executing a task on an auto pumped queue should wake the TQM.
 610   EXPECT_THAT(run_order, ElementsAre(3, 1, 2));
 611 }
 612
 613 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupWhenAlreadyAwake) {
 614   Initialize(2u);
 615   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 616
 617   std::vector<int> run_order;
 618   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 619       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 620
 621   selector_->AppendQueueToService(1);
 622   selector_->AppendQueueToService(0);
 623
 624   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 625   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 626   test_task_runner_->RunUntilIdle();
 627   EXPECT_THAT(run_order, ElementsAre(2, 1));  // TQM was already awake.
 628 }
 629
 630 TEST_F(TaskQueueManagerTest,
 631        AutoPumpAfterWakeupTriggeredByManuallyPumpedQueue) {
 632   Initialize(2u);
 633   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 634   manager_->SetPumpPolicy(1, TaskQueueManager::PumpPolicy::MANUAL);
 635
 636   std::vector<int> run_order;
 637   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 638       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 639
 640   selector_->AppendQueueToService(1);
 641   selector_->AppendQueueToService(0);
 642
 643   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 644   test_task_runner_->RunUntilIdle();
 645   EXPECT_TRUE(run_order.empty());  // Shouldn't run - no other task to wake TQM.
 646
 647   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 648   test_task_runner_->RunUntilIdle();
 649   // This still shouldn't wake TQM as manual queue was not pumped.
 650   EXPECT_TRUE(run_order.empty());
 651
 652   manager_->PumpQueue(1);
 653   test_task_runner_->RunUntilIdle();
 654   // Executing a task on an auto pumped queue should wake the TQM.
 655   EXPECT_THAT(run_order, ElementsAre(2, 1));
 656 }
 657
 658 void TestPostingTask(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
 659                      base::Closure task) {
 660   task_runner->PostTask(FROM_HERE, task);
 661 }
 662
 663 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupFromTask) {
 664   Initialize(2u);
 665   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 666
 667   std::vector<int> run_order;
 668   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 669       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 670
 671   selector_->AppendQueueToService(1);
 672   selector_->AppendQueueToService(1);
 673   selector_->AppendQueueToService(0);
 674
 675   // Check that a task which posts a task to an auto pump after wakeup queue
 676   // doesn't cause the queue to wake up.
 677   base::Closure after_wakeup_task = base::Bind(&TestTask, 1, &run_order);
 678   runners[1]->PostTask(
 679       FROM_HERE,
 680       base::Bind(&TestPostingTask, runners[0], after_wakeup_task));
 681   test_task_runner_->RunUntilIdle();
 682   EXPECT_TRUE(run_order.empty());
 683
 684   // Wake up the queue.
 685   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 686   test_task_runner_->RunUntilIdle();
 687   EXPECT_THAT(run_order, ElementsAre(2, 1));
 688 }
 689
 690 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupFromMultipleTasks) {
 691   Initialize(2u);
 692   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 693
 694   std::vector<int> run_order;
 695   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 696       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 697
 698   selector_->AppendQueueToService(1);
 699   selector_->AppendQueueToService(1);
 700   selector_->AppendQueueToService(1);
 701   selector_->AppendQueueToService(0);
 702   selector_->AppendQueueToService(0);
 703
 704   // Check that a task which posts a task to an auto pump after wakeup queue
 705   // doesn't cause the queue to wake up.
 706   base::Closure after_wakeup_task_1 = base::Bind(&TestTask, 1, &run_order);
 707   base::Closure after_wakeup_task_2 = base::Bind(&TestTask, 2, &run_order);
 708   runners[1]->PostTask(
 709       FROM_HERE,
 710       base::Bind(&TestPostingTask, runners[0], after_wakeup_task_1));
 711   runners[1]->PostTask(
 712       FROM_HERE,
 713       base::Bind(&TestPostingTask, runners[0], after_wakeup_task_2));
 714   test_task_runner_->RunUntilIdle();
 715   EXPECT_TRUE(run_order.empty());
 716
 717   // Wake up the queue.
 718   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 719   test_task_runner_->RunUntilIdle();
 720   EXPECT_THAT(run_order, ElementsAre(3, 1, 2));
 721 }
 722
 723 void NullTestTask() {
 724 }
 725
 726 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupBecomesQuiescent) {
 727   Initialize(2u);
 728   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 729
 730   int run_count = 0;
 731   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 732       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 733
 734   selector_->AppendQueueToService(1);
 735   selector_->AppendQueueToService(0);
 736   selector_->AppendQueueToService(0);
 737   // Append extra service queue '0' entries to the selector otherwise test will
 738   // finish even if the RePostingTestTask woke each other up.
 739   selector_->AppendQueueToService(0);
 740   selector_->AppendQueueToService(0);
 741
 742   // Check that if multiple tasks reposts themselves onto a pump-after-wakeup
 743   // queue they don't wake each other and will eventually stop when no other
 744   // tasks execute.
 745   runners[0]->PostTask(FROM_HERE,
 746                        base::Bind(&RePostingTestTask, runners[0], &run_count));
 747   runners[0]->PostTask(FROM_HERE,
 748                        base::Bind(&RePostingTestTask, runners[0], &run_count));
 749   runners[1]->PostTask(FROM_HERE, base::Bind(&NullTestTask));
 750   test_task_runner_->RunUntilIdle();
 751   // The reposting tasks posted to the after wakeup queue shouldn't have woken
 752   // each other up.
 753   EXPECT_EQ(2, run_count);
 754 }
 755
 756 class MockTaskObserver : public base::MessageLoop::TaskObserver {
 757  public:
 758   MOCK_METHOD1(DidProcessTask, void(const base::PendingTask& task));
 759   MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task));
 760 };
 761
 762 TEST_F(TaskQueueManagerTest, TaskObserverAdding) {
 763   InitializeWithRealMessageLoop(1u);
 764   MockTaskObserver observer;
 765
 766   manager_->SetWorkBatchSize(2);
 767   manager_->AddTaskObserver(&observer);
 768
 769   std::vector<int> run_order;
 770   scoped_refptr<base::SingleThreadTaskRunner> runner =
 771       manager_->TaskRunnerForQueue(0);
 772
 773   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 774   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 775
 776   selector_->AppendQueueToService(0);
 777   selector_->AppendQueueToService(0);
 778
 779   // Two pairs of callbacks for the tasks above plus another one for the
 780   // DoWork() posted by the task queue manager.
 781   EXPECT_CALL(observer, WillProcessTask(_)).Times(3);
 782   EXPECT_CALL(observer, DidProcessTask(_)).Times(3);
 783   message_loop_->RunUntilIdle();
 784 }
 785
 786 TEST_F(TaskQueueManagerTest, TaskObserverRemoving) {
 787   InitializeWithRealMessageLoop(1u);
 788   MockTaskObserver observer;
 789   manager_->SetWorkBatchSize(2);
 790   manager_->AddTaskObserver(&observer);
 791   manager_->RemoveTaskObserver(&observer);
 792
 793   std::vector<int> run_order;
 794   scoped_refptr<base::SingleThreadTaskRunner> runner =
 795       manager_->TaskRunnerForQueue(0);
 796
 797   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 798
 799   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
 800   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 801
 802   selector_->AppendQueueToService(0);
 803   message_loop_->RunUntilIdle();
 804 }
 805
 806 void RemoveObserverTask(TaskQueueManager* manager,
 807                         base::MessageLoop::TaskObserver* observer) {
 808   manager->RemoveTaskObserver(observer);
 809 }
 810
 811 TEST_F(TaskQueueManagerTest, TaskObserverRemovingInsideTask) {
 812   InitializeWithRealMessageLoop(1u);
 813   MockTaskObserver observer;
 814   manager_->SetWorkBatchSize(3);
 815   manager_->AddTaskObserver(&observer);
 816
 817   scoped_refptr<base::SingleThreadTaskRunner> runner =
 818       manager_->TaskRunnerForQueue(0);
 819   runner->PostTask(FROM_HERE,
 820                    base::Bind(&RemoveObserverTask, manager_.get(), &observer));
 821
 822   selector_->AppendQueueToService(0);
 823
 824   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
 825   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 826   message_loop_->RunUntilIdle();
 827 }
 828
 829 }  // namespace
 830 }  // namespace content
 831