Simplify ThreadController scheduling for delayed work.

Change-Id: I15858d42c4f2f6404225f129878335c19e22bf97
Reviewed-on: https://chromium-review.googlesource.com/1070031
Commit-Queue: Greg Kraynov <kraynov@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#561472}

third_party/blink/renderer/platform/scheduler/base/task_queue_manager_impl.cc

@@ -251,12 +251,15 @@ void TaskQueueManagerImpl::MaybeScheduleDelayedWork(
     TimeDomain* requesting_time_domain,
     TimeTicks now,
     TimeTicks run_time) {
-  controller_->ScheduleDelayedWork(now, run_time);
+  // TODO(kraynov): Convert time domains to use LazyNow.
+  LazyNow lazy_now(now);
+  controller_->SetNextDelayedDoWork(&lazy_now, run_time);
 }
 
+// TODO(kraynov): Remove after simplifying TimeDomain.
 void TaskQueueManagerImpl::CancelDelayedWork(TimeDomain* requesting_time_domain,
                                              TimeTicks run_time) {
-  controller_->CancelDelayedWork(run_time);
+  controller_->SetNextDelayedDoWork(nullptr, TimeTicks::Max());
 }
 
 Optional<PendingTask> TaskQueueManagerImpl::TakeTask() {

third_party/blink/renderer/platform/scheduler/base/thread_controller.h

@@ -10,6 +10,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
+#include "third_party/blink/renderer/platform/scheduler/base/lazy_now.h"
 
 namespace base {
 class TickClock;
@@ -46,21 +47,12 @@ class PLATFORM_EXPORT ThreadController {
   // code is changed to work that way.
   virtual void ScheduleWork() = 0;
 
-  // Notify the controller that its associated sequence will have
-  // delayed work to run at |run_time|. The thread associated with this
-  // controller will run a task returned by sequence->TakeTask() at that time.
-  // This call cancels any previously scheduled delayed work. Will be called
-  // from the main sequence.
-  //
-  // TODO(altimin): Change this to "the thread associated with this
-  // controller will run tasks returned by sequence->TakeTask() until
-  // it returns null or sequence->DidRunTask() returns false" once the
-  // code is changed to work that way.
-  virtual void ScheduleDelayedWork(TimeTicks now, TimeTicks run_time) = 0;
-
-  // Notify thread controller that sequence no longer has delayed work at
-  // |run_time| and previously scheduled callbacks should be cancelled.
-  virtual void CancelDelayedWork(TimeTicks run_time) = 0;
+  // Notify the controller that SequencedTaskSource will have a delayed work
+  // ready to be run at |run_time|. This call cancels any previously
+  // scheduled delayed work. Can only be called from the main sequence.
+  // NOTE: DelayTillNextTask might return a different value as it also takes
+  // immediate work into account.
+  virtual void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) = 0;
 
   // Sets the sequenced task source from which to take tasks after
   // a Schedule*Work() call is made.

third_party/blink/renderer/platform/scheduler/base/thread_controller_impl.cc

@@ -76,16 +76,21 @@ void ThreadControllerImpl::ScheduleWork() {
   task_runner_->PostTask(FROM_HERE, immediate_do_work_closure_);
 }
 
-void ThreadControllerImpl::ScheduleDelayedWork(TimeTicks now,
-                                               TimeTicks run_time) {
+void ThreadControllerImpl::SetNextDelayedDoWork(LazyNow* lazy_now,
+                                                TimeTicks run_time) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(sequence_);
 
-  // If there's a delayed DoWork scheduled to run sooner, we don't need to do
-  // anything because a delayed continuation will be posted as needed.
-  if (main_sequence_only().next_delayed_do_work <= run_time)
+  if (main_sequence_only().next_delayed_do_work == run_time)
     return;
 
+  // Cancel DoWork if it was scheduled and we set an "infinite" delay now.
+  if (run_time == TimeTicks::Max()) {
+    cancelable_delayed_do_work_closure_.Cancel();
+    main_sequence_only().next_delayed_do_work = TimeTicks::Max();
+    return;
+  }
+
   // If DoWork is running then we don't need to do anything because it will post
   // a continuation as needed. Bailing out here is by far the most common case.
   if (main_sequence_only().do_work_running_count >
@@ -100,27 +105,18 @@ void ThreadControllerImpl::ScheduleDelayedWork(TimeTicks now,
       return;
   }
 
-  base::TimeDelta delay = std::max(TimeDelta(), run_time - now);
+  base::TimeDelta delay = std::max(TimeDelta(), run_time - lazy_now->Now());
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("sequence_manager"),
-               "ThreadControllerImpl::ScheduleDelayedWork::PostDelayedTask",
+               "ThreadControllerImpl::SetNextDelayedDoWork::PostDelayedTask",
                "delay_ms", delay.InMillisecondsF());
 
   main_sequence_only().next_delayed_do_work = run_time;
+  // Reset also causes cancellation of the previous DoWork task.
   cancelable_delayed_do_work_closure_.Reset(delayed_do_work_closure_);
   task_runner_->PostDelayedTask(
       FROM_HERE, cancelable_delayed_do_work_closure_.callback(), delay);
 }
 
-void ThreadControllerImpl::CancelDelayedWork(TimeTicks run_time) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK(sequence_);
-  if (main_sequence_only().next_delayed_do_work != run_time)
-    return;
-
-  cancelable_delayed_do_work_closure_.Cancel();
-  main_sequence_only().next_delayed_do_work = TimeTicks::Max();
-}
-
 bool ThreadControllerImpl::RunsTasksInCurrentSequence() {
   return task_runner_->RunsTasksInCurrentSequence();
 }

third_party/blink/renderer/platform/scheduler/base/thread_controller_impl.h

@@ -39,8 +39,7 @@ class PLATFORM_EXPORT ThreadControllerImpl : public ThreadController,
   void SetWorkBatchSize(int work_batch_size) override;
   void DidQueueTask(const PendingTask& pending_task) override;
   void ScheduleWork() override;
-  void ScheduleDelayedWork(TimeTicks now, TimeTicks run_timy) override;
-  void CancelDelayedWork(TimeTicks run_time) override;
+  void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) override;
   void SetSequencedTaskSource(SequencedTaskSource* sequence) override;
   bool RunsTasksInCurrentSequence() override;
   const TickClock* GetClock() override;

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_metrics_helper_unittest.cc

@@ -49,6 +49,7 @@ class MainThreadMetricsHelperTest : public testing::Test {
 
   void SetUp() override {
     histogram_tester_.reset(new base::HistogramTester());
+    clock_.Advance(base::TimeDelta::FromMilliseconds(1));
     mock_task_runner_ =
         base::MakeRefCounted<cc::OrderedSimpleTaskRunner>(&clock_, true);
     scheduler_ = std::make_unique<MainThreadSchedulerImplForTest>(

third_party/blink/renderer/platform/scheduler/test/lazy_thread_controller_for_test.cc

@@ -98,16 +98,11 @@ void LazyThreadControllerForTest::ScheduleWork() {
   ThreadControllerImpl::ScheduleWork();
 }
 
-void LazyThreadControllerForTest::ScheduleDelayedWork(
-    base::TimeTicks now,
+void LazyThreadControllerForTest::SetNextDelayedDoWork(
+    base::sequence_manager::LazyNow* lazy_now,
     base::TimeTicks run_time) {
   EnsureMessageLoop();
-  ThreadControllerImpl::ScheduleDelayedWork(now, run_time);
-}
-
-void LazyThreadControllerForTest::CancelDelayedWork(base::TimeTicks run_time) {
-  EnsureMessageLoop();
-  ThreadControllerImpl::CancelDelayedWork(run_time);
+  ThreadControllerImpl::SetNextDelayedDoWork(lazy_now, run_time);
 }
 
 void LazyThreadControllerForTest::SetDefaultTaskRunner(

third_party/blink/renderer/platform/scheduler/test/lazy_thread_controller_for_test.h

@@ -31,9 +31,8 @@ class LazyThreadControllerForTest
   void RemoveNestingObserver(base::RunLoop::NestingObserver* observer) override;
   bool RunsTasksInCurrentSequence() override;
   void ScheduleWork() override;
-  void ScheduleDelayedWork(base::TimeTicks now,
-                           base::TimeTicks run_time) override;
-  void CancelDelayedWork(base::TimeTicks run_time) override;
+  void SetNextDelayedDoWork(base::sequence_manager::LazyNow* lazy_now,
+                            base::TimeTicks run_time) override;
   void SetDefaultTaskRunner(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   void RestoreDefaultTaskRunner() override;