Revert of [Reland] Scheduler refactoring to virtually eliminate redundant DoWorks

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 79e17b6869ca2ffc83ad70616b1f966997a82e88..97ef5e9597650c1e1b6d4b50d9ffe272a17922a7 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
@@ -116,37 +116,8 @@
           manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST)));
   }
 
-  void UpdateWorkQueues(
-      const std::set<internal::TaskQueueImpl*>* queues_to_reload,
-      LazyNow lazy_now) {
-    manager_->UpdateWorkQueues(queues_to_reload, &lazy_now);
-  }
-
-  base::Optional<base::TimeDelta> ComputeDelayTillNextTask(LazyNow* lazy_now) {
-    base::AutoLock lock(manager_->any_thread_lock_);
-    return manager_->ComputeDelayTillNextTaskLocked(lazy_now);
-  }
-
-  void PostDoWorkContinuation(base::Optional<base::TimeDelta> next_delay,
-                              LazyNow* lazy_now) {
-    MoveableAutoLock lock(manager_->any_thread_lock_);
-    return manager_->PostDoWorkContinuationLocked(next_delay, lazy_now,
-                                                  std::move(lock));
-  }
-
-  int immediate_do_work_posted_count() const {
-    base::AutoLock lock(manager_->any_thread_lock_);
-    return manager_->any_thread().immediate_do_work_posted_count;
-  }
-
-  base::TimeTicks next_delayed_do_work() const {
-    return manager_->next_delayed_do_work_;
-  }
-
-  void MaybeScheduleImmediateWorkLocked(
-      const tracked_objects::Location& from_here) {
-    MoveableAutoLock lock(manager_->any_thread_lock_);
-    manager_->MaybeScheduleImmediateWorkLocked(from_here, std::move(lock));
+  void UpdateWorkQueues(LazyNow lazy_now) {
+    manager_->UpdateWorkQueues(lazy_now);
   }
 
   // Runs all immediate tasks until there is no more work to do and advances
@@ -518,34 +489,6 @@
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
-TEST_F(TaskQueueManagerTest, RemovingFenceForDisabledQueueDoesNotPostDoWork) {
-  Initialize(1u);
-
-  std::vector<EnqueueOrder> run_order;
-  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
-      runners_[0]->CreateQueueEnabledVoter();
-  voter->SetQueueEnabled(false);
-  runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
-  runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
-
-  runners_[0]->RemoveFence();
-  EXPECT_FALSE(test_task_runner_->HasPendingTasks());
-}
-
-TEST_F(TaskQueueManagerTest, EnablingFencedQueueDoesNotPostDoWork) {
-  Initialize(1u);
-
-  std::vector<EnqueueOrder> run_order;
-  std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
-      runners_[0]->CreateQueueEnabledVoter();
-  voter->SetQueueEnabled(false);
-  runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
-  runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
-
-  voter->SetQueueEnabled(true);
-  EXPECT_FALSE(test_task_runner_->HasPendingTasks());
-}
-
 TEST_F(TaskQueueManagerTest, DenyRunning_BeforePosting) {
   Initialize(1u);
 
@@ -1094,12 +1037,12 @@
 
   // Move time forwards until just before the delayed task should run.
   now_src_->Advance(base::TimeDelta::FromMilliseconds(10));
-  UpdateWorkQueues(nullptr, LazyNow(now_src_.get()));
+  UpdateWorkQueues(LazyNow(now_src_.get()));
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
 
   // Force the delayed task onto the work queue.
   now_src_->Advance(base::TimeDelta::FromMilliseconds(2));
-  UpdateWorkQueues(nullptr, LazyNow(now_src_.get()));
+  UpdateWorkQueues(LazyNow(now_src_.get()));
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   test_task_runner_->RunUntilIdle();
@@ -2219,199 +2162,5 @@
   voter.reset();
 }
 
-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)));
-
-  runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
-                               base::TimeDelta::FromSeconds(10));
-
-  EXPECT_EQ(base::TimeDelta::FromSeconds(10),
-            ComputeDelayTillNextTask(&lazy_now).value());
-
-  runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
-                               base::TimeDelta::FromSeconds(15));
-
-  EXPECT_EQ(base::TimeDelta::FromSeconds(10),
-            ComputeDelayTillNextTask(&lazy_now).value());
-
-  runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
-                               base::TimeDelta::FromSeconds(5));
-
-  EXPECT_EQ(base::TimeDelta::FromSeconds(5),
-            ComputeDelayTillNextTask(&lazy_now).value());
-
-  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());
-}
-
-TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_NoMoreWork) {
-  Initialize(1u);
-
-  LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::Optional<base::TimeDelta>(), &lazy_now);
-
-  EXPECT_EQ(0u, test_task_runner_->NumPendingTasks());
-  EXPECT_EQ(0, immediate_do_work_posted_count());
-  EXPECT_TRUE(next_delayed_do_work().is_null());
-}
-
-TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_ImmediateWork) {
-  Initialize(1u);
-
-  LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta(), &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().is_null());
-}
-
-TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWork) {
-  Initialize(1u);
-
-  LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &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_delayed_do_work());
-}
-
-TEST_F(TaskQueueManagerTest,
-       PostDoWorkContinuation_DelayedWorkButImmediateDoWorkAlreadyPosted) {
-  Initialize(1u);
-
-  MaybeScheduleImmediateWorkLocked(FROM_HERE);
-  EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
-  EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
-  EXPECT_EQ(1, immediate_do_work_posted_count());
-
-  LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &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_delayed_do_work().is_null());
-}
-
-TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkTimeChanges) {
-  Initialize(1u);
-
-  LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &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_delayed_do_work());
-
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(10), &lazy_now);
-
-  // This should have resulted in the previous task getting canceled and a new
-  // one getting posted.
-  EXPECT_EQ(2u, test_task_runner_->NumPendingTasks());
-  test_task_runner_->RemoveCancelledTasks();
-  EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
-  EXPECT_EQ(base::TimeDelta::FromSeconds(10),
-            test_task_runner_->DelayToNextTaskTime());
-  EXPECT_EQ(0, immediate_do_work_posted_count());
-  EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(10),
-            next_delayed_do_work());
-}
-
-TEST_F(TaskQueueManagerTest,
-       PostDoWorkContinuation_ImmediateWorkButDelayedDoWorkPending) {
-  Initialize(1u);
-
-  LazyNow lazy_now(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
-
-  now_src_->Advance(base::TimeDelta::FromSeconds(1));
-  lazy_now = LazyNow(now_src_.get());
-  PostDoWorkContinuation(base::TimeDelta(), &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_delayed_do_work());
-}
-
-namespace {
-void MessageLoopTaskWithDelayedQuit(
-    base::MessageLoop* message_loop,
-    base::SimpleTestTickClock* now_src,
-    scoped_refptr<internal::TaskQueueImpl> task_queue) {
-  base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
-  base::RunLoop run_loop;
-  task_queue->PostDelayedTask(FROM_HERE, run_loop.QuitClosure(),
-                              base::TimeDelta::FromMilliseconds(100));
-  now_src->Advance(base::TimeDelta::FromMilliseconds(200));
-  run_loop.Run();
-}
-}  // namespace
-
-TEST_F(TaskQueueManagerTest, DelayedTaskRunsInNestedMessageLoop) {
-  InitializeWithRealMessageLoop(1u);
-  base::RunLoop run_loop;
-  runners_[0]->PostTask(
-      FROM_HERE,
-      base::Bind(&MessageLoopTaskWithDelayedQuit, message_loop_.get(),
-                 now_src_.get(), base::RetainedRef(runners_[0])));
-  run_loop.RunUntilIdle();
-}
-
-namespace {
-void MessageLoopTaskWithImmediateQuit(
-    base::MessageLoop* message_loop,
-    base::Closure non_nested_quit_closure,
-    scoped_refptr<internal::TaskQueueImpl> task_queue) {
-  base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
-
-  base::RunLoop run_loop;
-  // Needed because entering the nested message loop causes a DoWork to get
-  // posted.
-  task_queue->PostTask(FROM_HERE, base::Bind(&NopTask));
-  task_queue->PostTask(FROM_HERE, run_loop.QuitClosure());
-  run_loop.Run();
-  non_nested_quit_closure.Run();
-}
-}  // namespace
-
-TEST_F(TaskQueueManagerTest,
-       DelayedNestedMessageLoopDoesntPreventTasksRunning) {
-  InitializeWithRealMessageLoop(1u);
-  base::RunLoop run_loop;
-  runners_[0]->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&MessageLoopTaskWithImmediateQuit, message_loop_.get(),
-                 run_loop.QuitClosure(), base::RetainedRef(runners_[0])),
-      base::TimeDelta::FromMilliseconds(100));
-
-  now_src_->Advance(base::TimeDelta::FromMilliseconds(200));
-  run_loop.Run();
-}
-
 }  // namespace scheduler
 }  // namespace blink