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"
 
 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<SchedulerTaskRunnerDelegate> main_task_runner,
+    TimeSource time_source)
     : 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_),
+      time_source_(time_source),
+      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 833 matching lines @@
   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());
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
+double RendererSchedulerImpl::currentTime() const {
+  switch (time_source_) {

[Sami, 2015/10/28 20:00:35]

Do we need to make this distinction here? Why not always call into the helper?

[alex clarke (OOO till 29th), 2015/10/29 18:07:30]

As far as I can tell the distinction is important.  Specially (helper_.Now() -
base::TimeTicks::UnixEpoch()) is an approximation to base::Time::Now().

I think it's OK for currentTime to be less accurate if virtual time is enabled. 
I don't think that's a good idea if it's not.

I think the question of whether it should be done here or elsewhere is a valid
one, but I think there's less plumbing if it's done here.  WDYT?

+    case TimeSource::NORMAL:
+      return base::Time::Now().ToDoubleT();
+
+    case TimeSource::VIRTUAL:
+      return (helper_.Now() - base::TimeTicks::UnixEpoch()).InSecondsF();
+
+    default:
+      break;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+double RendererSchedulerImpl::monotonicallyIncreasingTime() const {
+  return helper_.Now().ToInternalValue() /
+         static_cast<double>(base::Time::kMicrosecondsPerSecond);
+}
+
 }  // namespace scheduler