Introduce a SchedulerHelper in content/child/scheduler

content/child/scheduler/task_queue_selector_impl.cc

Index: content/child/scheduler/task_queue_selector_impl.cc
diff --git a/content/renderer/scheduler/renderer_task_queue_selector.cc b/content/child/scheduler/task_queue_selector_impl.cc
similarity index 77%
rename from content/renderer/scheduler/renderer_task_queue_selector.cc
rename to content/child/scheduler/task_queue_selector_impl.cc
index 7191942cd13ebb8c1c9a037190250236f646d60a..3894b47ad3394ee9fdb5e5b23f862a9f55ae3b37 100644
--- a/content/renderer/scheduler/renderer_task_queue_selector.cc
+++ b/content/child/scheduler/task_queue_selector_impl.cc
@@ -2,7 +2,7 @@
 // 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_task_queue_selector.h"
+#include "content/child/scheduler/task_queue_selector_impl.h"
 
 #include "base/logging.h"
 #include "base/pending_task.h"
@@ -10,13 +10,13 @@
 
 namespace content {
 
-RendererTaskQueueSelector::RendererTaskQueueSelector() : starvation_count_(0) {
+TaskQueueSelectorImpl::TaskQueueSelectorImpl() : starvation_count_(0) {
 }
 
-RendererTaskQueueSelector::~RendererTaskQueueSelector() {
+TaskQueueSelectorImpl::~TaskQueueSelectorImpl() {
 }
 
-void RendererTaskQueueSelector::RegisterWorkQueues(
+void TaskQueueSelectorImpl::RegisterWorkQueues(
     const std::vector<const base::TaskQueue*>& work_queues) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   work_queues_ = work_queues;
@@ -30,8 +30,8 @@ void RendererTaskQueueSelector::RegisterWorkQueues(
   }
 }
 
-void RendererTaskQueueSelector::SetQueuePriority(size_t queue_index,
-                                                 QueuePriority priority) {
+void TaskQueueSelectorImpl::SetQueuePriority(size_t queue_index,
+                                             QueuePriority priority) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   DCHECK_LT(priority, QUEUE_PRIORITY_COUNT);
@@ -39,12 +39,12 @@ void RendererTaskQueueSelector::SetQueuePriority(size_t queue_index,
   queue_priorities_[priority].insert(queue_index);
 }
 
-void RendererTaskQueueSelector::EnableQueue(size_t queue_index,
-                                            QueuePriority priority) {
+void TaskQueueSelectorImpl::EnableQueue(size_t queue_index,
+                                        QueuePriority priority) {
   SetQueuePriority(queue_index, priority);
 }
 
-void RendererTaskQueueSelector::DisableQueue(size_t queue_index) {
+void TaskQueueSelectorImpl::DisableQueue(size_t queue_index) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   for (auto& queue_priority : queue_priorities_) {
@@ -52,7 +52,7 @@ void RendererTaskQueueSelector::DisableQueue(size_t queue_index) {
   }
 }
 
-bool RendererTaskQueueSelector::IsQueueEnabled(size_t queue_index) const {
+bool TaskQueueSelectorImpl::IsQueueEnabled(size_t queue_index) const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_LT(queue_index, work_queues_.size());
   for (const auto& queue_priority : queue_priorities_) {
@@ -62,21 +62,21 @@ bool RendererTaskQueueSelector::IsQueueEnabled(size_t queue_index) const {
   return false;
 }
 
-bool RendererTaskQueueSelector::IsOlder(const base::TaskQueue* queueA,
-                                        const base::TaskQueue* queueB) {
+bool TaskQueueSelectorImpl::IsOlder(const base::TaskQueue* queueA,
+                                    const base::TaskQueue* queueB) {
   // Note: the comparison is correct due to the fact that the PendingTask
   // operator inverts its comparison operation in order to work well in a heap
   // based priority queue.
   return queueB->front() < queueA->front();
 }
 
-RendererTaskQueueSelector::QueuePriority
-RendererTaskQueueSelector::NextPriority(QueuePriority priority) {
+TaskQueueSelectorImpl::QueuePriority TaskQueueSelectorImpl::NextPriority(
+    QueuePriority priority) {
   DCHECK(priority < QUEUE_PRIORITY_COUNT);
   return static_cast<QueuePriority>(static_cast<int>(priority) + 1);
 }
 
-bool RendererTaskQueueSelector::ChooseOldestWithPriority(
+bool TaskQueueSelectorImpl::ChooseOldestWithPriority(
     QueuePriority priority,
     size_t* out_queue_index) const {
   bool found_non_empty_queue = false;
@@ -98,8 +98,7 @@ bool RendererTaskQueueSelector::ChooseOldestWithPriority(
   return found_non_empty_queue;
 }
 
-bool RendererTaskQueueSelector::SelectWorkQueueToService(
-    size_t* out_queue_index) {
+bool TaskQueueSelectorImpl::SelectWorkQueueToService(size_t* out_queue_index) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(work_queues_.size());
   // Always service the control queue if it has any work.
@@ -124,8 +123,7 @@ bool RendererTaskQueueSelector::SelectWorkQueueToService(
   return false;
 }
 
-void RendererTaskQueueSelector::DidSelectQueueWithPriority(
-    QueuePriority priority) {
+void TaskQueueSelectorImpl::DidSelectQueueWithPriority(QueuePriority priority) {
   switch (priority) {
     case CONTROL_PRIORITY:
       break;
@@ -142,8 +140,7 @@ void RendererTaskQueueSelector::DidSelectQueueWithPriority(
 }
 
 // static
-const char* RendererTaskQueueSelector::PriorityToString(
-    QueuePriority priority) {
+const char* TaskQueueSelectorImpl::PriorityToString(QueuePriority priority) {
   switch (priority) {
     case CONTROL_PRIORITY:
       return "control";
@@ -159,7 +156,7 @@ const char* RendererTaskQueueSelector::PriorityToString(
   }
 }
 
-void RendererTaskQueueSelector::AsValueInto(
+void TaskQueueSelectorImpl::AsValueInto(
     base::trace_event::TracedValue* state) const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   state->BeginDictionary("priorities");