Adds a flag to support "Virtual Time" to the blink scheduler

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"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_selector.h"
-#include "components/scheduler/child/scheduler_task_runner_delegate.h"
+#include "components/scheduler/child/scheduler_tqm_delegate.h"
 
 namespace scheduler {
 namespace {
 // The run time of loading tasks is strongly bimodal.  The vast majority are
 // very cheap, but there are usually a handful of very expensive tasks (e.g ~1
 // second on a mobile device) so we take a very pesimistic view when estimating
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
 const double kLoadingTaskEstimationPercentile = 98;
 const int kTimerTaskEstimationSampleCount = 200;
 const double kTimerTaskEstimationPercentile = 90;
 const int kShortIdlePeriodDurationSampleCount = 10;
 const double kShortIdlePeriodDurationPercentile = 50;
 }
 
 RendererSchedulerImpl::RendererSchedulerImpl(
-    scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner)
+    scoped_refptr<SchedulerTqmDelegate> main_task_runner)
     : helper_(main_task_runner,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler.debug")),
       idle_helper_(&helper_,
                    this,
                    "renderer.scheduler",
                    TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                    "RendererSchedulerIdlePeriod",
                    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_),
+      main_thread_only_(compositor_task_runner_, helper_.tick_clock()),
       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 28 matching lines @@
   DCHECK(MainThreadOnly().was_shutdown);
 }
 
 RendererSchedulerImpl::Policy::Policy()
     : compositor_queue_priority(TaskQueue::NORMAL_PRIORITY),
       loading_queue_priority(TaskQueue::NORMAL_PRIORITY),
       timer_queue_priority(TaskQueue::NORMAL_PRIORITY),
       default_queue_priority(TaskQueue::NORMAL_PRIORITY) {}
 
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
-    const scoped_refptr<TaskQueue>& compositor_task_runner)
-    : loading_task_cost_estimator(kLoadingTaskEstimationSampleCount,
+    const scoped_refptr<TaskQueue>& compositor_task_runner,
+    base::TickClock* time_source)
+    : loading_task_cost_estimator(time_source,
+                                  kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
-      timer_task_cost_estimator(kTimerTaskEstimationSampleCount,
+      timer_task_cost_estimator(time_source,
+                                kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
       idle_time_estimator(compositor_task_runner,
+                          time_source,
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       renderer_hidden(false),
       renderer_backgrounded(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
@@ skipping 122 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_.Now());
+  base::TimeTicks now(helper_.tick_clock()->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_.Now()));
+      this, AsValue(helper_.tick_clock()->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 79 matching lines @@
                "RendererSchedulerImpl::DidAnimateForInputOnCompositorThread");
   UpdateForInputEventOnCompositorThread(
       blink::WebInputEvent::Undefined,
       InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
 }
 
 void RendererSchedulerImpl::UpdateForInputEventOnCompositorThread(
     blink::WebInputEvent::Type type,
     InputEventState input_event_state) {
   base::AutoLock lock(any_thread_lock_);
-  base::TimeTicks now = helper_.Now();
+  base::TimeTicks now = helper_.tick_clock()->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 47 matching lines @@
   CompositorThreadOnly().last_input_type = type;
 }
 
 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_.Now());
+    AnyThread().user_model.DidFinishProcessingInputEvent(
+        helper_.tick_clock()->NowTicks());
   }
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return false;
 
   MaybeUpdatePolicy();
   // The touchstart and main-thread gesture use cases indicate a strong
@@ 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_.Now();
+  base::TimeTicks now = helper_.tick_clock()->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 238 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_.Now();
+    optional_now = helper_.tick_clock()->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 51 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_.Now();
+  AnyThread().last_idle_period_end_time = helper_.tick_clock()->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_.Now() + base::TimeDelta::FromMilliseconds(
-                          kRailsInitialLoadingPrioritizationMillis);
+      helper_.tick_clock()->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);
 }
 
 void RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded() {
@@ skipping 13 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_.Now());
+  AnyThread().user_model.Reset(helper_.tick_clock()->NowTicks());
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 }  // namespace scheduler