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