scheduler: Encapsulate task queue selector inside the scheduler helper

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/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 344 matching lines @@
     delayed_update_policy_runner_.SetDeadline(FROM_HERE, new_policy_duration,
                                               now);
   } else {
     current_policy_expiration_time_ = base::TimeTicks();
   }
 
   if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
       new_policy == current_policy_)
     return;
 
-  PrioritizingTaskQueueSelector* task_queue_selector =
-      helper_.SchedulerTaskQueueSelector();
   bool policy_disables_timers = false;
 
   switch (new_policy) {
     case Policy::COMPOSITOR_PRIORITY:
-      task_queue_selector->SetQueuePriority(
-          COMPOSITOR_TASK_QUEUE, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
+      helper_.SetQueuePriority(COMPOSITOR_TASK_QUEUE,
+                               PrioritizingTaskQueueSelector::HIGH_PRIORITY);
       // TODO(scheduler-dev): Add a task priority between HIGH and BEST_EFFORT
       // that still has some guarantee of running.
-      task_queue_selector->SetQueuePriority(
+      helper_.SetQueuePriority(
           LOADING_TASK_QUEUE,
           PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
       break;
     case Policy::TOUCHSTART_PRIORITY:
-      task_queue_selector->SetQueuePriority(
-          COMPOSITOR_TASK_QUEUE, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
-      task_queue_selector->DisableQueue(LOADING_TASK_QUEUE);
+      helper_.SetQueuePriority(COMPOSITOR_TASK_QUEUE,
+                               PrioritizingTaskQueueSelector::HIGH_PRIORITY);
+      helper_.DisableQueue(LOADING_TASK_QUEUE);
       // TODO(alexclarke): Set policy_disables_timers once the blink TimerBase
       // refactor is safely landed.
       break;
     case Policy::NORMAL:
-      task_queue_selector->SetQueuePriority(
-          COMPOSITOR_TASK_QUEUE,
-          PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
-      task_queue_selector->SetQueuePriority(
-          LOADING_TASK_QUEUE, PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
+      helper_.SetQueuePriority(COMPOSITOR_TASK_QUEUE,
+                               PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
+      helper_.SetQueuePriority(LOADING_TASK_QUEUE,
+                               PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
       break;
   }
   if (timer_queue_suspend_count_ != 0 || policy_disables_timers) {
-    task_queue_selector->DisableQueue(TIMER_TASK_QUEUE);
+    helper_.DisableQueue(TIMER_TASK_QUEUE);
   } else {
-    helper_.SchedulerTaskQueueSelector()->SetQueuePriority(
-        TIMER_TASK_QUEUE, PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
+    helper_.SetQueuePriority(TIMER_TASK_QUEUE,
+                             PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
   }
-  DCHECK(task_queue_selector->IsQueueEnabled(COMPOSITOR_TASK_QUEUE));
+  DCHECK(helper_.IsQueueEnabled(COMPOSITOR_TASK_QUEUE));
   if (new_policy != Policy::TOUCHSTART_PRIORITY)
-    DCHECK(task_queue_selector->IsQueueEnabled(LOADING_TASK_QUEUE));
+    DCHECK(helper_.IsQueueEnabled(LOADING_TASK_QUEUE));
 
   current_policy_ = new_policy;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.policy", current_policy_);
 }
 
@@ skipping 87 matching lines @@
 }
 
 bool RendererSchedulerImpl::PollableNeedsUpdateFlag::IsSet() const {
   return base::subtle::Acquire_Load(&flag_) != 0;
 }
 
 void RendererSchedulerImpl::SuspendTimerQueue() {
   helper_.CheckOnValidThread();
   timer_queue_suspend_count_++;
   ForceUpdatePolicy();
-  DCHECK(
-      !helper_.SchedulerTaskQueueSelector()->IsQueueEnabled(TIMER_TASK_QUEUE));
+  DCHECK(!helper_.IsQueueEnabled(TIMER_TASK_QUEUE));
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   helper_.CheckOnValidThread();
   timer_queue_suspend_count_--;
   DCHECK_GE(timer_queue_suspend_count_, 0);
   ForceUpdatePolicy();
 }
 
 // static
@@ skipping 102 matching lines @@
       // meaningful touchstart response and should not impact task priority.
       return current_state;
 
     default:
       break;
   }
   return InputStreamState::ACTIVE;
 }
 
 }  // namespace scheduler