Implement WebFrameScheduler and WebPageScheduler

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/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 21 matching lines @@
       idle_helper_(&helper_,
                    this,
                    "renderer.scheduler",
                    TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                    "RendererSchedulerIdlePeriod",
                    base::TimeDelta()),
       control_task_runner_(helper_.ControlTaskRunner()),
       compositor_task_runner_(
           helper_.NewTaskQueue(TaskQueue::Spec("compositor_tq")
                                    .SetShouldMonitorQuiescence(true))),
-      loading_task_runner_(
-          helper_.NewTaskQueue(TaskQueue::Spec("loading_tq")
-                                   .SetShouldMonitorQuiescence(true))),
-      timer_task_runner_(
-          helper_.NewTaskQueue(TaskQueue::Spec("timer_tq")
-                                   .SetShouldMonitorQuiescence(true))),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       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()));
 
-  loading_task_runner_->AddTaskObserver(
-      &MainThreadOnly().loading_task_cost_estimator);
-
-  timer_task_runner_->AddTaskObserver(
-      &MainThreadOnly().timer_task_cost_estimator);
+  default_loading_task_runner_ = NewLoadingTaskRunner("loading_tq");
+  default_timer_task_runner_ = NewTimerTaskRunner("timer_tq");
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   // Make sure that we don't initially assume there is no idle time.
   MainThreadOnly().short_idle_period_duration.InsertSample(
       cc::BeginFrameArgs::DefaultInterval());
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
-  timer_task_runner_->RemoveTaskObserver(
-      &MainThreadOnly().timer_task_cost_estimator);
-  loading_task_runner_->RemoveTaskObserver(
-      &MainThreadOnly().loading_task_cost_estimator);
+
+  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
   // we could end up having stale pointers to the Blink heap which has been
   // terminated by this point.
   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),
@@ skipping 46 matching lines @@
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
 RendererSchedulerImpl::IdleTaskRunner() {
   return idle_helper_.IdleTaskRunner();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::LoadingTaskRunner() {
   helper_.CheckOnValidThread();
-  return loading_task_runner_;
+  return default_loading_task_runner_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskRunner() {
   helper_.CheckOnValidThread();
-  return timer_task_runner_;
+  return default_timer_task_runner_;
+}
+
+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);
+  return loading_task_queue;
+}
+
+scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskRunner(
+    const char* name) {
+  helper_.CheckOnValidThread();
+  scoped_refptr<TaskQueue> timer_task_queue(helper_.NewTaskQueue(
+      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true)));
+  timer_task_runners_.insert(timer_task_queue);
+  timer_task_queue->SetQueuePriority(
+      MainThreadOnly().current_policy.timer_queue_priority);
+  timer_task_queue->AddTaskObserver(
+      &MainThreadOnly().timer_task_cost_estimator);
+  return timer_task_queue;
+}
+
+void RendererSchedulerImpl::UnregisterTaskRunner(
+    scoped_refptr<TaskQueue>& task_queue) {
+  loading_task_runners_.erase(task_queue);
+  timer_task_runners_.erase(task_queue);
+  helper_.UnregisterTaskQueue(task_queue);

[Sami, 2015/09/10 12:51:58]

Should we be removing the observers here too?

 }
 
 bool RendererSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
   return idle_helper_.CanExceedIdleDeadlineIfRequired();
 }
 
 void RendererSchedulerImpl::AddTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   helper_.AddTaskObserver(task_observer);
 }
@@ skipping 448 matching lines @@
                  "RendererScheduler.timer_tasks_seem_expensive",
                  MainThreadOnly().timer_tasks_seem_expensive);
 
   if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
       new_policy == MainThreadOnly().current_policy) {
     return;
   }
 
   compositor_task_runner_->SetQueuePriority(
       new_policy.compositor_queue_priority);
-  loading_task_runner_->SetQueuePriority(new_policy.loading_queue_priority);
-  timer_task_runner_->SetQueuePriority(new_policy.timer_queue_priority);
+  for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
+    loading_queue->SetQueuePriority(new_policy.loading_queue_priority);
+  }
+  for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
+    timer_queue->SetQueuePriority(new_policy.timer_queue_priority);
+  }
 
   // TODO(alexclarke): We shouldn't have to prioritize the default queue, but it
   // appears to be necessary since the order of loading tasks and IPCs (which
   // are mostly dispatched on the default queue) need to be preserved.
   helper_.DefaultTaskRunner()->SetQueuePriority(
       new_policy.default_queue_priority);
 
   DCHECK(compositor_task_runner_->IsQueueEnabled());
   MainThreadOnly().current_policy = new_policy;
 }
@@ skipping 60 matching lines @@
   return true;
 }
 
 SchedulerHelper* RendererSchedulerImpl::GetSchedulerHelperForTesting() {
   return &helper_;
 }
 
 void RendererSchedulerImpl::SuspendTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
-  DCHECK(!timer_task_runner_->IsQueueEnabled());
+  DCHECK(!default_timer_task_runner_->IsQueueEnabled());
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count--;
   DCHECK_GE(MainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::SetTimerQueueSuspensionWhenBackgroundedEnabled(
     bool enabled) {
@@ skipping 124 matching lines @@
   MainThreadOnly().short_idle_period_duration.Clear();
   // Make sure that we don't initially assume there is no idle time.
   MainThreadOnly().short_idle_period_duration.InsertSample(
       cc::BeginFrameArgs::DefaultInterval());
   AnyThread().user_model.Reset();
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 }  // namespace scheduler