Make TimeDomain::NextScheduledRunTime protected.

It shouldn't be used as an API method, use DelayTillNextTask
method instead. The are intercahngable for RealTimeDomain but
NextScheduledRunTime disreards any additional logic which
might be defined in a DelayTillNextTask override.
So this change also makes it more semantically correct.

Bug: 857101
Change-Id: Ie6170312d7840a2acfe32e592fb2d799e4eaf0a7
Reviewed-on: https://chromium-review.googlesource.com/1118224Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Greg Kraynov <kraynov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#571133}

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

@@ -113,10 +113,11 @@ class TaskQueueManagerTest : public TaskQueueManagerTestBase {
     for (;;) {
       // Advance time if we've run out of immediate work to do.
       if (!manager_->HasImmediateWork()) {
-        TimeTicks run_time;
-        if (manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time)) {
-          test_task_runner_->AdvanceMockTickClock(run_time -
-                                                  GetTickClock()->NowTicks());
+        LazyNow lazy_now(GetTickClock());
+        Optional<TimeDelta> delay =
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now);
+        if (delay) {
+          test_task_runner_->AdvanceMockTickClock(*delay);
           per_run_time_callback.Run();
         } else {
           break;
@@ -1194,43 +1195,44 @@ TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) {
 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime) {
   CreateTaskQueues(2u);
   test_task_runner_->AdvanceMockTickClock(TimeDelta::FromMicroseconds(10000));
+  LazyNow lazy_now_1(GetTickClock());
 
   // With no delayed tasks.
-  TimeTicks run_time;
-  EXPECT_FALSE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
+  EXPECT_FALSE(manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
 
   // With a non-delayed task.
   runners_[0]->PostTask(FROM_HERE, BindOnce(&NopTask));
-  EXPECT_FALSE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
+  EXPECT_FALSE(manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
 
   // With a delayed task.
   TimeDelta expected_delay = TimeDelta::FromMilliseconds(50);
   runners_[0]->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), expected_delay);
-  EXPECT_TRUE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
-  EXPECT_EQ(GetTickClock()->NowTicks() + expected_delay, run_time);
+  EXPECT_EQ(expected_delay,
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
 
   // With another delayed task in the same queue with a longer delay.
   runners_[0]->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
                                TimeDelta::FromMilliseconds(100));
-  EXPECT_TRUE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
-  EXPECT_EQ(GetTickClock()->NowTicks() + expected_delay, run_time);
+  EXPECT_EQ(expected_delay,
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
 
   // With another delayed task in the same queue with a shorter delay.
   expected_delay = TimeDelta::FromMilliseconds(20);
   runners_[0]->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), expected_delay);
-  EXPECT_TRUE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
-  EXPECT_EQ(GetTickClock()->NowTicks() + expected_delay, run_time);
+  EXPECT_EQ(expected_delay,
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
 
   // With another delayed task in a different queue with a shorter delay.
   expected_delay = TimeDelta::FromMilliseconds(10);
   runners_[1]->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), expected_delay);
-  EXPECT_TRUE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
-  EXPECT_EQ(GetTickClock()->NowTicks() + expected_delay, run_time);
+  EXPECT_EQ(expected_delay,
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
 
   // Test it updates as time progresses
   test_task_runner_->AdvanceMockTickClock(expected_delay);
-  EXPECT_TRUE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
-  EXPECT_EQ(GetTickClock()->NowTicks(), run_time);
+  LazyNow lazy_now_2(GetTickClock());
+  EXPECT_EQ(TimeDelta(),
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_2));
 }
 
 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime_MultipleQueues) {
@@ -1244,9 +1246,9 @@ TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime_MultipleQueues) {
   runners_[2]->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), delay3);
   runners_[0]->PostTask(FROM_HERE, BindOnce(&NopTask));
 
-  TimeTicks run_time;
-  EXPECT_TRUE(manager_->GetRealTimeDomain()->NextScheduledRunTime(&run_time));
-  EXPECT_EQ(GetTickClock()->NowTicks() + delay2, run_time);
+  LazyNow lazy_now(GetTickClock());
+  EXPECT_EQ(delay2,
+            manager_->GetRealTimeDomain()->DelayTillNextTask(&lazy_now));
 }
 
 TEST_F(TaskQueueManagerTest, DeleteTaskQueueManagerInsideATask) {

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

@@ -53,16 +53,16 @@ class PLATFORM_EXPORT TimeDomain {
   // Returns the name of this time domain for tracing.
   virtual const char* GetName() const = 0;
 
-  // If there is a scheduled delayed task, |out_time| is set to the scheduled
-  // runtime for the next one and it returns true.  Returns false otherwise.
-  bool NextScheduledRunTime(TimeTicks* out_time) const;
-
  protected:
   friend class internal::TaskQueueImpl;
   friend class TaskQueueManagerImpl;
 
   void AsValueInto(trace_event::TracedValue* state) const;
 
+  // If there is a scheduled delayed task, |out_time| is set to the scheduled
+  // runtime for the next one and it returns true. Returns false otherwise.
+  bool NextScheduledRunTime(TimeTicks* out_time) const;
+
   // If there is a scheduled delayed task, |out_task_queue| is set to the queue
   // the next task was posted to and it returns true.  Returns false otherwise.
   bool NextScheduledTaskQueue(internal::TaskQueueImpl** out_task_queue) const;

third_party/blink/renderer/platform/scheduler/common/idle_helper.cc

@@ -82,15 +82,18 @@ IdleHelper::IdlePeriodState IdleHelper::ComputeNewLongIdlePeriodState(
     return IdlePeriodState::kNotInIdlePeriod;
   }
 
-  base::TimeTicks next_pending_delayed_task;
+  base::sequence_manager::LazyNow lazy_now(now);
+  base::Optional<base::TimeDelta> delay_till_next_task =
+      helper_->real_time_domain()->DelayTillNextTask(&lazy_now);
+
   base::TimeDelta max_long_idle_period_duration =
       base::TimeDelta::FromMilliseconds(kMaximumIdlePeriodMillis);
   base::TimeDelta long_idle_period_duration;
-  if (helper_->real_time_domain()->NextScheduledRunTime(
-          &next_pending_delayed_task)) {
+
+  if (delay_till_next_task) {
     // Limit the idle period duration to be before the next pending task.
-    long_idle_period_duration = std::min(next_pending_delayed_task - now,
-                                         max_long_idle_period_duration);
+    long_idle_period_duration =
+        std::min(*delay_till_next_task, max_long_idle_period_duration);
   } else {
     long_idle_period_duration = max_long_idle_period_duration;
   }

third_party/blink/renderer/platform/scheduler/common/idle_helper_unittest.cc

@@ -767,9 +767,9 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodPaused) {
   idle_helper_->EnableLongIdlePeriod();
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
   // There shouldn't be any delayed tasks posted by the idle helper when paused.
-  base::TimeTicks next_pending_delayed_task;
-  EXPECT_FALSE(scheduler_helper_->real_time_domain()->NextScheduledRunTime(
-      &next_pending_delayed_task));
+  base::sequence_manager::LazyNow lazy_now_1(&clock_);
+  EXPECT_FALSE(
+      scheduler_helper_->real_time_domain()->DelayTillNextTask(&lazy_now_1));
 
   // Posting a task should transition us to the an active state.
   g_max_idle_task_reposts = 2;
@@ -789,8 +789,9 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodPaused) {
 
   // Once all task have been run we should go back to the paused state.
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
-  EXPECT_FALSE(scheduler_helper_->real_time_domain()->NextScheduledRunTime(
-      &next_pending_delayed_task));
+  base::sequence_manager::LazyNow lazy_now_2(&clock_);
+  EXPECT_FALSE(
+      scheduler_helper_->real_time_domain()->DelayTillNextTask(&lazy_now_2));
 
   idle_helper_->EndIdlePeriod();
   CheckIdlePeriodStateIs("not_in_idle_period");

third_party/blink/renderer/platform/testing/testing_platform_support_with_mock_scheduler.cc

@@ -101,12 +101,16 @@ void TestingPlatformSupportWithMockScheduler::RunForPeriodSeconds(
     // If we've run out of immediate work then fast forward to the next delayed
     // task, but don't pass |deadline|.
     if (!task_queue_manager_->HasImmediateWork()) {
-      base::TimeTicks next_delayed_task;
-      if (!task_queue_manager_->GetRealTimeDomain()->NextScheduledRunTime(
-              &next_delayed_task) ||
-          next_delayed_task > deadline) {
+      base::sequence_manager::LazyNow lazy_now(&clock_);
+      base::Optional<base::TimeDelta> delay =
+          task_queue_manager_->GetRealTimeDomain()->DelayTillNextTask(
+              &lazy_now);
+      if (!delay)
+        break;
+
+      base::TimeTicks next_delayed_task = lazy_now.Now() + *delay;
+      if (next_delayed_task > deadline)
         break;
-      }
 
       clock_.SetNowTicks(next_delayed_task);
     }

third_party/blink/renderer/platform/timer_test.cc

@@ -54,14 +54,16 @@ class TimerTest : public testing::Test {
   // to the delay in seconds till the next pending delayed task is scheduled to
   // fire.
   bool TimeTillNextDelayedTask(double* time) const {
-    base::TimeTicks next_run_time;
-    if (!platform_->GetMainThreadScheduler()
-             ->GetActiveTimeDomain()
-             ->NextScheduledRunTime(&next_run_time))
+    base::sequence_manager::LazyNow lazy_now =
+        platform_->GetMainThreadScheduler()
+            ->real_time_domain()
+            ->CreateLazyNow();
+    base::Optional<base::TimeDelta> delay = platform_->GetMainThreadScheduler()
+                                                ->GetActiveTimeDomain()
+                                                ->DelayTillNextTask(&lazy_now);
+    if (!delay)
       return false;
-    *time = (next_run_time -
-             platform_->GetMainThreadScheduler()->GetActiveTimeDomain()->Now())
-                .InSecondsF();
+    *time = delay->InSecondsF();
     return true;
   }