Make blink platform time consistent with the timer virtual time

components/scheduler/child/idle_helper.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/scheduler/child/idle_helper.h"
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/base/task_queue.h"
 #include "components/scheduler/base/task_queue_manager.h"
+#include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/child/scheduler_helper.h"
 
 namespace scheduler {
 
 IdleHelper::IdleHelper(
     SchedulerHelper* helper,
     Delegate* delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
@@ skipping 110 matching lines @@
   EndIdlePeriod();
 
   if (ShouldWaitForQuiescence()) {
     helper_->ControlTaskRunner()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.callback(),
         required_quiescence_duration_before_long_idle_period_);
     delegate_->IsNotQuiescent();
     return;
   }
 
-  base::TimeTicks now(helper_->tick_clock()->NowTicks());
+  base::TimeTicks now(helper_->task_queue_manager_delegate()->NowTicks());
   base::TimeDelta next_long_idle_period_delay;
   IdlePeriodState new_idle_period_state =
       ComputeNewLongIdlePeriodState(now, &next_long_idle_period_delay);
   if (IsInIdlePeriod(new_idle_period_state)) {
     StartIdlePeriod(new_idle_period_state, now,
                     now + next_long_idle_period_delay);
   } else {
     // Otherwise wait for the next long idle period delay before trying again.
     helper_->ControlTaskRunner()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.callback(),
@@ skipping 43 matching lines @@
 
 void IdleHelper::WillProcessTask(const base::PendingTask& pending_task) {
 }
 
 void IdleHelper::DidProcessTask(const base::PendingTask& pending_task) {
   helper_->CheckOnValidThread();
   TRACE_EVENT0(disabled_by_default_tracing_category_, "DidProcessTask");
   if (IsInIdlePeriod(state_.idle_period_state()) &&
       state_.idle_period_state() !=
           IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED &&
-      helper_->tick_clock()->NowTicks() >= state_.idle_period_deadline()) {
+      helper_->task_queue_manager_delegate()->NowTicks() >=
+          state_.idle_period_deadline()) {
     // If the idle period deadline has now been reached, either end the idle
     // period or trigger a new long-idle period.
     if (IsInLongIdlePeriod(state_.idle_period_state())) {
       EnableLongIdlePeriod();
     } else {
       DCHECK(IdlePeriodState::IN_SHORT_IDLE_PERIOD ==
              state_.idle_period_state());
       EndIdlePeriod();
     }
   }
@@ skipping 15 matching lines @@
     base::TimeDelta next_long_idle_period_delay;
     if (state_.idle_period_state() ==
         IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE) {
       // If we are in a max deadline long idle period then start the next
       // idle period immediately.
       next_long_idle_period_delay = base::TimeDelta();
     } else {
       // Otherwise ensure that we kick the scheduler at the right time to
       // initiate the next idle period.
       next_long_idle_period_delay =
-          std::max(base::TimeDelta(), state_.idle_period_deadline() -
-                                          helper_->tick_clock()->NowTicks());
+          std::max(base::TimeDelta(),
+                   state_.idle_period_deadline() -
+                       helper_->task_queue_manager_delegate()->NowTicks());
     }
     if (next_long_idle_period_delay == base::TimeDelta()) {
       EnableLongIdlePeriod();
     } else {
       helper_->ControlTaskRunner()->PostDelayedTask(
           FROM_HERE, enable_next_long_idle_period_closure_.callback(),
           next_long_idle_period_delay);
     }
   }
 }
@@ skipping 99 matching lines @@
   helper_->CheckOnValidThread();
   if (new_state == idle_period_state_) {
     DCHECK_EQ(new_deadline, idle_period_deadline_);
     return;
   }
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
     base::TimeTicks now(optional_now.is_null()
-                            ? helper_->tick_clock()->NowTicks()
+                            ? helper_->task_queue_manager_delegate()->NowTicks()
                             : optional_now);
     base::TraceTicks trace_now = base::TraceTicks::Now();
     idle_period_deadline_for_tracing_ = trace_now + (new_deadline - now);
     TraceEventIdlePeriodStateChange(
         new_state, running_idle_task_for_tracing_,
         idle_period_deadline_for_tracing_, trace_now);
   }
 
   idle_period_state_ = new_state;
   idle_period_deadline_ = new_deadline;
@@ skipping 102 matching lines @@
       return "in_long_idle_period_with_max_deadline";
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler