[scheduler] Rename member variables from task_runner_ to task_queue_.

Rename *_task_runner_ member variables to *_task_queue_ to match
variable type.

BUG=710063

Review-Url: https://codereview.chromium.org/2840873002
Cr-Commit-Position: refs/heads/master@{#467320}

third_party/WebKit/Source/platform/scheduler/child/idle_canceled_delayed_task_sweeper_unittest.cc

@@ -52,7 +52,7 @@ class IdleCanceledDelayedTaskSweeperTest : public testing::Test,
             new IdleCanceledDelayedTaskSweeper("test",
                                                scheduler_helper_.get(),
                                                idle_helper_->IdleTaskRunner())),
-        default_task_runner_(scheduler_helper_->DefaultTaskQueue()) {
+        default_task_queue_(scheduler_helper_->DefaultTaskQueue()) {
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
   }
 
@@ -84,7 +84,7 @@ class IdleCanceledDelayedTaskSweeperTest : public testing::Test,
   std::unique_ptr<IdleHelper> idle_helper_;
   std::unique_ptr<IdleCanceledDelayedTaskSweeper>
       idle_canceled_delayed_taks_sweeper_;
-  scoped_refptr<TaskQueue> default_task_runner_;
+  scoped_refptr<TaskQueue> default_task_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(IdleCanceledDelayedTaskSweeperTest);
 };
@@ -94,28 +94,28 @@ TEST_F(IdleCanceledDelayedTaskSweeperTest, TestSweep) {
   TestClass class2;
 
   // Post one task we won't cancel.
-  default_task_runner_->PostDelayedTask(
+  default_task_queue_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TestClass::NopTask, class1.weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(100));
 
   // And a bunch we will.
-  default_task_runner_->PostDelayedTask(
+  default_task_queue_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TestClass::NopTask, class2.weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(101));
 
-  default_task_runner_->PostDelayedTask(
+  default_task_queue_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TestClass::NopTask, class2.weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(102));
 
-  default_task_runner_->PostDelayedTask(
+  default_task_queue_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TestClass::NopTask, class2.weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(103));
 
-  default_task_runner_->PostDelayedTask(
+  default_task_queue_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TestClass::NopTask, class2.weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(104));
@@ -130,7 +130,7 @@ TEST_F(IdleCanceledDelayedTaskSweeperTest, TestSweep) {
   idle_helper_->EnableLongIdlePeriod();
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(40));
 
-  EXPECT_EQ(1u, default_task_runner_->GetNumberOfPendingTasks());
+  EXPECT_EQ(1u, default_task_queue_->GetNumberOfPendingTasks());
 }
 
 }  // namespace scheduler

third_party/WebKit/Source/platform/scheduler/child/scheduler_helper.cc

@@ -37,21 +37,20 @@ SchedulerHelper::SchedulerHelper(
                                tracing_category,
                                disabled_by_default_tracing_category,
                                disabled_by_default_verbose_tracing_category)),
-      control_task_runner_(
+      control_task_queue_(
           NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::CONTROL)
                            .SetShouldNotifyObservers(false))),
-      default_task_runner_(NewTaskQueue(default_task_queue_spec)),
+      default_task_queue_(NewTaskQueue(default_task_queue_spec)),
       observer_(nullptr),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category) {
-  control_task_runner_->SetQueuePriority(TaskQueue::CONTROL_PRIORITY);
+  control_task_queue_->SetQueuePriority(TaskQueue::CONTROL_PRIORITY);
 
   task_queue_manager_->SetWorkBatchSize(4);
 
   DCHECK(task_queue_manager_delegate_);
-  task_queue_manager_delegate_->SetDefaultTaskRunner(
-      default_task_runner_.get());
+  task_queue_manager_delegate_->SetDefaultTaskRunner(default_task_queue_.get());
 }
 
 SchedulerHelper::~SchedulerHelper() {
@@ -83,11 +82,11 @@ scoped_refptr<TaskQueue> SchedulerHelper::NewTaskQueue(
 
 scoped_refptr<TaskQueue> SchedulerHelper::DefaultTaskQueue() {
   CheckOnValidThread();
-  return default_task_runner_;
+  return default_task_queue_;
 }
 
 scoped_refptr<TaskQueue> SchedulerHelper::ControlTaskQueue() {
-  return control_task_runner_;
+  return control_task_queue_;
 }
 
 size_t SchedulerHelper::GetNumberOfPendingTasks() const {

third_party/WebKit/Source/platform/scheduler/child/scheduler_helper.h

@@ -119,8 +119,8 @@ class BLINK_PLATFORM_EXPORT SchedulerHelper
   base::ThreadChecker thread_checker_;
   scoped_refptr<SchedulerTqmDelegate> task_queue_manager_delegate_;
   std::unique_ptr<TaskQueueManager> task_queue_manager_;
-  scoped_refptr<TaskQueue> control_task_runner_;
-  scoped_refptr<TaskQueue> default_task_runner_;
+  scoped_refptr<TaskQueue> control_task_queue_;
+  scoped_refptr<TaskQueue> default_task_queue_;
 
   Observer* observer_;  // NOT OWNED
   const char* tracing_category_;

third_party/WebKit/Source/platform/scheduler/child/web_scheduler_impl.cc

@@ -22,7 +22,6 @@ WebSchedulerImpl::WebSchedulerImpl(
     scoped_refptr<TaskQueue> timer_task_runner)
     : child_scheduler_(child_scheduler),
       idle_task_runner_(idle_task_runner),
-      timer_task_runner_(timer_task_runner),
       loading_web_task_runner_(WebTaskRunnerImpl::Create(loading_task_runner)),
       timer_web_task_runner_(WebTaskRunnerImpl::Create(timer_task_runner)) {}
 

third_party/WebKit/Source/platform/scheduler/child/web_scheduler_impl.h

@@ -56,7 +56,6 @@ class BLINK_PLATFORM_EXPORT WebSchedulerImpl : public WebScheduler {
 
   ChildScheduler* child_scheduler_;  // NOT OWNED
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
-  scoped_refptr<TaskQueue> timer_task_runner_;
   RefPtr<WebTaskRunnerImpl> loading_web_task_runner_;
   RefPtr<WebTaskRunnerImpl> timer_web_task_runner_;
 

third_party/WebKit/Source/platform/scheduler/child/webthread_impl_for_worker_scheduler.cc

@@ -66,14 +66,14 @@ void WebThreadImplForWorkerScheduler::InitOnThread(
       thread_->message_loop(), base::MakeUnique<base::DefaultTickClock>());
   worker_scheduler_ = CreateWorkerScheduler();
   worker_scheduler_->Init();
-  task_runner_ = worker_scheduler_->DefaultTaskQueue();
+  task_queue_ = worker_scheduler_->DefaultTaskQueue();
   idle_task_runner_ = worker_scheduler_->IdleTaskRunner();
   web_scheduler_.reset(new WebSchedulerImpl(
       worker_scheduler_.get(), worker_scheduler_->IdleTaskRunner(),
       worker_scheduler_->DefaultTaskQueue(),
       worker_scheduler_->DefaultTaskQueue()));
   base::MessageLoop::current()->AddDestructionObserver(this);
-  web_task_runner_ = WebTaskRunnerImpl::Create(task_runner_);
+  web_task_runner_ = WebTaskRunnerImpl::Create(task_queue_);
   completion->Signal();
 }
 
@@ -84,7 +84,7 @@ void WebThreadImplForWorkerScheduler::RestoreTaskRunnerOnThread(
 }
 
 void WebThreadImplForWorkerScheduler::WillDestroyCurrentMessageLoop() {
-  task_runner_ = nullptr;
+  task_queue_ = nullptr;
   idle_task_runner_ = nullptr;
   web_scheduler_.reset();
   worker_scheduler_.reset();
@@ -106,7 +106,7 @@ blink::WebScheduler* WebThreadImplForWorkerScheduler::Scheduler() const {
 
 base::SingleThreadTaskRunner* WebThreadImplForWorkerScheduler::GetTaskRunner()
     const {
-  return task_runner_.get();
+  return task_queue_.get();
 }
 
 SingleThreadIdleTaskRunner* WebThreadImplForWorkerScheduler::GetIdleTaskRunner()

third_party/WebKit/Source/platform/scheduler/child/webthread_impl_for_worker_scheduler.h

@@ -73,7 +73,7 @@ class BLINK_PLATFORM_EXPORT WebThreadImplForWorkerScheduler
   std::unique_ptr<scheduler::WorkerScheduler> worker_scheduler_;
   std::unique_ptr<scheduler::WebSchedulerImpl> web_scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner_;
-  scoped_refptr<TaskQueue> task_runner_;
+  scoped_refptr<TaskQueue> task_queue_;
   scoped_refptr<scheduler::SingleThreadIdleTaskRunner> idle_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> task_runner_delegate_;
   WebPrivatePtr<WebTaskRunnerImpl> web_task_runner_;

third_party/WebKit/Source/platform/scheduler/renderer/auto_advancing_virtual_time_domain_unittest.cc

@@ -36,17 +36,17 @@ class AutoAdvancingVirtualTimeDomainTest : public testing::Test {
         main_task_runner_, "test.scheduler", "test.scheduler",
         "test.scheduler.debug");
     manager_->AddTaskTimeObserver(&test_task_time_observer_);
-    task_runner_ =
+    task_queue_ =
         manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
     initial_time_ = clock_->NowTicks();
     auto_advancing_time_domain_.reset(
         new AutoAdvancingVirtualTimeDomain(initial_time_));
     manager_->RegisterTimeDomain(auto_advancing_time_domain_.get());
-    task_runner_->SetTimeDomain(auto_advancing_time_domain_.get());
+    task_queue_->SetTimeDomain(auto_advancing_time_domain_.get());
   }
 
   void TearDown() override {
-    task_runner_->UnregisterTaskQueue();
+    task_queue_->UnregisterTaskQueue();
     manager_->UnregisterTimeDomain(auto_advancing_time_domain_.get());
   }
 
@@ -56,7 +56,7 @@ class AutoAdvancingVirtualTimeDomainTest : public testing::Test {
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> main_task_runner_;
   std::unique_ptr<TaskQueueManager> manager_;
-  scoped_refptr<TaskQueue> task_runner_;
+  scoped_refptr<TaskQueue> task_queue_;
   std::unique_ptr<AutoAdvancingVirtualTimeDomain> auto_advancing_time_domain_;
   TestTaskTimeObserver test_task_time_observer_;
 };
@@ -70,7 +70,7 @@ void NopTask(bool* task_run) {
 TEST_F(AutoAdvancingVirtualTimeDomainTest, VirtualTimeAdvances) {
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
   bool task_run = false;
-  task_runner_->PostDelayedTask(FROM_HERE, base::Bind(NopTask, &task_run),
+  task_queue_->PostDelayedTask(FROM_HERE, base::Bind(NopTask, &task_run),
                                delay);
 
   mock_task_runner_->RunUntilIdle();
@@ -84,7 +84,7 @@ TEST_F(AutoAdvancingVirtualTimeDomainTest, VirtualTimeAdvances) {
 TEST_F(AutoAdvancingVirtualTimeDomainTest, VirtualTimeDoesNotAdvance) {
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
   bool task_run = false;
-  task_runner_->PostDelayedTask(FROM_HERE, base::Bind(NopTask, &task_run),
+  task_queue_->PostDelayedTask(FROM_HERE, base::Bind(NopTask, &task_run),
                                delay);
 
   auto_advancing_time_domain_->SetCanAdvanceVirtualTime(false);

third_party/WebKit/Source/platform/scheduler/renderer/idle_time_estimator.cc

@@ -14,17 +14,17 @@ IdleTimeEstimator::IdleTimeEstimator(
     base::TickClock* time_source,
     int sample_count,
     double estimation_percentile)
-    : compositor_task_runner_(compositor_task_runner),
+    : compositor_task_queue_(compositor_task_runner),
       per_frame_compositor_task_runtime_(sample_count),
       time_source_(time_source),
       estimation_percentile_(estimation_percentile),
       nesting_level_(0),
       did_commit_(false) {
-  compositor_task_runner_->AddTaskObserver(this);
+  compositor_task_queue_->AddTaskObserver(this);
 }
 
 IdleTimeEstimator::~IdleTimeEstimator() {
-  compositor_task_runner_->RemoveTaskObserver(this);
+  compositor_task_queue_->RemoveTaskObserver(this);
 }
 
 base::TimeDelta IdleTimeEstimator::GetExpectedIdleDuration(

third_party/WebKit/Source/platform/scheduler/renderer/idle_time_estimator.h

@@ -40,7 +40,7 @@ class BLINK_PLATFORM_EXPORT IdleTimeEstimator
   void DidProcessTask(const base::PendingTask& pending_task) override;
 
  private:
-  scoped_refptr<TaskQueue> compositor_task_runner_;
+  scoped_refptr<TaskQueue> compositor_task_queue_;
   cc::RollingTimeDeltaHistory per_frame_compositor_task_runtime_;
   base::TickClock* time_source_;  // NOT OWNED
   double estimation_percentile_;

third_party/WebKit/Source/platform/scheduler/renderer/idle_time_estimator_unittest.cc

@@ -48,10 +48,10 @@ class IdleTimeEstimatorTest : public testing::Test {
     manager_ = base::MakeUnique<TaskQueueManager>(
         main_task_runner_, "test.scheduler", "test.scheduler",
         "test.scheduler.debug");
-    compositor_task_runner_ = manager_->NewTaskQueue(
+    compositor_task_queue_ = manager_->NewTaskQueue(
         TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR));
     estimator_.reset(new IdleTimeEstimatorForTest(
-        compositor_task_runner_, test_time_source_.get(), 10, 50));
+        compositor_task_queue_, test_time_source_.get(), 10, 50));
   }
 
   void SimulateFrameWithOneCompositorTask(int compositor_time) {
@@ -91,7 +91,7 @@ class IdleTimeEstimatorTest : public testing::Test {
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> main_task_runner_;
   std::unique_ptr<TaskQueueManager> manager_;
-  scoped_refptr<TaskQueue> compositor_task_runner_;
+  scoped_refptr<TaskQueue> compositor_task_queue_;
   std::unique_ptr<IdleTimeEstimatorForTest> estimator_;
   const base::TimeDelta frame_length_;
   TestTaskTimeObserver test_task_time_observer_;

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

@@ -101,12 +101,12 @@ RendererSchedulerImpl::RendererSchedulerImpl(
                                           &helper_,
                                           idle_helper_.IdleTaskRunner()),
       render_widget_scheduler_signals_(this),
-      control_task_runner_(helper_.ControlTaskQueue()),
-      compositor_task_runner_(
+      control_task_queue_(helper_.ControlTaskQueue()),
+      compositor_task_queue_(
           helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
-      compositor_task_runner_enabled_voter_(
-          compositor_task_runner_->CreateQueueEnabledVoter()),
+      compositor_task_queue_enabled_voter_(
+          compositor_task_queue_->CreateQueueEnabledVoter()),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
@@ -114,7 +114,7 @@ RendererSchedulerImpl::RendererSchedulerImpl(
       seqlock_queueing_time_estimator_(
           QueueingTimeEstimator(this, base::TimeDelta::FromSeconds(1))),
       main_thread_only_(this,
-                        compositor_task_runner_,
+                        compositor_task_queue_,
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
@@ -130,9 +130,9 @@ RendererSchedulerImpl::RendererSchedulerImpl(
       base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
                  weak_factory_.GetWeakPtr()));
 
-  default_loading_task_runner_ =
+  default_loading_task_queue_ =
       NewLoadingTaskQueue(TaskQueue::QueueType::DEFAULT_LOADING);
-  default_timer_task_runner_ =
+  default_timer_task_queue_ =
       NewTimerTaskQueue(TaskQueue::QueueType::DEFAULT_TIMER);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
@@ -272,7 +272,7 @@ RendererSchedulerImpl::DefaultTaskRunner() {
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::CompositorTaskRunner() {
   helper_.CheckOnValidThread();
-  return compositor_task_runner_;
+  return compositor_task_queue_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
@@ -283,13 +283,13 @@ RendererSchedulerImpl::IdleTaskRunner() {
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::LoadingTaskRunner() {
   helper_.CheckOnValidThread();
-  return default_loading_task_runner_;
+  return default_loading_task_queue_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::TimerTaskRunner() {
   helper_.CheckOnValidThread();
-  return default_timer_task_runner_;
+  return default_timer_task_queue_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskQueue() {
@@ -298,17 +298,17 @@ scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskQueue() {
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::CompositorTaskQueue() {
   helper_.CheckOnValidThread();
-  return compositor_task_runner_;
+  return compositor_task_queue_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::LoadingTaskQueue() {
   helper_.CheckOnValidThread();
-  return default_loading_task_runner_;
+  return default_loading_task_queue_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskQueue() {
   helper_.CheckOnValidThread();
-  return default_timer_task_runner_;
+  return default_timer_task_queue_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskQueue() {
@@ -491,7 +491,7 @@ void RendererSchedulerImpl::SetAllRenderWidgetsHidden(bool hidden) {
     // hidden.
     base::TimeDelta end_idle_when_hidden_delay =
         base::TimeDelta::FromMilliseconds(kEndIdleWhenHiddenDelayMillis);
-    control_task_runner_->PostDelayedTask(
+    control_task_queue_->PostDelayedTask(
         FROM_HERE, end_renderer_hidden_idle_period_closure_.GetCallback(),
         end_idle_when_hidden_delay);
     GetMainThreadOnly().renderer_hidden = true;
@@ -540,7 +540,7 @@ void RendererSchedulerImpl::OnRendererBackgrounded() {
   base::TimeDelta suspend_timers_when_backgrounded_delay =
       base::TimeDelta::FromMilliseconds(
           kSuspendTimersWhenBackgroundedDelayMillis);
-  control_task_runner_->PostDelayedTask(
+  control_task_queue_->PostDelayedTask(
       FROM_HERE, suspend_timers_when_backgrounded_closure_.GetCallback(),
       suspend_timers_when_backgrounded_delay);
 }
@@ -848,7 +848,7 @@ bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
     case UseCase::MAIN_THREAD_GESTURE:
     case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
     case UseCase::SYNCHRONIZED_GESTURE:
-      return compositor_task_runner_->HasPendingImmediateWork() ||
+      return compositor_task_queue_->HasPendingImmediateWork() ||
              GetMainThreadOnly().touchstart_expected_soon;
 
     case UseCase::TOUCHSTART:
@@ -891,7 +891,7 @@ void RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread(
   any_thread_lock_.AssertAcquired();
   if (!policy_may_need_update_.IsSet()) {
     policy_may_need_update_.SetWhileLocked(true);
-    control_task_runner_->PostTask(from_here, update_policy_closure_);
+    control_task_queue_->PostTask(from_here, update_policy_closure_);
   }
 }
 
@@ -1165,8 +1165,7 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
   }
 
   ApplyTaskQueuePolicy(
-      compositor_task_runner_.get(),
-      compositor_task_runner_enabled_voter_.get(),
+      compositor_task_queue_.get(), compositor_task_queue_enabled_voter_.get(),
       GetMainThreadOnly().current_policy.compositor_queue_policy,
       new_policy.compositor_queue_policy);
 
@@ -1206,7 +1205,7 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
     }
   }
 
-  DCHECK(compositor_task_runner_->IsQueueEnabled());
+  DCHECK(compositor_task_queue_->IsQueueEnabled());
   GetMainThreadOnly().current_policy = new_policy;
 }
 
@@ -1361,7 +1360,7 @@ void RendererSchedulerImpl::SuspendTimerQueue() {
   GetMainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
 #ifndef NDEBUG
-  DCHECK(!default_timer_task_runner_->IsQueueEnabled());
+  DCHECK(!default_timer_task_queue_->IsQueueEnabled());
   for (const auto& runner : timer_task_runners_) {
     DCHECK(!runner.first->IsQueueEnabled());
   }
@@ -1655,11 +1654,11 @@ void RendererSchedulerImpl::SetTopLevelBlameContext(
   //
   // Per-frame task runners (loading, timers, etc.) are configured with a more
   // specific blame context by WebFrameSchedulerImpl.
-  control_task_runner_->SetBlameContext(blame_context);
+  control_task_queue_->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);
+  default_loading_task_queue_->SetBlameContext(blame_context);
+  default_timer_task_queue_->SetBlameContext(blame_context);
+  compositor_task_queue_->SetBlameContext(blame_context);
   idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context);
 }
 

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h

@@ -400,10 +400,10 @@ class BLINK_PLATFORM_EXPORT RendererSchedulerImpl
   std::unique_ptr<TaskQueueThrottler> task_queue_throttler_;
   RenderWidgetSignals render_widget_scheduler_signals_;
 
-  const scoped_refptr<TaskQueue> control_task_runner_;
-  const scoped_refptr<TaskQueue> compositor_task_runner_;
+  const scoped_refptr<TaskQueue> control_task_queue_;
+  const scoped_refptr<TaskQueue> compositor_task_queue_;
   std::unique_ptr<TaskQueue::QueueEnabledVoter>
-      compositor_task_runner_enabled_voter_;
+      compositor_task_queue_enabled_voter_;
 
   using TaskQueueVoterMap =
       std::map<scoped_refptr<TaskQueue>,
@@ -412,8 +412,8 @@ class BLINK_PLATFORM_EXPORT RendererSchedulerImpl
   TaskQueueVoterMap loading_task_runners_;
   TaskQueueVoterMap timer_task_runners_;
   std::set<scoped_refptr<TaskQueue>> unthrottled_task_runners_;
-  scoped_refptr<TaskQueue> default_loading_task_runner_;
-  scoped_refptr<TaskQueue> default_timer_task_runner_;
+  scoped_refptr<TaskQueue> default_loading_task_queue_;
+  scoped_refptr<TaskQueue> default_timer_task_queue_;
 
   // Note |virtual_time_domain_| is lazily created.
   std::unique_ptr<AutoAdvancingVirtualTimeDomain> virtual_time_domain_;

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc

@@ -75,7 +75,7 @@ std::string PointerToId(void* pointer) {
 TaskQueueThrottler::TaskQueueThrottler(
     RendererSchedulerImpl* renderer_scheduler,
     const char* tracing_category)
-    : task_runner_(renderer_scheduler->ControlTaskQueue()),
+    : control_task_queue_(renderer_scheduler->ControlTaskQueue()),
       renderer_scheduler_(renderer_scheduler),
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
@@ -108,7 +108,7 @@ TaskQueueThrottler::~TaskQueueThrottler() {
 }
 
 void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
-  DCHECK_NE(task_queue, task_runner_.get());
+  DCHECK_NE(task_queue, control_task_queue_.get());
 
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       queue_details_.insert(std::make_pair(task_queue, Metadata()));
@@ -194,8 +194,8 @@ void TaskQueueThrottler::UnregisterTaskQueue(TaskQueue* task_queue) {
 void TaskQueueThrottler::OnQueueNextWakeUpChanged(
     TaskQueue* queue,
     base::TimeTicks next_wake_up) {
-  if (!task_runner_->RunsTasksOnCurrentThread()) {
-    task_runner_->PostTask(
+  if (!control_task_queue_->RunsTasksOnCurrentThread()) {
+    control_task_queue_->PostTask(
         FROM_HERE,
         base::Bind(forward_immediate_work_callback_, queue, next_wake_up));
     return;
@@ -303,7 +303,7 @@ void TaskQueueThrottler::MaybeSchedulePumpThrottledTasks(
   TRACE_EVENT1(tracing_category_,
                "TaskQueueThrottler::MaybeSchedulePumpThrottledTasks",
                "delay_till_next_pump_ms", delay.InMilliseconds());
-  task_runner_->PostDelayedTask(
+  control_task_queue_->PostDelayedTask(
       from_here, pump_throttled_tasks_closure_.GetCallback(), delay);
 }
 

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.h

@@ -128,7 +128,9 @@ class BLINK_PLATFORM_EXPORT TaskQueueThrottler : public TaskQueue::Observer,
   static base::TimeTicks AlignedThrottledRunTime(
       base::TimeTicks unthrottled_runtime);
 
-  const scoped_refptr<TaskQueue>& task_runner() const { return task_runner_; }
+  const scoped_refptr<TaskQueue>& task_queue() const {
+    return control_task_queue_;
+  }
 
   // Returned object is owned by |TaskQueueThrottler|.
   CPUTimeBudgetPool* CreateCPUTimeBudgetPool(const char* name);
@@ -174,7 +176,7 @@ class BLINK_PLATFORM_EXPORT TaskQueueThrottler : public TaskQueue::Observer,
   TaskQueueMap queue_details_;
   base::Callback<void(TaskQueue*, base::TimeTicks)>
       forward_immediate_work_callback_;
-  scoped_refptr<TaskQueue> task_runner_;
+  scoped_refptr<TaskQueue> control_task_queue_;
   RendererSchedulerImpl* renderer_scheduler_;  // NOT OWNED
   base::TickClock* tick_clock_;                // NOT OWNED
   const char* tracing_category_;               // NOT OWNED

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc

@@ -271,14 +271,14 @@ TEST_F(TaskQueueThrottlerTest,
        ThrotlingAnEmptyQueueDoesNotPostPumpThrottledTasksLocked) {
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
 
-  EXPECT_TRUE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_TRUE(task_queue_throttler_->task_queue()->IsEmpty());
 }
 
 TEST_F(TaskQueueThrottlerTest, OnTimeDomainHasImmediateWork_EnabledQueue) {
   task_queue_throttler_->OnQueueNextWakeUpChanged(timer_queue_.get(),
                                                   base::TimeTicks());
   // Check PostPumpThrottledTasksLocked was called.
-  EXPECT_FALSE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_FALSE(task_queue_throttler_->task_queue()->IsEmpty());
 }
 
 TEST_F(TaskQueueThrottlerTest, OnTimeDomainHasImmediateWork_DisabledQueue) {
@@ -289,7 +289,7 @@ TEST_F(TaskQueueThrottlerTest, OnTimeDomainHasImmediateWork_DisabledQueue) {
   task_queue_throttler_->OnQueueNextWakeUpChanged(timer_queue_.get(),
                                                   base::TimeTicks());
   // Check PostPumpThrottledTasksLocked was not called.
-  EXPECT_TRUE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_TRUE(task_queue_throttler_->task_queue()->IsEmpty());
 }
 
 TEST_F(TaskQueueThrottlerTest,
@@ -301,11 +301,11 @@ TEST_F(TaskQueueThrottlerTest,
   voter->SetQueueEnabled(false);
 
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
-  EXPECT_TRUE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_TRUE(task_queue_throttler_->task_queue()->IsEmpty());
 
   // Enabling it should trigger a call to PostPumpThrottledTasksLocked.
   voter->SetQueueEnabled(true);
-  EXPECT_FALSE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_FALSE(task_queue_throttler_->task_queue()->IsEmpty());
 }
 
 TEST_F(TaskQueueThrottlerTest,
@@ -318,11 +318,11 @@ TEST_F(TaskQueueThrottlerTest,
   voter->SetQueueEnabled(false);
 
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
-  EXPECT_TRUE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_TRUE(task_queue_throttler_->task_queue()->IsEmpty());
 
   // Enabling it should trigger a call to PostPumpThrottledTasksLocked.
   voter->SetQueueEnabled(true);
-  EXPECT_FALSE(task_queue_throttler_->task_runner()->IsEmpty());
+  EXPECT_FALSE(task_queue_throttler_->task_queue()->IsEmpty());
 }
 
 TEST_F(TaskQueueThrottlerTest, WakeUpForNonDelayedTask) {