Move throttling of background timers into the renderer 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/base/virtual_time_domain.h"
 #include "components/scheduler/child/scheduler_tqm_delegate.h"
 #include "components/scheduler/renderer/webthread_impl_for_renderer_scheduler.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<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()),
+      throttling_helper_(this, "renderer.scheduler"),
       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_.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()));
 
   default_loading_task_runner_ = NewLoadingTaskRunner("default_loading_tq");
   default_timer_task_runner_ = NewTimerTaskRunner("default_timer_tq");
 
+  virtual_time_domain_ = make_scoped_refptr(
+      new VirtualTimeDomain(helper_.scheduler_tqm_delegate()->NowTicks()));
+  helper_.RegisterTimeDomain(virtual_time_domain_);
+
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   helper_.SetObserver(this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
+  helper_.UnregisterTimeDomain(virtual_time_domain_);
+
   for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
     loading_queue->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
   }
   for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
     timer_queue->RemoveTaskObserver(
         &MainThreadOnly().timer_task_cost_estimator);
   }
 
   // Ensure the renderer scheduler was shut down explicitly, because otherwise
@@ skipping 78 matching lines @@
 RendererSchedulerImpl::LoadingTaskRunner() {
   helper_.CheckOnValidThread();
   return default_loading_task_runner_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskRunner() {
   helper_.CheckOnValidThread();
   return default_timer_task_runner_;
 }
 
+scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskRunner() {
+  helper_.CheckOnValidThread();
+  return helper_.ControlTaskRunner();
+}
+
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskRunner(
     const char* name) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> loading_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(name).SetShouldMonitorQuiescence(true)));
   loading_task_runners_.insert(loading_task_queue);
   loading_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.loading_queue_priority);
   loading_task_queue->AddTaskObserver(
       &MainThreadOnly().loading_task_cost_estimator);
@@ skipping 850 matching lines @@
 
 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);
 }
 
+void RendererSchedulerImpl::RegisterTimeDomain(
+    const scoped_refptr<TimeDomain>& time_domain) {
+  helper_.RegisterTimeDomain(time_domain);
+}
+
+void RendererSchedulerImpl::UnregisterTimeDomain(
+    const scoped_refptr<TimeDomain>& time_domain) {
+  helper_.UnregisterTimeDomain(time_domain);
+}
+
 }  // namespace scheduler