[Reland] Dont post delayed DoWork for disabled queues.

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
index fc290a3c42e06a279c3382b291972f903b04caba..5c0dd925730681c912a0c945b77acb4a82af1d0a 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
@@ -32,9 +32,11 @@
 #include "platform/scheduler/base/work_queue_sets.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
+using testing::AnyNumber;
 using testing::Contains;
 using testing::ElementsAre;
 using testing::ElementsAreArray;
+using testing::Mock;
 using testing::Not;
 using testing::_;
 using blink::scheduler::internal::EnqueueOrder;
@@ -42,6 +44,21 @@ using blink::scheduler::internal::EnqueueOrder;
 namespace blink {
 namespace scheduler {
 
+class TaskQueueManagerForTest : public TaskQueueManager {
+ public:
+  TaskQueueManagerForTest(
+      scoped_refptr<TaskQueueManagerDelegate> delegate,
+      const char* tracing_category,
+      const char* disabled_by_default_tracing_category,
+      const char* disabled_by_default_verbose_tracing_category)
+      : TaskQueueManager(delegate,
+                         tracing_category,
+                         disabled_by_default_tracing_category,
+                         disabled_by_default_verbose_tracing_category) {}
+
+  using TaskQueueManager::NextTaskDelay;
+};
+
 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest {
  public:
   static scoped_refptr<MessageLoopTaskRunner> Create(
@@ -85,7 +102,7 @@ class TaskQueueManagerTest : public testing::Test {
         test_task_runner_.get(),
         base::MakeUnique<TestTimeSource>(now_src_.get()));
 
-    manager_ = base::MakeUnique<TaskQueueManager>(
+    manager_ = base::MakeUnique<TaskQueueManagerForTest>(
         main_task_runner_, "test.scheduler", "test.scheduler",
         "test.scheduler.debug");
 
@@ -106,7 +123,7 @@ class TaskQueueManagerTest : public testing::Test {
     message_loop_.reset(new base::MessageLoop());
     // A null clock triggers some assertions.
     now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
-    manager_ = base::MakeUnique<TaskQueueManager>(
+    manager_ = base::MakeUnique<TaskQueueManagerForTest>(
         MessageLoopTaskRunner::Create(
             base::WrapUnique(new TestTimeSource(now_src_.get()))),
         "test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -120,12 +137,14 @@ class TaskQueueManagerTest : public testing::Test {
     manager_->WakeupReadyDelayedQueues(&lazy_now);
   }
 
-  base::Optional<base::TimeDelta> ComputeDelayTillNextTask(LazyNow* lazy_now) {
+  using NextTaskDelay = TaskQueueManagerForTest::NextTaskDelay;
+
+  base::Optional<NextTaskDelay> ComputeDelayTillNextTask(LazyNow* lazy_now) {
     base::AutoLock lock(manager_->any_thread_lock_);
     return manager_->ComputeDelayTillNextTaskLocked(lazy_now);
   }
 
-  void PostDoWorkContinuation(base::Optional<base::TimeDelta> next_delay,
+  void PostDoWorkContinuation(base::Optional<NextTaskDelay> next_delay,
                               LazyNow* lazy_now) {
     MoveableAutoLock lock(manager_->any_thread_lock_);
     return manager_->PostDoWorkContinuationLocked(next_delay, lazy_now,
@@ -137,8 +156,8 @@ class TaskQueueManagerTest : public testing::Test {
     return manager_->any_thread().immediate_do_work_posted_count;
   }
 
-  base::TimeTicks next_scheduled_delayed_do_work_time() const {
-    return manager_->next_scheduled_delayed_do_work_time_;
+  base::TimeTicks next_delayed_do_work_time() const {
+    return manager_->next_delayed_do_work_.run_time();
   }
 
   EnqueueOrder GetNextSequenceNumber() const {
@@ -175,7 +194,7 @@ class TaskQueueManagerTest : public testing::Test {
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_;
-  std::unique_ptr<TaskQueueManager> manager_;
+  std::unique_ptr<TaskQueueManagerForTest> manager_;
   std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_;
   TestTaskTimeObserver test_task_time_observer_;
 };
@@ -204,7 +223,7 @@ TEST_F(TaskQueueManagerTest,
   TestCountUsesTimeSource* test_count_uses_time_source =
       new TestCountUsesTimeSource();
 
-  manager_ = base::MakeUnique<TaskQueueManager>(
+  manager_ = base::MakeUnique<TaskQueueManagerForTest>(
       MessageLoopTaskRunner::Create(
           base::WrapUnique(test_count_uses_time_source)),
       "test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -237,7 +256,7 @@ TEST_F(TaskQueueManagerTest, NowNotCalledForNestedTasks) {
   TestCountUsesTimeSource* test_count_uses_time_source =
       new TestCountUsesTimeSource();
 
-  manager_ = base::MakeUnique<TaskQueueManager>(
+  manager_ = base::MakeUnique<TaskQueueManagerForTest>(
       MessageLoopTaskRunner::Create(
           base::WrapUnique(test_count_uses_time_source)),
       "test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -382,16 +401,11 @@ TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTask) {
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // Move the task into the |delayed_work_queue|.
-  EXPECT_TRUE(runners_[0]->delayed_work_queue()->Empty());
-  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
-      runners_[0]->CreateQueueEnabledVoter();
-  voter->SetQueueEnabled(false);
-  test_task_runner_->RunUntilIdle();
+  WakeupReadyDelayedQueues(LazyNow(now_src_.get()));
   EXPECT_FALSE(runners_[0]->delayed_work_queue()->Empty());
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // Run the task, making the queue empty.
-  voter->SetQueueEnabled(true);
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
 }
@@ -1676,6 +1690,137 @@ TEST_F(TaskQueueManagerTest,
 }
 
 namespace {
+class MockTimeDomainObserver : public TimeDomain::Observer {
+ public:
+  ~MockTimeDomainObserver() override {}
+
+  MOCK_METHOD1(OnTimeDomainHasImmediateWork, void(TaskQueue*));
+  MOCK_METHOD1(OnTimeDomainHasDelayedWork, void(TaskQueue*));
+};
+}  // namespace
+
+TEST_F(TaskQueueManagerTest, TimeDomainObserver_ImmediateTask) {
+  Initialize(1u);
+
+  MockTimeDomainObserver observer;
+  std::unique_ptr<VirtualTimeDomain> domain(
+      new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+  manager_->RegisterTimeDomain(domain.get());
+  runners_[0]->SetTimeDomain(domain.get());
+
+  // We should get a notification when a task is posted on an empty queue.
+  EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(runners_[0].get()));
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // But not subsequently.
+  EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(_)).Times(0);
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // Unless the immediate work queue is emptied.
+  runners_[0]->ReloadImmediateWorkQueueIfEmpty();
+  EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(runners_[0].get()));
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+
+  // Tidy up.
+  runners_[0]->UnregisterTaskQueue();
+  manager_->UnregisterTimeDomain(domain.get());
+}
+
+TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTask) {
+  Initialize(1u);
+
+  MockTimeDomainObserver observer;
+  std::unique_ptr<VirtualTimeDomain> domain(
+      new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+  manager_->RegisterTimeDomain(domain.get());
+  runners_[0]->SetTimeDomain(domain.get());
+
+  // We should get a notification when a delayed task is posted on an empty
+  // queue.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromSeconds(10));
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // We should not get a notification for a longer delay.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromSeconds(100));
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // We should get a notification for a shorter delay.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromSeconds(1));
+  Mock::VerifyAndClearExpectations(&observer);
+
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+      runners_[0]->CreateQueueEnabledVoter();
+  voter->SetQueueEnabled(false);
+
+  // When a queue has been enabled, we may get a notification if the
+  // TimeDomain's next scheduled wakeup has changed.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  voter->SetQueueEnabled(true);
+
+  // Tidy up.
+  runners_[0]->UnregisterTaskQueue();
+  manager_->UnregisterTimeDomain(domain.get());
+}
+
+TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTaskMultpleQueues) {

[Sami, 2017/02/10 12:49:43]

typo: multiple

[alex clarke (OOO till 29th), 2017/02/10 14:19:29]

Done.

+  Initialize(2u);
+
+  MockTimeDomainObserver observer;
+  std::unique_ptr<VirtualTimeDomain> domain(
+      new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+  manager_->RegisterTimeDomain(domain.get());
+  runners_[0]->SetTimeDomain(domain.get());
+  runners_[1]->SetTimeDomain(domain.get());
+
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get())).Times(1);
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[1].get())).Times(1);
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromSeconds(1));
+  runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromSeconds(10));
+  testing::Mock::VerifyAndClearExpectations(&observer);
+
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
+      runners_[0]->CreateQueueEnabledVoter();
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
+      runners_[1]->CreateQueueEnabledVoter();
+
+  // Disabling a queue should not trigger a notification.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  voter0->SetQueueEnabled(false);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // Re-enabling it should should also trigger a notification.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+  voter0->SetQueueEnabled(true);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // Disabling a queue should not trigger a notification.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+  voter1->SetQueueEnabled(false);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // Re-enabling it should should trigger a notification.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[1].get()));
+  voter1->SetQueueEnabled(true);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // Tidy up.
+  EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(AnyNumber());
+  runners_[0]->UnregisterTaskQueue();
+  runners_[1]->UnregisterTaskQueue();
+  manager_->UnregisterTimeDomain(domain.get());
+}
+
+namespace {
 void ChromiumRunloopInspectionTask(
     scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner) {
   EXPECT_EQ(1u, test_task_runner->NumPendingTasks());
@@ -2321,10 +2466,6 @@ TEST_F(TaskQueueManagerTest, SweepCanceledDelayedTasks) {
 TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask) {
   Initialize(2u);
 
-  std::unique_ptr<RealTimeDomain> domain2(new RealTimeDomain("test"));
-  manager_->RegisterTimeDomain(domain2.get());
-  runners_[1]->SetTimeDomain(domain2.get());
-
   LazyNow lazy_now(now_src_.get());
   EXPECT_FALSE(static_cast<bool>(ComputeDelayTillNextTask(&lazy_now)));
 
@@ -2332,27 +2473,23 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask) {
                                base::TimeDelta::FromSeconds(10));
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(10),
-            ComputeDelayTillNextTask(&lazy_now).value());
+            ComputeDelayTillNextTask(&lazy_now)->delay());
 
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromSeconds(15));
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(10),
-            ComputeDelayTillNextTask(&lazy_now).value());
+            ComputeDelayTillNextTask(&lazy_now)->delay());
 
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
                                base::TimeDelta::FromSeconds(5));
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(5),
-            ComputeDelayTillNextTask(&lazy_now).value());
+            ComputeDelayTillNextTask(&lazy_now)->delay());
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
 
-  EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
-
-  // Tidy up.
-  runners_[1]->UnregisterTaskQueue();
-  manager_->UnregisterTimeDomain(domain2.get());
+  EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
 }
 
 TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_Disabled) {
@@ -2385,7 +2522,7 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_FenceUnblocking) {
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
   LazyNow lazy_now(now_src_.get());
-  EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
+  EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
 }
 
 TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
@@ -2397,44 +2534,63 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
   now_src_->Advance(base::TimeDelta::FromSeconds(10));
 
   LazyNow lazy_now(now_src_.get());
-  EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
+  EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
 }
 
 TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_NoMoreWork) {
   Initialize(1u);
 
   LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::Optional<base::TimeDelta>(), &lazy_now);
+  PostDoWorkContinuation(base::Optional<NextTaskDelay>(), &lazy_now);
 
   EXPECT_EQ(0u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(0, immediate_do_work_posted_count());
-  EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+  EXPECT_TRUE(next_delayed_do_work_time().is_null());
 }
 
 TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_ImmediateWork) {
   Initialize(1u);
 
   LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta(), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(), &lazy_now);
 
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
   EXPECT_EQ(1, immediate_do_work_posted_count());
-  EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+  EXPECT_TRUE(next_delayed_do_work_time().is_null());
+}
+
+TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkInThePast) {
+  Initialize(1u);
+
+  LazyNow lazy_now(now_src_.get());
+  // Note this isn't supposed to happen in practice.
+  PostDoWorkContinuation(
+      NextTaskDelay(base::TimeDelta::FromSeconds(-1),
+                    runners_[0]->GetTimeDomain(),
+                    NextTaskDelay::AllowAnyDelayForTesting()),
+      &lazy_now);
+
+  EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
+  EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
+  EXPECT_EQ(1, immediate_do_work_posted_count());
+  EXPECT_TRUE(next_delayed_do_work_time().is_null());
 }
 
 TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWork) {
   Initialize(1u);
 
   LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
+                                       runners_[0]->GetTimeDomain()),
+                         &lazy_now);
 
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(base::TimeDelta::FromSeconds(1),
             test_task_runner_->DelayToNextTaskTime());
   EXPECT_EQ(0, immediate_do_work_posted_count());
   EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(1),
-            next_scheduled_delayed_do_work_time());
+            next_delayed_do_work_time());
 }
 
 TEST_F(TaskQueueManagerTest,
@@ -2447,29 +2603,35 @@ TEST_F(TaskQueueManagerTest,
   EXPECT_EQ(1, immediate_do_work_posted_count());
 
   LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
+                                       runners_[0]->GetTimeDomain()),
+                         &lazy_now);
 
   // Test that a delayed task didn't get posted.
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
   EXPECT_EQ(1, immediate_do_work_posted_count());
-  EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+  EXPECT_TRUE(next_delayed_do_work_time().is_null());
 }
 
 TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkTimeChanges) {
   Initialize(1u);
 
   LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
+                                       runners_[0]->GetTimeDomain()),
+                         &lazy_now);
 
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   EXPECT_EQ(0, immediate_do_work_posted_count());
   EXPECT_EQ(base::TimeDelta::FromSeconds(1),
             test_task_runner_->DelayToNextTaskTime());
   EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(1),
-            next_scheduled_delayed_do_work_time());
+            next_delayed_do_work_time());
 
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(10), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(10),
+                                       runners_[0]->GetTimeDomain()),
+                         &lazy_now);
 
   // This should have resulted in the previous task getting canceled and a new
   // one getting posted.
@@ -2480,7 +2642,7 @@ TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkTimeChanges) {
             test_task_runner_->DelayToNextTaskTime());
   EXPECT_EQ(0, immediate_do_work_posted_count());
   EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(10),
-            next_scheduled_delayed_do_work_time());
+            next_delayed_do_work_time());
 }
 
 TEST_F(TaskQueueManagerTest,
@@ -2488,18 +2650,20 @@ TEST_F(TaskQueueManagerTest,
   Initialize(1u);
 
   LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
+                                       runners_[0]->GetTimeDomain()),
+                         &lazy_now);
 
   now_src_->Advance(base::TimeDelta::FromSeconds(1));
   lazy_now = LazyNow(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta(), &lazy_now);
+  PostDoWorkContinuation(NextTaskDelay(), &lazy_now);
 
   // Because the delayed DoWork was pending we don't expect an immediate DoWork
   // to get posted.
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
   EXPECT_EQ(0, immediate_do_work_posted_count());
-  EXPECT_EQ(lazy_now.Now(), next_scheduled_delayed_do_work_time());
+  EXPECT_EQ(lazy_now.Now(), next_delayed_do_work_time());
 }
 
 namespace {
@@ -2600,5 +2764,98 @@ TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) {
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 }
 
+TEST_F(TaskQueueManagerTest, DelayedDoWorkNotPostedForDisabledQueue) {
+  Initialize(1u);
+
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromMilliseconds(1));
+  ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
+            test_task_runner_->DelayToNextTaskTime());
+
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+      runners_[0]->CreateQueueEnabledVoter();
+  voter->SetQueueEnabled(false);
+
+  EXPECT_TRUE(test_task_runner_->HasPendingTasks());
+  test_task_runner_->RemoveCancelledTasks();
+  EXPECT_FALSE(test_task_runner_->HasPendingTasks());
+
+  voter->SetQueueEnabled(true);
+  ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
+            test_task_runner_->DelayToNextTaskTime());
+}
+
+TEST_F(TaskQueueManagerTest, DisablingQueuesChangesDelayTillNextDoWork) {
+  Initialize(3u);
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromMilliseconds(1));
+  runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromMilliseconds(10));
+  runners_[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+                               base::TimeDelta::FromMilliseconds(100));
+
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
+      runners_[0]->CreateQueueEnabledVoter();
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
+      runners_[1]->CreateQueueEnabledVoter();
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter2 =
+      runners_[2]->CreateQueueEnabledVoter();
+
+  ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
+            test_task_runner_->DelayToNextTaskTime());
+
+  voter0->SetQueueEnabled(false);
+  test_task_runner_->RemoveCancelledTasks();
+  ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(10),
+            test_task_runner_->DelayToNextTaskTime());
+
+  voter1->SetQueueEnabled(false);
+  test_task_runner_->RemoveCancelledTasks();
+  ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(100),
+            test_task_runner_->DelayToNextTaskTime());
+
+  voter2->SetQueueEnabled(false);
+  test_task_runner_->RemoveCancelledTasks();
+  EXPECT_FALSE(test_task_runner_->HasPendingTasks());
+}
+
+TEST_F(TaskQueueManagerTest, GetNextScheduledWakeUp) {
+  Initialize(1u);
+
+  EXPECT_EQ(base::nullopt, runners_[0]->GetNextScheduledWakeUp());
+
+  base::TimeTicks start_time = manager_->delegate()->NowTicks();
+  base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10);
+  base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(2);
+
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1);
+  EXPECT_EQ(start_time + delay1, runners_[0]->GetNextScheduledWakeUp());
+
+  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2);
+  EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+
+  // We don't have wakeups scheduled for disabled queues.
+  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+      runners_[0]->CreateQueueEnabledVoter();
+  voter->SetQueueEnabled(false);
+  EXPECT_EQ(base::nullopt, runners_[0]->GetNextScheduledWakeUp());
+
+  voter->SetQueueEnabled(true);
+  EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+
+  // Immediate tasks shouldn't make any difference.
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+  EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+
+  // Neither should fences.
+  runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+  EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+}
+
 }  // namespace scheduler
 }  // namespace blink