content/child/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/child/scheduler/task_queue_manager.h"
   6
   7 #include "base/threading/thread.h"
   8 #include "cc/test/ordered_simple_task_runner.h"
   9 #include "cc/test/test_now_source.h"
  10 #include "content/child/scheduler/nestable_task_runner_for_test.h"
  11 #include "content/child/scheduler/scheduler_message_loop_delegate.h"
  12 #include "content/child/scheduler/task_queue_selector.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14
  15 using testing::ElementsAre;
  16 using testing::_;
  17
  18 namespace content {
  19 namespace {
  20
  21 class SelectorForTest : public TaskQueueSelector {
  22  public:
  23   ~SelectorForTest() override {}
  24
  25   virtual void AppendQueueToService(size_t queue_index) = 0;
  26
  27   virtual const std::vector<const base::TaskQueue*>& work_queues() = 0;
  28
  29   void AsValueInto(base::trace_event::TracedValue* state) const override {}
  30 };
  31
  32 // Always selects queue 0.
  33 class AutomaticSelectorForTest : public SelectorForTest {
  34  public:
  35   AutomaticSelectorForTest() {}
  36   ~AutomaticSelectorForTest() override {}
  37
  38   void RegisterWorkQueues(
  39       const std::vector<const base::TaskQueue*>& work_queues) override {
  40     work_queues_ = work_queues;
  41   }
  42
  43   bool SelectWorkQueueToService(size_t* out_queue_index) override {
  44     for (size_t i = 0; i < work_queues_.size(); i++) {
  45       if (!work_queues_[i]->empty()) {
  46         *out_queue_index = i;
  47         return true;
  48       }
  49     }
  50     return false;
  51   }
  52
  53   void AppendQueueToService(size_t queue_index) override {
  54     DCHECK(false) << "Not supported";
  55   }
  56
  57   const std::vector<const base::TaskQueue*>& work_queues() override {
  58     return work_queues_;
  59   }
  60
  61  private:
  62   std::vector<const base::TaskQueue*> work_queues_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(AutomaticSelectorForTest);
  65 };
  66
  67 class ExplicitSelectorForTest : public SelectorForTest {
  68  public:
  69   ExplicitSelectorForTest() {}
  70   ~ExplicitSelectorForTest() override {}
  71
  72   void RegisterWorkQueues(
  73       const std::vector<const base::TaskQueue*>& work_queues) override {
  74     work_queues_ = work_queues;
  75   }
  76
  77   bool SelectWorkQueueToService(size_t* out_queue_index) override {
  78     if (queues_to_service_.empty())
  79       return false;
  80     *out_queue_index = queues_to_service_.front();
  81     queues_to_service_.pop_front();
  82     return true;
  83   }
  84
  85   void AppendQueueToService(size_t queue_index) override {
  86     queues_to_service_.push_back(queue_index);
  87   }
  88
  89   const std::vector<const base::TaskQueue*>& work_queues() override {
  90     return work_queues_;
  91   }
  92
  93  private:
  94   std::deque<size_t> queues_to_service_;
  95   std::vector<const base::TaskQueue*> work_queues_;
  96
  97   DISALLOW_COPY_AND_ASSIGN(ExplicitSelectorForTest);
  98 };
  99
 100 class TaskQueueManagerTest : public testing::Test {
 101  protected:
 102   enum class SelectorType {
 103     Automatic,
 104     Explicit,
 105   };
 106
 107   void Initialize(size_t num_queues, SelectorType type) {
 108     now_src_ = cc::TestNowSource::Create(1000);
 109     test_task_runner_ =
 110         make_scoped_refptr(new cc::OrderedSimpleTaskRunner(now_src_, false));
 111     selector_ = make_scoped_ptr(createSelectorForTest(type));
 112     manager_ = make_scoped_ptr(new TaskQueueManager(
 113         num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()),
 114         selector_.get(), "test.scheduler"));
 115     manager_->SetTimeSourceForTesting(now_src_);
 116
 117     EXPECT_EQ(num_queues, selector_->work_queues().size());
 118   }
 119
 120   void InitializeWithRealMessageLoop(size_t num_queues, SelectorType type) {
 121     message_loop_.reset(new base::MessageLoop());
 122     selector_ = make_scoped_ptr(createSelectorForTest(type));
 123     manager_ = make_scoped_ptr(new TaskQueueManager(
 124         num_queues, SchedulerMessageLoopDelegate::Create(message_loop_.get()),
 125         selector_.get(), "test.scheduler"));
 126     EXPECT_EQ(num_queues, selector_->work_queues().size());
 127   }
 128
 129   SelectorForTest* createSelectorForTest(SelectorType type) {
 130     switch (type) {
 131       case SelectorType::Automatic:
 132         return new AutomaticSelectorForTest();
 133
 134       case SelectorType::Explicit:
 135         return new ExplicitSelectorForTest();
 136     }
 137
 138     return nullptr;
 139   }
 140
 141   scoped_refptr<cc::TestNowSource> now_src_;
 142   scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_;
 143   scoped_ptr<SelectorForTest> selector_;
 144   scoped_ptr<TaskQueueManager> manager_;
 145   scoped_ptr<base::MessageLoop> message_loop_;
 146 };
 147
 148 void PostFromNestedRunloop(base::MessageLoop* message_loop,
 149                            base::SingleThreadTaskRunner* runner,
 150                            std::vector<std::pair<base::Closure, bool>>* tasks) {
 151   base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
 152   for (std::pair<base::Closure, bool>& pair : *tasks) {
 153     if (pair.second) {
 154       runner->PostTask(FROM_HERE, pair.first);
 155     } else {
 156       runner->PostNonNestableTask(FROM_HERE, pair.first);
 157     }
 158   }
 159   message_loop->RunUntilIdle();
 160 }
 161
 162 void TestTask(int value, std::vector<int>* out_result) {
 163   out_result->push_back(value);
 164 }
 165
 166 TEST_F(TaskQueueManagerTest, SingleQueuePosting) {
 167   Initialize(1u, SelectorType::Automatic);
 168
 169   std::vector<int> run_order;
 170   scoped_refptr<base::SingleThreadTaskRunner> runner =
 171       manager_->TaskRunnerForQueue(0);
 172
 173   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 174   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 175   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 176
 177   test_task_runner_->RunUntilIdle();
 178   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 179 }
 180
 181 TEST_F(TaskQueueManagerTest, MultiQueuePosting) {
 182   Initialize(3u, SelectorType::Explicit);
 183
 184   std::vector<int> run_order;
 185   scoped_refptr<base::SingleThreadTaskRunner> runners[3] = {
 186       manager_->TaskRunnerForQueue(0),
 187       manager_->TaskRunnerForQueue(1),
 188       manager_->TaskRunnerForQueue(2)};
 189
 190   selector_->AppendQueueToService(0);
 191   selector_->AppendQueueToService(1);
 192   selector_->AppendQueueToService(2);
 193   selector_->AppendQueueToService(0);
 194   selector_->AppendQueueToService(1);
 195   selector_->AppendQueueToService(2);
 196
 197   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 198   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 199   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 200   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 201   runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order));
 202   runners[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order));
 203
 204   test_task_runner_->RunUntilIdle();
 205   EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6));
 206 }
 207
 208 void NopTask() {
 209 }
 210
 211 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) {
 212   Initialize(3u, SelectorType::Explicit);
 213
 214   scoped_refptr<cc::TestNowSource> now_src = cc::TestNowSource::Create(1000);
 215   manager_->SetTimeSourceForTesting(now_src);
 216
 217   scoped_refptr<base::SingleThreadTaskRunner> runners[3] = {
 218       manager_->TaskRunnerForQueue(0),
 219       manager_->TaskRunnerForQueue(1),
 220       manager_->TaskRunnerForQueue(2)};
 221
 222   selector_->AppendQueueToService(0);
 223   selector_->AppendQueueToService(1);
 224   selector_->AppendQueueToService(2);
 225   selector_->AppendQueueToService(0);
 226   selector_->AppendQueueToService(1);
 227   selector_->AppendQueueToService(2);
 228
 229   runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
 230   runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
 231   runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
 232   runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
 233   runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask));
 234   runners[2]->PostTask(FROM_HERE, base::Bind(&NopTask));
 235
 236   test_task_runner_->RunUntilIdle();
 237
 238   EXPECT_EQ(0, now_src->NumNowCalls());
 239 }
 240
 241 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) {
 242   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 243
 244   std::vector<int> run_order;
 245   scoped_refptr<base::SingleThreadTaskRunner> runner =
 246       manager_->TaskRunnerForQueue(0);
 247
 248   runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 249
 250   message_loop_->RunUntilIdle();
 251   EXPECT_THAT(run_order, ElementsAre(1));
 252 }
 253
 254 TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) {
 255   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 256
 257   std::vector<int> run_order;
 258   scoped_refptr<base::SingleThreadTaskRunner> runner =
 259       manager_->TaskRunnerForQueue(0);
 260
 261   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 262   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 263   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 264   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 265   runner->PostNonNestableTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order));
 266
 267   message_loop_->RunUntilIdle();
 268   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5));
 269 }
 270
 271 TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) {
 272   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 273
 274   std::vector<int> run_order;
 275   scoped_refptr<base::SingleThreadTaskRunner> runner =
 276       manager_->TaskRunnerForQueue(0);
 277
 278   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 279   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 280
 281   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
 282   tasks_to_post_from_nested_loop.push_back(
 283       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
 284   tasks_to_post_from_nested_loop.push_back(
 285       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
 286   tasks_to_post_from_nested_loop.push_back(
 287       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 288
 289   runner->PostTask(
 290       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
 291                             base::Unretained(&tasks_to_post_from_nested_loop)));
 292
 293   message_loop_->RunUntilIdle();
 294   // Note we expect task 3 to run last because it's non-nestable.
 295   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 296 }
 297
 298 TEST_F(TaskQueueManagerTest, QueuePolling) {
 299   Initialize(1u, SelectorType::Automatic);
 300
 301   std::vector<int> run_order;
 302   scoped_refptr<base::SingleThreadTaskRunner> runner =
 303       manager_->TaskRunnerForQueue(0);
 304
 305   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 306   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 307   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 308
 309   test_task_runner_->RunUntilIdle();
 310   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 311 }
 312
 313 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) {
 314   Initialize(1u, SelectorType::Automatic);
 315
 316   std::vector<int> run_order;
 317   scoped_refptr<base::SingleThreadTaskRunner> runner =
 318       manager_->TaskRunnerForQueue(0);
 319
 320   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 321   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 322                           delay);
 323   EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime());
 324   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 325   EXPECT_TRUE(run_order.empty());
 326
 327   // The task doesn't run before the delay has completed.
 328   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9));
 329   EXPECT_TRUE(run_order.empty());
 330
 331   // After the delay has completed, the task runs normally.
 332   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1));
 333   EXPECT_THAT(run_order, ElementsAre(1));
 334 }
 335
 336 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_DecendingOrder) {
 337   Initialize(1u, SelectorType::Automatic);
 338
 339   std::vector<int> run_order;
 340   scoped_refptr<base::SingleThreadTaskRunner> runner =
 341       manager_->TaskRunnerForQueue(0);
 342
 343   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 344                           base::TimeDelta::FromMilliseconds(10));
 345
 346   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
 347                           base::TimeDelta::FromMilliseconds(8));
 348
 349   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
 350                           base::TimeDelta::FromMilliseconds(5));
 351
 352   EXPECT_EQ(base::TimeDelta::FromMilliseconds(5),
 353             test_task_runner_->DelayToNextTaskTime());
 354
 355   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
 356   EXPECT_THAT(run_order, ElementsAre(3));
 357   EXPECT_EQ(base::TimeDelta::FromMilliseconds(3),
 358             test_task_runner_->DelayToNextTaskTime());
 359
 360   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(3));
 361   EXPECT_THAT(run_order, ElementsAre(3, 2));
 362   EXPECT_EQ(base::TimeDelta::FromMilliseconds(2),
 363             test_task_runner_->DelayToNextTaskTime());
 364
 365   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(2));
 366   EXPECT_THAT(run_order, ElementsAre(3, 2, 1));
 367 }
 368
 369 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_AscendingOrder) {
 370   Initialize(1u, SelectorType::Automatic);
 371
 372   std::vector<int> run_order;
 373   scoped_refptr<base::SingleThreadTaskRunner> runner =
 374       manager_->TaskRunnerForQueue(0);
 375
 376   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 377                           base::TimeDelta::FromMilliseconds(1));
 378
 379   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
 380                           base::TimeDelta::FromMilliseconds(5));
 381
 382   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
 383                           base::TimeDelta::FromMilliseconds(10));
 384
 385   EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
 386             test_task_runner_->DelayToNextTaskTime());
 387
 388   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1));
 389   EXPECT_THAT(run_order, ElementsAre(1));
 390   EXPECT_EQ(base::TimeDelta::FromMilliseconds(4),
 391             test_task_runner_->DelayToNextTaskTime());
 392
 393   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(4));
 394   EXPECT_THAT(run_order, ElementsAre(1, 2));
 395   EXPECT_EQ(base::TimeDelta::FromMilliseconds(5),
 396             test_task_runner_->DelayToNextTaskTime());
 397
 398   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
 399   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 400 }
 401
 402 TEST_F(TaskQueueManagerTest, PostDelayedTask_SharesUnderlyingDelayedTasks) {
 403   Initialize(1u, SelectorType::Automatic);
 404
 405   std::vector<int> run_order;
 406   scoped_refptr<base::SingleThreadTaskRunner> runner =
 407       manager_->TaskRunnerForQueue(0);
 408
 409   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 410   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 411                           delay);
 412   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
 413                           delay);
 414   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
 415                           delay);
 416
 417   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
 418 }
 419
 420 class TestObject {
 421  public:
 422   ~TestObject() { destructor_count_++; }
 423
 424   void Run() { FAIL() << "TestObject::Run should not be called"; }
 425
 426   static int destructor_count_;
 427 };
 428
 429 int TestObject::destructor_count_ = 0;
 430
 431 TEST_F(TaskQueueManagerTest, PendingDelayedTasksRemovedOnShutdown) {
 432   Initialize(1u, SelectorType::Automatic);
 433
 434   TestObject::destructor_count_ = 0;
 435
 436   scoped_refptr<base::SingleThreadTaskRunner> runner =
 437       manager_->TaskRunnerForQueue(0);
 438
 439   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 440   runner->PostDelayedTask(
 441       FROM_HERE, base::Bind(&TestObject::Run, base::Owned(new TestObject())),
 442       delay);
 443   runner->PostTask(
 444       FROM_HERE, base::Bind(&TestObject::Run, base::Owned(new TestObject())));
 445
 446   manager_.reset();
 447
 448   EXPECT_EQ(2, TestObject::destructor_count_);
 449 }
 450
 451 TEST_F(TaskQueueManagerTest, ManualPumping) {
 452   Initialize(1u, SelectorType::Automatic);
 453   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 454
 455   std::vector<int> run_order;
 456   scoped_refptr<base::SingleThreadTaskRunner> runner =
 457       manager_->TaskRunnerForQueue(0);
 458
 459   // Posting a task when pumping is disabled doesn't result in work getting
 460   // posted.
 461   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 462   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 463
 464   // However polling still works.
 465   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 466
 467   // After pumping the task runs normally.
 468   manager_->PumpQueue(0);
 469   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
 470   test_task_runner_->RunUntilIdle();
 471   EXPECT_THAT(run_order, ElementsAre(1));
 472 }
 473
 474 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) {
 475   Initialize(1u, SelectorType::Automatic);
 476   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 477
 478   std::vector<int> run_order;
 479   scoped_refptr<base::SingleThreadTaskRunner> runner =
 480       manager_->TaskRunnerForQueue(0);
 481
 482   // Posting a task when pumping is disabled doesn't result in work getting
 483   // posted.
 484   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 485   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 486
 487   // When pumping is enabled the task runs normally.
 488   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AUTO);
 489   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
 490   test_task_runner_->RunUntilIdle();
 491   EXPECT_THAT(run_order, ElementsAre(1));
 492 }
 493
 494 TEST_F(TaskQueueManagerTest, DenyRunning) {
 495   Initialize(1u, SelectorType::Explicit);
 496
 497   std::vector<int> run_order;
 498   scoped_refptr<base::SingleThreadTaskRunner> runner =
 499       manager_->TaskRunnerForQueue(0);
 500   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 501
 502   // Since we haven't appended a work queue to be selected, the task doesn't
 503   // run.
 504   test_task_runner_->RunUntilIdle();
 505   EXPECT_TRUE(run_order.empty());
 506
 507   // Pumping the queue again with a selected work queue runs the task.
 508   manager_->PumpQueue(0);
 509   selector_->AppendQueueToService(0);
 510   test_task_runner_->RunUntilIdle();
 511   EXPECT_THAT(run_order, ElementsAre(1));
 512 }
 513
 514 TEST_F(TaskQueueManagerTest, ManualPumpingWithDelayedTask) {
 515   Initialize(1u, SelectorType::Automatic);
 516   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 517
 518   std::vector<int> run_order;
 519   scoped_refptr<base::SingleThreadTaskRunner> runner =
 520       manager_->TaskRunnerForQueue(0);
 521
 522   // Posting a delayed task when pumping will apply the delay, but won't cause
 523   // work to executed afterwards.
 524   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 525   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 526                           delay);
 527
 528   // After pumping but before the delay period has expired, task does not run.
 529   manager_->PumpQueue(0);
 530   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
 531   EXPECT_TRUE(run_order.empty());
 532
 533   // Once the delay has expired, pumping causes the task to run.
 534   now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(5));
 535   manager_->PumpQueue(0);
 536   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
 537   test_task_runner_->RunPendingTasks();
 538   EXPECT_THAT(run_order, ElementsAre(1));
 539 }
 540
 541 TEST_F(TaskQueueManagerTest, ManualPumpingWithMultipleDelayedTasks) {
 542   Initialize(1u, SelectorType::Automatic);
 543   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 544
 545   std::vector<int> run_order;
 546   scoped_refptr<base::SingleThreadTaskRunner> runner =
 547       manager_->TaskRunnerForQueue(0);
 548
 549   // Posting a delayed task when pumping will apply the delay, but won't cause
 550   // work to executed afterwards.
 551   base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1));
 552   base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10));
 553   base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20));
 554   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 555                           delay1);
 556   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
 557                           delay2);
 558   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
 559                           delay3);
 560
 561   now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(15));
 562   test_task_runner_->RunUntilIdle();
 563   EXPECT_TRUE(run_order.empty());
 564
 565   // Once the delay has expired, pumping causes the task to run.
 566   manager_->PumpQueue(0);
 567   test_task_runner_->RunUntilIdle();
 568   EXPECT_THAT(run_order, ElementsAre(1, 2));
 569 }
 570
 571 TEST_F(TaskQueueManagerTest, DelayedTasksDontAutoRunWithManualPumping) {
 572   Initialize(1u, SelectorType::Automatic);
 573   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 574
 575   std::vector<int> run_order;
 576   scoped_refptr<base::SingleThreadTaskRunner> runner =
 577       manager_->TaskRunnerForQueue(0);
 578
 579   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
 580   runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
 581                           delay);
 582
 583   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10));
 584   EXPECT_TRUE(run_order.empty());
 585 }
 586
 587 TEST_F(TaskQueueManagerTest, ManualPumpingWithNonEmptyWorkQueue) {
 588   Initialize(1u, SelectorType::Automatic);
 589   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 590
 591   std::vector<int> run_order;
 592   scoped_refptr<base::SingleThreadTaskRunner> runner =
 593       manager_->TaskRunnerForQueue(0);
 594
 595   // Posting two tasks and pumping twice should result in two tasks in the work
 596   // queue.
 597   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 598   manager_->PumpQueue(0);
 599   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 600   manager_->PumpQueue(0);
 601
 602   EXPECT_EQ(2u, selector_->work_queues()[0]->size());
 603 }
 604
 605 void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
 606                        int countdown,
 607                        std::vector<int>* out_result) {
 608   out_result->push_back(countdown);
 609   if (--countdown) {
 610     runner->PostTask(FROM_HERE,
 611                      Bind(&ReentrantTestTask, runner, countdown, out_result));
 612   }
 613 }
 614
 615 TEST_F(TaskQueueManagerTest, ReentrantPosting) {
 616   Initialize(1u, SelectorType::Automatic);
 617
 618   std::vector<int> run_order;
 619   scoped_refptr<base::SingleThreadTaskRunner> runner =
 620       manager_->TaskRunnerForQueue(0);
 621
 622   runner->PostTask(FROM_HERE, Bind(&ReentrantTestTask, runner, 3, &run_order));
 623
 624   test_task_runner_->RunUntilIdle();
 625   EXPECT_THAT(run_order, ElementsAre(3, 2, 1));
 626 }
 627
 628 TEST_F(TaskQueueManagerTest, NoTasksAfterShutdown) {
 629   Initialize(1u, SelectorType::Automatic);
 630
 631   std::vector<int> run_order;
 632   scoped_refptr<base::SingleThreadTaskRunner> runner =
 633       manager_->TaskRunnerForQueue(0);
 634
 635   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 636   manager_.reset();
 637   selector_.reset();
 638   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 639
 640   test_task_runner_->RunUntilIdle();
 641   EXPECT_TRUE(run_order.empty());
 642 }
 643
 644 void PostTaskToRunner(scoped_refptr<base::SingleThreadTaskRunner> runner,
 645                       std::vector<int>* run_order) {
 646   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, run_order));
 647 }
 648
 649 TEST_F(TaskQueueManagerTest, PostFromThread) {
 650   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 651
 652   std::vector<int> run_order;
 653   scoped_refptr<base::SingleThreadTaskRunner> runner =
 654       manager_->TaskRunnerForQueue(0);
 655
 656   base::Thread thread("TestThread");
 657   thread.Start();
 658   thread.message_loop()->PostTask(
 659       FROM_HERE, base::Bind(&PostTaskToRunner, runner, &run_order));
 660   thread.Stop();
 661
 662   message_loop_->RunUntilIdle();
 663   EXPECT_THAT(run_order, ElementsAre(1));
 664 }
 665
 666 void RePostingTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
 667                        int* run_count) {
 668   (*run_count)++;
 669   runner->PostTask(FROM_HERE, Bind(&RePostingTestTask,
 670                                    base::Unretained(runner.get()), run_count));
 671 }
 672
 673 TEST_F(TaskQueueManagerTest, DoWorkCantPostItselfMultipleTimes) {
 674   Initialize(1u, SelectorType::Automatic);
 675   scoped_refptr<base::SingleThreadTaskRunner> runner =
 676       manager_->TaskRunnerForQueue(0);
 677
 678   int run_count = 0;
 679   runner->PostTask(FROM_HERE,
 680                    base::Bind(&RePostingTestTask, runner, &run_count));
 681
 682   test_task_runner_->RunPendingTasks();
 683   // NOTE without the executing_task_ check in MaybePostDoWorkOnMainRunner there
 684   // will be two tasks here.
 685   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
 686   EXPECT_EQ(1, run_count);
 687 }
 688
 689 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) {
 690   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 691
 692   std::vector<int> run_order;
 693   scoped_refptr<base::SingleThreadTaskRunner> runner =
 694       manager_->TaskRunnerForQueue(0);
 695
 696   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
 697   tasks_to_post_from_nested_loop.push_back(
 698       std::make_pair(base::Bind(&TestTask, 1, &run_order), true));
 699
 700   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
 701   runner->PostTask(
 702       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
 703                             base::Unretained(&tasks_to_post_from_nested_loop)));
 704   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 705
 706   message_loop_->RunUntilIdle();
 707
 708   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 709 }
 710
 711 TEST_F(TaskQueueManagerTest, WorkBatching) {
 712   Initialize(1u, SelectorType::Automatic);
 713
 714   manager_->SetWorkBatchSize(2);
 715
 716   std::vector<int> run_order;
 717   scoped_refptr<base::SingleThreadTaskRunner> runner =
 718       manager_->TaskRunnerForQueue(0);
 719
 720   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 721   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 722   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 723   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 724
 725   // Running one task in the host message loop should cause two posted tasks to
 726   // get executed.
 727   EXPECT_EQ(test_task_runner_->NumPendingTasks(), 1u);
 728   test_task_runner_->RunPendingTasks();
 729   EXPECT_THAT(run_order, ElementsAre(1, 2));
 730
 731   // The second task runs the remaining two posted tasks.
 732   EXPECT_EQ(test_task_runner_->NumPendingTasks(), 1u);
 733   test_task_runner_->RunPendingTasks();
 734   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4));
 735 }
 736
 737 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeup) {
 738   Initialize(2u, SelectorType::Explicit);
 739   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 740
 741   std::vector<int> run_order;
 742   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 743       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 744
 745   selector_->AppendQueueToService(1);
 746   selector_->AppendQueueToService(0);
 747   selector_->AppendQueueToService(0);
 748
 749   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 750   test_task_runner_->RunUntilIdle();
 751   EXPECT_TRUE(run_order.empty());  // Shouldn't run - no other task to wake TQM.
 752
 753   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 754   test_task_runner_->RunUntilIdle();
 755   EXPECT_TRUE(run_order.empty());  // Still shouldn't wake TQM.
 756
 757   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 758   test_task_runner_->RunUntilIdle();
 759   // Executing a task on an auto pumped queue should wake the TQM.
 760   EXPECT_THAT(run_order, ElementsAre(3, 1, 2));
 761 }
 762
 763 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupWhenAlreadyAwake) {
 764   Initialize(2u, SelectorType::Explicit);
 765   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 766
 767   std::vector<int> run_order;
 768   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 769       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 770
 771   selector_->AppendQueueToService(1);
 772   selector_->AppendQueueToService(0);
 773
 774   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 775   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 776   test_task_runner_->RunUntilIdle();
 777   EXPECT_THAT(run_order, ElementsAre(2, 1));  // TQM was already awake.
 778 }
 779
 780 TEST_F(TaskQueueManagerTest,
 781        AutoPumpAfterWakeupTriggeredByManuallyPumpedQueue) {
 782   Initialize(2u, SelectorType::Explicit);
 783   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 784   manager_->SetPumpPolicy(1, TaskQueueManager::PumpPolicy::MANUAL);
 785
 786   std::vector<int> run_order;
 787   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 788       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 789
 790   selector_->AppendQueueToService(1);
 791   selector_->AppendQueueToService(0);
 792
 793   runners[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 794   test_task_runner_->RunUntilIdle();
 795   EXPECT_TRUE(run_order.empty());  // Shouldn't run - no other task to wake TQM.
 796
 797   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 798   test_task_runner_->RunUntilIdle();
 799   // This still shouldn't wake TQM as manual queue was not pumped.
 800   EXPECT_TRUE(run_order.empty());
 801
 802   manager_->PumpQueue(1);
 803   test_task_runner_->RunUntilIdle();
 804   // Executing a task on an auto pumped queue should wake the TQM.
 805   EXPECT_THAT(run_order, ElementsAre(2, 1));
 806 }
 807
 808 void TestPostingTask(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
 809                      base::Closure task) {
 810   task_runner->PostTask(FROM_HERE, task);
 811 }
 812
 813 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupFromTask) {
 814   Initialize(2u, SelectorType::Explicit);
 815   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 816
 817   std::vector<int> run_order;
 818   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 819       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 820
 821   selector_->AppendQueueToService(1);
 822   selector_->AppendQueueToService(1);
 823   selector_->AppendQueueToService(0);
 824
 825   // Check that a task which posts a task to an auto pump after wakeup queue
 826   // doesn't cause the queue to wake up.
 827   base::Closure after_wakeup_task = base::Bind(&TestTask, 1, &run_order);
 828   runners[1]->PostTask(
 829       FROM_HERE, base::Bind(&TestPostingTask, runners[0], after_wakeup_task));
 830   test_task_runner_->RunUntilIdle();
 831   EXPECT_TRUE(run_order.empty());
 832
 833   // Wake up the queue.
 834   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 835   test_task_runner_->RunUntilIdle();
 836   EXPECT_THAT(run_order, ElementsAre(2, 1));
 837 }
 838
 839 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupFromMultipleTasks) {
 840   Initialize(2u, SelectorType::Explicit);
 841   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 842
 843   std::vector<int> run_order;
 844   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 845       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 846
 847   selector_->AppendQueueToService(1);
 848   selector_->AppendQueueToService(1);
 849   selector_->AppendQueueToService(1);
 850   selector_->AppendQueueToService(0);
 851   selector_->AppendQueueToService(0);
 852
 853   // Check that a task which posts a task to an auto pump after wakeup queue
 854   // doesn't cause the queue to wake up.
 855   base::Closure after_wakeup_task_1 = base::Bind(&TestTask, 1, &run_order);
 856   base::Closure after_wakeup_task_2 = base::Bind(&TestTask, 2, &run_order);
 857   runners[1]->PostTask(
 858       FROM_HERE, base::Bind(&TestPostingTask, runners[0], after_wakeup_task_1));
 859   runners[1]->PostTask(
 860       FROM_HERE, base::Bind(&TestPostingTask, runners[0], after_wakeup_task_2));
 861   test_task_runner_->RunUntilIdle();
 862   EXPECT_TRUE(run_order.empty());
 863
 864   // Wake up the queue.
 865   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 866   test_task_runner_->RunUntilIdle();
 867   EXPECT_THAT(run_order, ElementsAre(3, 1, 2));
 868 }
 869
 870 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupBecomesQuiescent) {
 871   Initialize(2u, SelectorType::Explicit);
 872   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 873
 874   int run_count = 0;
 875   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 876       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 877
 878   selector_->AppendQueueToService(1);
 879   selector_->AppendQueueToService(0);
 880   selector_->AppendQueueToService(0);
 881   // Append extra service queue '0' entries to the selector otherwise test will
 882   // finish even if the RePostingTestTask woke each other up.
 883   selector_->AppendQueueToService(0);
 884   selector_->AppendQueueToService(0);
 885
 886   // Check that if multiple tasks reposts themselves onto a pump-after-wakeup
 887   // queue they don't wake each other and will eventually stop when no other
 888   // tasks execute.
 889   runners[0]->PostTask(FROM_HERE,
 890                        base::Bind(&RePostingTestTask, runners[0], &run_count));
 891   runners[0]->PostTask(FROM_HERE,
 892                        base::Bind(&RePostingTestTask, runners[0], &run_count));
 893   runners[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
 894   test_task_runner_->RunUntilIdle();
 895   // The reposting tasks posted to the after wakeup queue shouldn't have woken
 896   // each other up.
 897   EXPECT_EQ(2, run_count);
 898 }
 899
 900 class MockTaskObserver : public base::MessageLoop::TaskObserver {
 901  public:
 902   MOCK_METHOD1(DidProcessTask, void(const base::PendingTask& task));
 903   MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task));
 904 };
 905
 906 TEST_F(TaskQueueManagerTest, TaskObserverAdding) {
 907   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 908   MockTaskObserver observer;
 909
 910   manager_->SetWorkBatchSize(2);
 911   manager_->AddTaskObserver(&observer);
 912
 913   std::vector<int> run_order;
 914   scoped_refptr<base::SingleThreadTaskRunner> runner =
 915       manager_->TaskRunnerForQueue(0);
 916
 917   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 918   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 919
 920   // Two pairs of callbacks for the tasks above plus another one for the
 921   // DoWork() posted by the task queue manager.
 922   EXPECT_CALL(observer, WillProcessTask(_)).Times(3);
 923   EXPECT_CALL(observer, DidProcessTask(_)).Times(3);
 924   message_loop_->RunUntilIdle();
 925 }
 926
 927 TEST_F(TaskQueueManagerTest, TaskObserverRemoving) {
 928   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 929   MockTaskObserver observer;
 930   manager_->SetWorkBatchSize(2);
 931   manager_->AddTaskObserver(&observer);
 932   manager_->RemoveTaskObserver(&observer);
 933
 934   std::vector<int> run_order;
 935   scoped_refptr<base::SingleThreadTaskRunner> runner =
 936       manager_->TaskRunnerForQueue(0);
 937
 938   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 939
 940   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
 941   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 942
 943   message_loop_->RunUntilIdle();
 944 }
 945
 946 void RemoveObserverTask(TaskQueueManager* manager,
 947                         base::MessageLoop::TaskObserver* observer) {
 948   manager->RemoveTaskObserver(observer);
 949 }
 950
 951 TEST_F(TaskQueueManagerTest, TaskObserverRemovingInsideTask) {
 952   InitializeWithRealMessageLoop(1u, SelectorType::Automatic);
 953   MockTaskObserver observer;
 954   manager_->SetWorkBatchSize(3);
 955   manager_->AddTaskObserver(&observer);
 956
 957   scoped_refptr<base::SingleThreadTaskRunner> runner =
 958       manager_->TaskRunnerForQueue(0);
 959   runner->PostTask(FROM_HERE,
 960                    base::Bind(&RemoveObserverTask, manager_.get(), &observer));
 961
 962   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
 963   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 964   message_loop_->RunUntilIdle();
 965 }
 966
 967 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) {
 968   Initialize(1u, SelectorType::Automatic);
 969   scoped_refptr<base::SingleThreadTaskRunner> runner =
 970       manager_->TaskRunnerForQueue(0);
 971   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 972   manager_.reset();
 973   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 974 }
 975
 976 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) {
 977   scoped_refptr<cc::TestNowSource> clock(cc::TestNowSource::Create());
 978   Initialize(2u, SelectorType::Explicit);
 979   manager_->SetTimeSourceForTesting(clock);
 980
 981   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
 982       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 983
 984   // With no delayed tasks.
 985   EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null());
 986
 987   // With a non-delayed task.
 988   runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
 989   EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null());
 990
 991   // With a delayed task.
 992   base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50);
 993   runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay);
 994   EXPECT_EQ(clock->Now() + expected_delay,
 995             manager_->NextPendingDelayedTaskRunTime());
 996
 997   // With another delayed task in the same queue with a longer delay.
 998   runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
 999                               base::TimeDelta::FromMilliseconds(100));
1000   EXPECT_EQ(clock->Now() + expected_delay,
1001             manager_->NextPendingDelayedTaskRunTime());
1002
1003   // With another delayed task in the same queue with a shorter delay.
1004   expected_delay = base::TimeDelta::FromMilliseconds(20);
1005   runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay);
1006   EXPECT_EQ(clock->Now() + expected_delay,
1007             manager_->NextPendingDelayedTaskRunTime());
1008
1009   // With another delayed task in a different queue with a shorter delay.
1010   expected_delay = base::TimeDelta::FromMilliseconds(10);
1011   runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay);
1012   EXPECT_EQ(clock->Now() + expected_delay,
1013             manager_->NextPendingDelayedTaskRunTime());
1014
1015   // Test it updates as time progresses
1016   clock->AdvanceNow(expected_delay);
1017   EXPECT_EQ(clock->Now(), manager_->NextPendingDelayedTaskRunTime());
1018 }
1019
1020 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) {
1021   Initialize(3u, SelectorType::Automatic);
1022
1023   scoped_refptr<base::SingleThreadTaskRunner> runners[3] = {
1024       manager_->TaskRunnerForQueue(0),
1025       manager_->TaskRunnerForQueue(1),
1026       manager_->TaskRunnerForQueue(2)};
1027
1028   base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50);
1029   base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5);
1030   base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10);
1031   runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1);
1032   runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2);
1033   runners[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3);
1034
1035   EXPECT_EQ(now_src_->Now() + delay2,
1036             manager_->NextPendingDelayedTaskRunTime());
1037 }
1038
1039 }  // namespace
1040 }  // namespace content