scheduler: Encapsulate TaskQueueManager inside SchedulerHelper

content/renderer/scheduler/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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 #include "content/child/scheduler/nestable_single_thread_task_runner.h"
 #include "content/child/scheduler/prioritizing_task_queue_selector.h"
 #include "ui/gfx/frame_time.h"
 
 namespace content {
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner)
     : helper_(main_task_runner,
               this,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TASK_QUEUE_COUNT,
               base::TimeDelta()),
       control_task_runner_(helper_.ControlTaskRunner()),
       compositor_task_runner_(
-          helper_.SchedulerTaskQueueManager()->TaskRunnerForQueue(
-              COMPOSITOR_TASK_QUEUE)),
-      loading_task_runner_(
-          helper_.SchedulerTaskQueueManager()->TaskRunnerForQueue(
-              LOADING_TASK_QUEUE)),
-      timer_task_runner_(
-          helper_.SchedulerTaskQueueManager()->TaskRunnerForQueue(
-              TIMER_TASK_QUEUE)),
+          helper_.TaskRunnerForQueue(COMPOSITOR_TASK_QUEUE)),
+      loading_task_runner_(helper_.TaskRunnerForQueue(LOADING_TASK_QUEUE)),
+      timer_task_runner_(helper_.TaskRunnerForQueue(TIMER_TASK_QUEUE)),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       current_policy_(Policy::NORMAL),
       renderer_hidden_(false),
       last_input_type_(blink::WebInputEvent::Undefined),
       input_stream_state_(InputStreamState::INACTIVE),
       policy_may_need_update_(&incoming_signals_lock_),
       timer_queue_suspend_count_(0),
       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()));
 
   for (size_t i = SchedulerHelper::TASK_QUEUE_COUNT;
        i < TASK_QUEUE_COUNT;
        i++) {
-    helper_.SchedulerTaskQueueManager()->SetQueueName(
-        i, TaskQueueIdToString(static_cast<QueueId>(i)));
+    helper_.SetQueueName(i, TaskQueueIdToString(static_cast<QueueId>(i)));
   }
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
@@ skipping 223 matching lines @@
   // We only yield if we are in the compositor priority and there is compositor
   // work outstanding, or if we are in the touchstart response priority.
   // Note: even though the control queue is higher priority we don't yield for
   // it since these tasks are not user-provided work and they are only intended
   // to run before the next task, not interrupt the tasks.
   switch (SchedulerPolicy()) {
     case Policy::NORMAL:
       return false;
 
     case Policy::COMPOSITOR_PRIORITY:
-      return !helper_.SchedulerTaskQueueManager()->IsQueueEmpty(
-          COMPOSITOR_TASK_QUEUE);
+      return !helper_.IsQueueEmpty(COMPOSITOR_TASK_QUEUE);
 
     case Policy::TOUCHSTART_PRIORITY:
       return true;
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
@@ skipping 142 matching lines @@
     base::TimeTicks now) const {
   helper_.CheckOnValidThread();
   // TODO(rmcilroy): Change this to DCHECK_EQ when crbug.com/463869 is fixed.
   DCHECK(input_stream_state_ != InputStreamState::INACTIVE);
   incoming_signals_lock_.AssertAcquired();
 
   base::TimeDelta escalated_priority_duration =
       base::TimeDelta::FromMilliseconds(kPriorityEscalationAfterInputMillis);
   base::TimeDelta time_left_in_policy;
   if (last_input_process_time_on_main_.is_null() &&
-      !helper_.SchedulerTaskQueueManager()->IsQueueEmpty(
-          COMPOSITOR_TASK_QUEUE)) {
+      !helper_.IsQueueEmpty(COMPOSITOR_TASK_QUEUE)) {
     // If the input event is still pending, go into input prioritized policy
     // and check again later.
     time_left_in_policy = escalated_priority_duration;
   } else {
     // Otherwise make sure the input prioritization policy ends on time.
     base::TimeTicks new_priority_end(
         std::max(last_input_receipt_time_on_compositor_,
                  last_input_process_time_on_main_) +
         escalated_priority_duration);
     time_left_in_policy = new_priority_end - now;
@@ skipping 164 matching lines @@
       // meaningful touchstart response and should not impact task priority.
       return current_state;
 
     default:
       break;
   }
   return InputStreamState::ACTIVE;
 }
 
 }  // namespace content