[scheduler] Rename member variables from task_runner_ to task_queue_.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.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 "platform/scheduler/renderer/task_queue_throttler.h"
 
 #include <cstdint>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 57 matching lines @@
   return base::StringPrintf(
       "0x%" PRIx64,
       static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pointer)));
 }
 
 }  // namespace
 
 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),
       time_domain_(new ThrottledTimeDomain(tracing_category)),
       allow_throttling_(true),
       weak_factory_(this) {
   pump_throttled_tasks_closure_.Reset(base::Bind(
       &TaskQueueThrottler::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
   forward_immediate_work_callback_ =
       base::Bind(&TaskQueueThrottler::OnQueueNextWakeUpChanged,
@@ skipping 12 matching lines @@
       task_queue->RemoveFence();
     }
     if (map_entry.second.throttling_ref_count != 0)
       task_queue->SetObserver(nullptr);
   }
 
   renderer_scheduler_->UnregisterTimeDomain(time_domain_.get());
 }
 
 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()));
   insert_result.first->second.throttling_ref_count++;
 
   // If ref_count is 1, the task queue is newly throttled.
   if (insert_result.first->second.throttling_ref_count != 1)
     return;
 
   TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueThrottled",
@@ skipping 65 matching lines @@
   // Iterator may have been deleted by BudgetPool::RemoveQueue, so don't
   // use it here.
   queue_details_.erase(task_queue);
 
   // NOTE: Observer is automatically unregistered when unregistering 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;
   }
 
   TRACE_EVENT0(tracing_category_,
                "TaskQueueThrottler::OnQueueNextWakeUpChanged");
 
   // We don't expect this to get called for disabled queues, but we can't DCHECK
   // because of the above thread hop.  Just bail out if the queue is disabled.
@@ skipping 87 matching lines @@
   }
 
   pending_pump_throttled_tasks_runtime_ = runtime;
 
   pump_throttled_tasks_closure_.Cancel();
 
   base::TimeDelta delay = pending_pump_throttled_tasks_runtime_.value() - now;
   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);
 }
 
 CPUTimeBudgetPool* TaskQueueThrottler::CreateCPUTimeBudgetPool(
     const char* name) {
   CPUTimeBudgetPool* time_budget_pool =
       new CPUTimeBudgetPool(name, this, tick_clock_->NowTicks());
   budget_pools_[time_budget_pool] = base::WrapUnique(time_budget_pool);
   return time_budget_pool;
 }
@@ skipping 167 matching lines @@
     queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
     queue->SetTimeDomain(time_domain_.get());
     SchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue);
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink