Make blink platform time consistent with the timer virtual time

components/scheduler/renderer/renderer_scheduler_impl.cc

 // Copyright 2014 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/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 31 matching lines @@
                    base::TimeDelta()),
       render_widget_scheduler_signals_(this),
       control_task_runner_(helper_.ControlTaskRunner()),
       compositor_task_runner_(
           helper_.NewTaskQueue(TaskQueue::Spec("compositor_tq")
                                    .SetShouldMonitorQuiescence(true))),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
-      main_thread_only_(compositor_task_runner_, helper_.tick_clock()),
+      main_thread_only_(compositor_task_runner_,
+                        helper_.scheduler_tqm_delegate().get()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
   suspend_timers_when_backgrounded_closure_.Reset(
       base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
                  weak_factory_.GetWeakPtr()));
@@ skipping 182 matching lines @@
   }
 }
 
 void RendererSchedulerImpl::DidCommitFrameToCompositor() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
-  base::TimeTicks now(helper_.tick_clock()->NowTicks());
+  base::TimeTicks now(helper_.scheduler_tqm_delegate()->NowTicks());
   if (now < MainThreadOnly().estimated_next_frame_begin) {
     // TODO(rmcilroy): Consider reducing the idle period based on the runtime of
     // the next pending delayed tasks (as currently done in for long idle times)
     idle_helper_.StartIdlePeriod(
         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now,
         MainThreadOnly().estimated_next_frame_begin);
   }
 
   MainThreadOnly().idle_time_estimator.DidCommitFrameToCompositor();
 }
@@ skipping 36 matching lines @@
         end_idle_when_hidden_delay);
     MainThreadOnly().renderer_hidden = true;
   } else {
     MainThreadOnly().renderer_hidden = false;
     EndIdlePeriod();
   }
 
   // TODO(alexclarke): Should we update policy here?
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
-      this, AsValue(helper_.tick_clock()->NowTicks()));
+      this, AsValue(helper_.scheduler_tqm_delegate()->NowTicks()));
 }
 
 void RendererSchedulerImpl::SetHasVisibleRenderWidgetWithTouchHandler(
     bool has_visible_render_widget_with_touch_handler) {
   helper_.CheckOnValidThread();
   if (has_visible_render_widget_with_touch_handler ==
       MainThreadOnly().has_visible_render_widget_with_touch_handler)
     return;
 
   MainThreadOnly().has_visible_render_widget_with_touch_handler =
@@ skipping 72 matching lines @@
     return;
 
   UpdateForInputEventOnCompositorThread(web_input_event.type, event_state);
 }
 
 void RendererSchedulerImpl::DidAnimateForInputOnCompositorThread() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidAnimateForInputOnCompositorThread");
   base::AutoLock lock(any_thread_lock_);
   AnyThread().fling_compositor_escalation_deadline =
-      helper_.tick_clock()->NowTicks() +
+      helper_.scheduler_tqm_delegate()->NowTicks() +
       base::TimeDelta::FromMilliseconds(kFlingEscalationLimitMillis);
 }
 
 void RendererSchedulerImpl::UpdateForInputEventOnCompositorThread(
     blink::WebInputEvent::Type type,
     InputEventState input_event_state) {
   base::AutoLock lock(any_thread_lock_);
-  base::TimeTicks now = helper_.tick_clock()->NowTicks();
+  base::TimeTicks now = helper_.scheduler_tqm_delegate()->NowTicks();
 
   // TODO(alexclarke): Move WebInputEventTraits where we can access it from here
   // and record the name rather than the integer representation.
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::UpdateForInputEventOnCompositorThread",
                "type", static_cast<int>(type), "input_event_state",
                InputEventStateToString(input_event_state));
 
   bool gesture_already_in_progress = InputSignalsSuggestGestureInProgress(now);
   bool was_awaiting_touch_start_response =
@@ skipping 61 matching lines @@
 }
 
 void RendererSchedulerImpl::DidHandleInputEventOnMainThread(
     const blink::WebInputEvent& web_input_event) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidHandleInputEventOnMainThread");
   helper_.CheckOnValidThread();
   if (ShouldPrioritizeInputEvent(web_input_event)) {
     base::AutoLock lock(any_thread_lock_);
     AnyThread().user_model.DidFinishProcessingInputEvent(
-        helper_.tick_clock()->NowTicks());
+        helper_.scheduler_tqm_delegate()->NowTicks());
   }
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return false;
 
   MaybeUpdatePolicy();
   // The touchstart, synchronized gesture and main-thread gesture use cases
@@ skipping 70 matching lines @@
   base::AutoLock lock(any_thread_lock_);
   UpdatePolicyLocked(UpdateType::FORCE_UPDATE);
 }
 
 void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   if (helper_.IsShutdown())
     return;
 
-  base::TimeTicks now = helper_.tick_clock()->NowTicks();
+  base::TimeTicks now = helper_.scheduler_tqm_delegate()->NowTicks();
   policy_may_need_update_.SetWhileLocked(false);
 
   base::TimeDelta expected_use_case_duration;
   UseCase use_case = ComputeCurrentUseCase(now, &expected_use_case_duration);
   MainThreadOnly().current_use_case = use_case;
 
   base::TimeDelta touchstart_expected_flag_valid_for_duration;
   bool touchstart_expected_soon = false;
   if (MainThreadOnly().has_visible_render_widget_with_touch_handler) {
     touchstart_expected_soon = AnyThread().user_model.IsGestureExpectedSoon(
@@ skipping 281 matching lines @@
   base::AutoLock lock(any_thread_lock_);
   return AsValueLocked(optional_now);
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
 
   if (optional_now.is_null())
-    optional_now = helper_.tick_clock()->NowTicks();
+    optional_now = helper_.scheduler_tqm_delegate()->NowTicks();
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
 
   state->SetBoolean(
       "has_visible_render_widget_with_touch_handler",
       MainThreadOnly().has_visible_render_widget_with_touch_handler);
   state->SetString("current_use_case",
                    UseCaseToString(MainThreadOnly().current_use_case));
   state->SetBoolean("loading_tasks_seem_expensive",
                     MainThreadOnly().loading_tasks_seem_expensive);
@@ skipping 57 matching lines @@
 }
 
 void RendererSchedulerImpl::OnIdlePeriodStarted() {
   base::AutoLock lock(any_thread_lock_);
   AnyThread().in_idle_period = true;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
   base::AutoLock lock(any_thread_lock_);
-  AnyThread().last_idle_period_end_time = helper_.tick_clock()->NowTicks();
+  AnyThread().last_idle_period_end_time =
+      helper_.scheduler_tqm_delegate()->NowTicks();
   AnyThread().in_idle_period = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::AddPendingNavigation() {
   helper_.CheckOnValidThread();
   MainThreadOnly().navigation_task_expected_count++;
   UpdatePolicy();
 }
 
 void RendererSchedulerImpl::RemovePendingNavigation() {
   helper_.CheckOnValidThread();
   DCHECK_GT(MainThreadOnly().navigation_task_expected_count, 0);
   if (MainThreadOnly().navigation_task_expected_count > 0)
     MainThreadOnly().navigation_task_expected_count--;
   UpdatePolicy();
 }
 
 void RendererSchedulerImpl::OnNavigationStarted() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnNavigationStarted");
   base::AutoLock lock(any_thread_lock_);
   AnyThread().rails_loading_priority_deadline =
-      helper_.tick_clock()->NowTicks() +
+      helper_.scheduler_tqm_delegate()->NowTicks() +
       base::TimeDelta::FromMilliseconds(
           kRailsInitialLoadingPrioritizationMillis);
   ResetForNavigationLocked();
 }
 
 bool RendererSchedulerImpl::HadAnIdlePeriodRecently(base::TimeTicks now) const {
   return (now - AnyThread().last_idle_period_end_time) <=
          base::TimeDelta::FromMilliseconds(
              kIdlePeriodStarvationThresholdMillis);
 }
@@ skipping 15 matching lines @@
   MainThreadOnly().timer_queue_suspended_when_backgrounded = false;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResetForNavigationLocked() {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   MainThreadOnly().loading_task_cost_estimator.Clear();
   MainThreadOnly().timer_task_cost_estimator.Clear();
   MainThreadOnly().idle_time_estimator.Clear();
-  AnyThread().user_model.Reset(helper_.tick_clock()->NowTicks());
+  AnyThread().user_model.Reset(helper_.scheduler_tqm_delegate()->NowTicks());
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
+double RendererSchedulerImpl::CurrentTimeSeconds() const {
+  return helper_.scheduler_tqm_delegate()->CurrentTimeSeconds();
+}
+
+double RendererSchedulerImpl::MonotonicallyIncreasingTimeSeconds() const {
+  return helper_.scheduler_tqm_delegate()->NowTicks().ToInternalValue() /
+         static_cast<double>(base::Time::kMicrosecondsPerSecond);
+}
+
 }  // namespace scheduler