[Try # 3] 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 97ef5e9597650c1e1b6d4b50d9ffe272a17922a7..dd704a6d4f503f8c4f6c7ea81e37468871c83787 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
@@ -117,7 +117,34 @@ class TaskQueueManagerTest : public testing::Test {
   }
 
   void UpdateWorkQueues(LazyNow lazy_now) {
-    manager_->UpdateWorkQueues(lazy_now);
+    manager_->UpdateWorkQueues(&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));
   }
 
   // Runs all immediate tasks until there is no more work to do and advances
@@ -2162,5 +2189,140 @@ TEST_F(TaskQueueManagerTest, UnregisterQueueBeforeDisabledVoterDeleted) {
   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);
+
+  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 scheduler
 }  // namespace blink