Inject CanAddURLToHistory into TopSitesImpl

components/scheduler/child/scheduler_helper.cc

 // Copyright 2015 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/child/scheduler_helper.h"
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/child/nestable_single_thread_task_runner.h"
-#include "components/scheduler/child/prioritizing_task_queue_selector.h"
 #include "components/scheduler/child/time_source.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     SchedulerHelperDelegate* scheduler_helper_delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
@@ skipping 308 matching lines @@
 
 base::TimeTicks SchedulerHelper::Now() const {
   return time_source_->Now();
 }
 
 SchedulerHelper::IdlePeriodState SchedulerHelper::SchedulerIdlePeriodState()
     const {
   return idle_period_state_;
 }
 
-PrioritizingTaskQueueSelector* SchedulerHelper::SchedulerTaskQueueSelector()
-    const {
-  return task_queue_selector_.get();
-}
-
 scoped_refptr<base::SingleThreadTaskRunner> SchedulerHelper::TaskRunnerForQueue(
     size_t queue_index) const {
   CheckOnValidThread();
   return task_queue_manager_->TaskRunnerForQueue(queue_index);
 }
 
 void SchedulerHelper::SetQueueName(size_t queue_index, const char* name) {
   CheckOnValidThread();
   task_queue_manager_->SetQueueName(queue_index, name);
 }
 
 bool SchedulerHelper::IsQueueEmpty(size_t queue_index) const {
   CheckOnValidThread();
   return task_queue_manager_->IsQueueEmpty(queue_index);
 }
 
+void SchedulerHelper::SetQueuePriority(
+    size_t queue_index,
+    PrioritizingTaskQueueSelector::QueuePriority priority) {
+  CheckOnValidThread();
+  return task_queue_selector_->SetQueuePriority(queue_index, priority);
+}
+
+void SchedulerHelper::EnableQueue(
+    size_t queue_index,
+    PrioritizingTaskQueueSelector::QueuePriority priority) {
+  CheckOnValidThread();
+  task_queue_selector_->EnableQueue(queue_index, priority);
+}
+
+void SchedulerHelper::DisableQueue(size_t queue_index) {
+  CheckOnValidThread();
+  task_queue_selector_->DisableQueue(queue_index);
+}
+
+bool SchedulerHelper::IsQueueEnabled(size_t queue_index) const {
+  CheckOnValidThread();
+  return task_queue_selector_->IsQueueEnabled(queue_index);
+}
+
 // static
 const char* SchedulerHelper::TaskQueueIdToString(QueueId queue_id) {
   switch (queue_id) {
     case DEFAULT_TASK_QUEUE:
       return "default_tq";
     case IDLE_TASK_QUEUE:
       return "idle_tq";
     case CONTROL_TASK_QUEUE:
       return "control_tq";
     case CONTROL_TASK_AFTER_WAKEUP_QUEUE:
@@ skipping 32 matching lines @@
 }
 
 void SchedulerHelper::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace scheduler