Revert of Move throttling of background timers into the renderer scheduler

components/scheduler/base/task_queue_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/scheduler/base/task_queue_manager.h"
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 198 matching lines @@
 
   message_loop_->RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
 TEST_F(TaskQueueManagerTest, QueuePolling) {
   Initialize(1u);
 
   std::vector<int> run_order;
-  EXPECT_FALSE(runners_[0]->HasPendingImmediateTask());
+  EXPECT_TRUE(runners_[0]->IsQueueEmpty());
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
-  EXPECT_TRUE(runners_[0]->HasPendingImmediateTask());
+  EXPECT_FALSE(runners_[0]->IsQueueEmpty());
 
   test_task_runner_->RunUntilIdle();
-  EXPECT_FALSE(runners_[0]->HasPendingImmediateTask());
+  EXPECT_TRUE(runners_[0]->IsQueueEmpty());
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) {
   Initialize(1u);
 
   std::vector<int> run_order;
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
   EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime());
-  EXPECT_EQ(TaskQueue::QueueState::NO_IMMEDIATE_WORK,
-            runners_[0]->GetQueueState());
+  EXPECT_TRUE(runners_[0]->IsQueueEmpty());
   EXPECT_TRUE(run_order.empty());
 
   // The task doesn't run before the delay has completed.
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9));
   EXPECT_TRUE(run_order.empty());
 
   // After the delay has completed, the task runs normally.
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1));
   EXPECT_THAT(run_order, ElementsAre(1));
-  EXPECT_EQ(TaskQueue::QueueState::EMPTY, runners_[0]->GetQueueState());
 }
 
 bool MessageLoopTaskCounter(size_t* count) {
   *count = *count + 1;
   return true;
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) {
   Initialize(1u);
 
@@ skipping 113 matching lines @@
   Initialize(1u);
   runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   // Posting a task when pumping is disabled doesn't result in work getting
   // posted.
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 
   // However polling still works.
-  EXPECT_TRUE(runners_[0]->HasPendingImmediateTask());
+  EXPECT_FALSE(runners_[0]->IsQueueEmpty());
 
   // After pumping the task runs normally.
   runners_[0]->PumpQueue();
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) {
   Initialize(1u);
@@ skipping 607 matching lines @@
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(manager_->GetAndClearSystemIsQuiescentBit());
 
   queue0->PostTask(FROM_HERE, base::Bind(&NopTask));
   queue1->PostTask(FROM_HERE, base::Bind(&NopTask));
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(manager_->GetAndClearSystemIsQuiescentBit());
   EXPECT_TRUE(manager_->GetAndClearSystemIsQuiescentBit());
 }
 
-TEST_F(TaskQueueManagerTest, HasPendingImmediateTask) {
+TEST_F(TaskQueueManagerTest, IsQueueEmpty) {
   Initialize(2u);
   internal::TaskQueueImpl* queue0 = runners_[0].get();
   internal::TaskQueueImpl* queue1 = runners_[1].get();
   queue0->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
   queue1->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
-  EXPECT_FALSE(queue0->HasPendingImmediateTask());
-  EXPECT_FALSE(queue1->HasPendingImmediateTask());
+  EXPECT_TRUE(queue0->IsQueueEmpty());
+  EXPECT_TRUE(queue1->IsQueueEmpty());
 
   queue0->PostTask(FROM_HERE, base::Bind(NullTask));
   queue1->PostTask(FROM_HERE, base::Bind(NullTask));
-  EXPECT_TRUE(queue0->HasPendingImmediateTask());
-  EXPECT_TRUE(queue1->HasPendingImmediateTask());
+  EXPECT_FALSE(queue0->IsQueueEmpty());
+  EXPECT_FALSE(queue1->IsQueueEmpty());
 
   test_task_runner_->RunUntilIdle();
-  EXPECT_FALSE(queue0->HasPendingImmediateTask());
-  EXPECT_TRUE(queue1->HasPendingImmediateTask());
+  EXPECT_TRUE(queue0->IsQueueEmpty());
+  EXPECT_FALSE(queue1->IsQueueEmpty());
 
   queue1->PumpQueue();
-  EXPECT_FALSE(queue0->HasPendingImmediateTask());
-  EXPECT_TRUE(queue1->HasPendingImmediateTask());
+  EXPECT_TRUE(queue0->IsQueueEmpty());
+  EXPECT_FALSE(queue1->IsQueueEmpty());
 
   test_task_runner_->RunUntilIdle();
-  EXPECT_FALSE(queue0->HasPendingImmediateTask());
-  EXPECT_FALSE(queue1->HasPendingImmediateTask());
+  EXPECT_TRUE(queue0->IsQueueEmpty());
+  EXPECT_TRUE(queue1->IsQueueEmpty());
 }
 
 TEST_F(TaskQueueManagerTest, GetQueueState) {
   Initialize(2u);
   internal::TaskQueueImpl* queue0 = runners_[0].get();
   internal::TaskQueueImpl* queue1 = runners_[1].get();
   queue0->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
   queue1->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   EXPECT_EQ(TaskQueue::QueueState::EMPTY, queue0->GetQueueState());
@@ skipping 53 matching lines @@
                                delay1);
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                delay2);
 
   now_src_->Advance(delay1 * 2);
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(2, 1));
 }
 
+TEST_F(TaskQueueManagerTest, DelayedTaskWithAbsoluteRunTime) {
+  Initialize(1u);
+
+  // One task in the past, two with the exact same run time and one in the
+  // future.
+  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
+  base::TimeTicks runTime1 = now_src_->NowTicks() - delay;
+  base::TimeTicks runTime2 = now_src_->NowTicks();
+  base::TimeTicks runTime3 = now_src_->NowTicks();
+  base::TimeTicks runTime4 = now_src_->NowTicks() + delay;
+
+  std::vector<int> run_order;
+  runners_[0]->PostDelayedTaskAt(
+      FROM_HERE, base::Bind(&TestTask, 1, &run_order), runTime1);
+  runners_[0]->PostDelayedTaskAt(
+      FROM_HERE, base::Bind(&TestTask, 2, &run_order), runTime2);
+  runners_[0]->PostDelayedTaskAt(
+      FROM_HERE, base::Bind(&TestTask, 3, &run_order), runTime3);
+  runners_[0]->PostDelayedTaskAt(
+      FROM_HERE, base::Bind(&TestTask, 4, &run_order), runTime4);
+
+  now_src_->Advance(2 * delay);
+  test_task_runner_->RunUntilIdle();
+
+  EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4));
+}
+
 void CheckIsNested(bool* is_nested) {
   *is_nested = base::MessageLoop::current()->IsNested();
 }
 
 void PostAndQuitFromNestedRunloop(base::RunLoop* run_loop,
                                   base::SingleThreadTaskRunner* runner,
                                   bool* was_nested) {
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::MessageLoop::current());
   runner->PostTask(FROM_HERE, run_loop->QuitClosure());
@@ skipping 174 matching lines @@
 
   scoped_refptr<internal::TaskQueueImpl> task_queue =
       manager_->NewTaskQueue(TaskQueue::Spec("test_queue"));
 
   EXPECT_CALL(observer, OnUnregisterTaskQueue(_)).Times(1);
   task_queue->UnregisterTaskQueue();
 
   manager_->SetObserver(nullptr);
 }
 
+TEST_F(TaskQueueManagerTest, ScheduleDelayedWorkIsNotReEntrant) {
+  Initialize(1u);
+
+  // Post two tasks into the past. The second one used to trigger a deadlock
+  // because it tried to re-entrantly wake the first task in the same queue.
+  runners_[0]->PostDelayedTaskAt(
+      FROM_HERE, base::Bind(&NullTask),
+      base::TimeTicks() + base::TimeDelta::FromMicroseconds(100));
+  runners_[0]->PostDelayedTaskAt(
+      FROM_HERE, base::Bind(&NullTask),
+      base::TimeTicks() + base::TimeDelta::FromMicroseconds(200));
+  test_task_runner_->RunUntilIdle();
+}
+
 void HasOneRefTask(std::vector<bool>* log, internal::TaskQueueImpl* tq) {
   log->push_back(tq->HasOneRef());
 }
 
 TEST_F(TaskQueueManagerTest, UnregisterTaskQueueInNestedLoop) {
   InitializeWithRealMessageLoop(1u);
 
   // We retain a reference to the task queue even when the manager has deleted
   // its reference.
   scoped_refptr<internal::TaskQueueImpl> task_queue =
@@ skipping 30 matching lines @@
                                    base::Unretained(task_queue.get())));
   message_loop_->RunUntilIdle();
 
   EXPECT_THAT(log, ElementsAre(false, false, true));
 }
 
 TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) {
   Initialize(2u);
 
   base::TimeTicks start_time = manager_->delegate()->NowTicks();
-  scoped_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(nullptr, start_time));
-  scoped_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(nullptr, start_time));
-  manager_->RegisterTimeDomain(domain_a.get());
-  manager_->RegisterTimeDomain(domain_b.get());
-  runners_[0]->SetTimeDomain(domain_a.get());
-  runners_[1]->SetTimeDomain(domain_b.get());
+  scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time));
+  scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time));
+  manager_->RegisterTimeDomain(domain_a);
+  manager_->RegisterTimeDomain(domain_b);
+  runners_[0]->SetTimeDomain(domain_a);
+  runners_[1]->SetTimeDomain(domain_b);
 
   std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
 
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
 
   domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(4, 5, 6));
 
   domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(4, 5, 6, 1, 2, 3));
 
-  manager_->UnregisterTimeDomain(domain_a.get());
-  manager_->UnregisterTimeDomain(domain_b.get());
+  manager_->UnregisterTimeDomain(domain_a);
+  manager_->UnregisterTimeDomain(domain_b);
 }
 
 TEST_F(TaskQueueManagerTest, TimeDomainMigration) {
   Initialize(1u);
 
   base::TimeTicks start_time = manager_->delegate()->NowTicks();
-  scoped_ptr<VirtualTimeDomain> domain_a(
-      new VirtualTimeDomain(nullptr, start_time));
-  manager_->RegisterTimeDomain(domain_a.get());
-  runners_[0]->SetTimeDomain(domain_a.get());
+  scoped_refptr<VirtualTimeDomain> domain_a(new VirtualTimeDomain(start_time));
+  manager_->RegisterTimeDomain(domain_a);
+  runners_[0]->SetTimeDomain(domain_a);
 
   std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order),
                                base::TimeDelta::FromMilliseconds(40));
 
   domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 
-  scoped_ptr<VirtualTimeDomain> domain_b(
-      new VirtualTimeDomain(nullptr, start_time));
-  manager_->RegisterTimeDomain(domain_b.get());
-  runners_[0]->SetTimeDomain(domain_b.get());
+  scoped_refptr<VirtualTimeDomain> domain_b(new VirtualTimeDomain(start_time));
+  manager_->RegisterTimeDomain(domain_b);
+  runners_[0]->SetTimeDomain(domain_b);
 
   domain_b->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(50));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4));
 
-  manager_->UnregisterTimeDomain(domain_a.get());
-  manager_->UnregisterTimeDomain(domain_b.get());
+  manager_->UnregisterTimeDomain(domain_a);
+  manager_->UnregisterTimeDomain(domain_b);
 }
 
 namespace {
 void ChromiumRunloopInspectionTask(
     scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner) {
   EXPECT_EQ(1u, test_task_runner->NumPendingTasks());
 }
 }  // namespace
 
 TEST_F(TaskQueueManagerTest, NumberOfPendingTasksOnChromiumRunLoop) {
   Initialize(1u);
 
   // NOTE because tasks posted to the chromiumrun loop are not cancellable, we
   // will end up with a lot more tasks posted if the delayed tasks were posted
   // in the reverse order.
   // TODO(alexclarke): Consider talking to the message pump directly.
   test_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   for (int i = 1; i < 100; i++) {
     runners_[0]->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ChromiumRunloopInspectionTask, test_task_runner_),
         base::TimeDelta::FromMilliseconds(i));
   }
   test_task_runner_->RunUntilIdle();
 }
 
 }  // namespace scheduler