[scheduler] Remove blink::scheduler::TaskQueue from public API.

third_party/WebKit/Source/platform/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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 83 matching lines @@
       idle_helper_(&helper_,
                    this,
                    "renderer.scheduler",
                    TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                    "RendererSchedulerIdlePeriod",
                    base::TimeDelta()),
       idle_canceled_delayed_task_sweeper_("renderer.scheduler",
                                           &helper_,
                                           idle_helper_.IdleTaskRunner()),
       render_widget_scheduler_signals_(this),
-      control_task_runner_(helper_.ControlTaskRunner()),
+      control_task_runner_(helper_.ControlTaskQueue()),
       compositor_task_runner_(
           helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
       compositor_task_runner_enabled_voter_(
           compositor_task_runner_->CreateQueueEnabledVoter()),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
-          helper_.ControlTaskRunner()),
+          helper_.ControlTaskQueue()),
       seqlock_queueing_time_estimator_(
           QueueingTimeEstimator(this, base::TimeDelta::FromSeconds(1))),
       main_thread_only_(this,
                         compositor_task_runner_,
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   task_queue_throttler_.reset(
       new TaskQueueThrottler(this, "renderer.scheduler"));
   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()));
 
   default_loading_task_runner_ =
-      NewLoadingTaskRunner(TaskQueue::QueueType::DEFAULT_LOADING);
+      NewLoadingTaskQueue(TaskQueue::QueueType::DEFAULT_LOADING);
   default_timer_task_runner_ =
-      NewTimerTaskRunner(TaskQueue::QueueType::DEFAULT_TIMER);
+      NewTimerTaskQueue(TaskQueue::QueueType::DEFAULT_TIMER);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   helper_.SetObserver(this);
   helper_.AddTaskTimeObserver(this);
 
   // Register a tracing state observer unless we're running in a test without a
   // task runner. Note that it's safe to remove a non-existent observer.
@@ skipping 110 matching lines @@
   helper_.Shutdown();
   idle_helper_.Shutdown();
   GetMainThreadOnly().was_shutdown = true;
   GetMainThreadOnly().rail_mode_observer = nullptr;
 }
 
 std::unique_ptr<blink::WebThread> RendererSchedulerImpl::CreateMainThread() {
   return base::MakeUnique<WebThreadImplForRendererScheduler>(this);
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskRunner() {
-  return helper_.DefaultTaskRunner();
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::DefaultTaskRunner() {
+  return helper_.DefaultTaskQueue();
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::CompositorTaskRunner() {
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::CompositorTaskRunner() {
   helper_.CheckOnValidThread();
   return compositor_task_runner_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
 RendererSchedulerImpl::IdleTaskRunner() {
   return idle_helper_.IdleTaskRunner();
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::LoadingTaskRunner() {
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::LoadingTaskRunner() {
   helper_.CheckOnValidThread();
   return default_loading_task_runner_;
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskRunner() {
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::TimerTaskRunner() {
   helper_.CheckOnValidThread();
   return default_timer_task_runner_;
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskRunner() {
-  helper_.CheckOnValidThread();
-  return helper_.ControlTaskRunner();
+scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskQueue() {
+  return helper_.DefaultTaskQueue();
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskRunner(
+scoped_refptr<TaskQueue> RendererSchedulerImpl::CompositorTaskQueue() {
+  helper_.CheckOnValidThread();
+  return compositor_task_runner_;
+}
+
+scoped_refptr<TaskQueue> RendererSchedulerImpl::LoadingTaskQueue() {
+  helper_.CheckOnValidThread();
+  return default_loading_task_runner_;
+}
+
+scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskQueue() {
+  helper_.CheckOnValidThread();
+  return default_timer_task_runner_;
+}
+
+scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskQueue() {
+  helper_.CheckOnValidThread();
+  return helper_.ControlTaskQueue();
+}
+
+scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> loading_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(queue_type)
           .SetShouldMonitorQuiescence(true)
           .SetTimeDomain(GetMainThreadOnly().use_virtual_time
                              ? GetVirtualTimeDomain()
                              : nullptr)));
   auto insert_result = loading_task_runners_.insert(std::make_pair(
       loading_task_queue, loading_task_queue->CreateQueueEnabledVoter()));
   insert_result.first->second->SetQueueEnabled(
       GetMainThreadOnly().current_policy.loading_queue_policy.is_enabled);
   loading_task_queue->SetQueuePriority(
       GetMainThreadOnly().current_policy.loading_queue_policy.priority);
   if (GetMainThreadOnly()
           .current_policy.loading_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(loading_task_queue.get());
   }
   loading_task_queue->AddTaskObserver(
       &GetMainThreadOnly().loading_task_cost_estimator);
   return loading_task_queue;
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskRunner(
+scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   // TODO(alexclarke): Consider using ApplyTaskQueuePolicy() for brevity.
   scoped_refptr<TaskQueue> timer_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(queue_type)
           .SetShouldMonitorQuiescence(true)
           .SetShouldReportWhenExecutionBlocked(true)
           .SetTimeDomain(GetMainThreadOnly().use_virtual_time
                              ? GetVirtualTimeDomain()
                              : nullptr)));
   auto insert_result = timer_task_runners_.insert(std::make_pair(
       timer_task_queue, timer_task_queue->CreateQueueEnabledVoter()));
   insert_result.first->second->SetQueueEnabled(
       GetMainThreadOnly().current_policy.timer_queue_policy.is_enabled);
   timer_task_queue->SetQueuePriority(
       GetMainThreadOnly().current_policy.timer_queue_policy.priority);
   if (GetMainThreadOnly().current_policy.timer_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(timer_task_queue.get());
   }
   timer_task_queue->AddTaskObserver(
       &GetMainThreadOnly().timer_task_cost_estimator);
   return timer_task_queue;
 }
 
-scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskRunner(
+scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> unthrottled_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(queue_type)
           .SetShouldMonitorQuiescence(true)
           .SetTimeDomain(GetMainThreadOnly().use_virtual_time
                              ? GetVirtualTimeDomain()
                              : nullptr)));
   unthrottled_task_runners_.insert(unthrottled_task_queue);
   return unthrottled_task_queue;
@@ skipping 800 matching lines @@
     ApplyTaskQueuePolicy(pair.first.get(), pair.second.get(),
                          GetMainThreadOnly().current_policy.timer_queue_policy,
                          new_policy.timer_queue_policy);
   }
   GetMainThreadOnly().have_reported_blocking_intervention_in_current_policy =
       false;
 
   // 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.
-  ApplyTaskQueuePolicy(helper_.DefaultTaskRunner().get(), nullptr,
+  ApplyTaskQueuePolicy(helper_.DefaultTaskQueue().get(), nullptr,
                        GetMainThreadOnly().current_policy.default_queue_policy,
                        new_policy.default_queue_policy);
   if (GetMainThreadOnly().rail_mode_observer &&
       new_policy.rail_mode != GetMainThreadOnly().current_policy.rail_mode) {
     GetMainThreadOnly().rail_mode_observer->OnRAILModeChanged(
         new_policy.rail_mode);
   }
 
   if (new_policy.should_disable_throttling !=
       GetMainThreadOnly().current_policy.should_disable_throttling) {
@@ skipping 449 matching lines @@
 
 void RendererSchedulerImpl::SetTopLevelBlameContext(
     base::trace_event::BlameContext* blame_context) {
   // Any task that runs in the default task runners belongs to the context of
   // all frames (as opposed to a particular frame). Note that the task itself
   // may still enter a more specific blame context if necessary.
   //
   // Per-frame task runners (loading, timers, etc.) are configured with a more
   // specific blame context by WebFrameSchedulerImpl.
   control_task_runner_->SetBlameContext(blame_context);
-  DefaultTaskRunner()->SetBlameContext(blame_context);
+  DefaultTaskQueue()->SetBlameContext(blame_context);
   default_loading_task_runner_->SetBlameContext(blame_context);
   default_timer_task_runner_->SetBlameContext(blame_context);
   compositor_task_runner_->SetBlameContext(blame_context);
   idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context);
 }
 
 void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) {
   GetMainThreadOnly().rail_mode_observer = observer;
 }
 
@@ skipping 281 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink