[scheduler] Rename member variables from task_runner_ to task_queue_.

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_.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)),
           helper_.ControlTaskQueue()),
       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_),
       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_ =
+  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(
       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
@@ skipping 119 matching lines @@
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::DefaultTaskRunner() {
   return helper_.DefaultTaskQueue();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::CompositorTaskRunner() {
   helper_.CheckOnValidThread();
-  return compositor_task_runner_;
+  return compositor_task_queue_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
 RendererSchedulerImpl::IdleTaskRunner() {
   return idle_helper_.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() {
   return helper_.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() {
   helper_.CheckOnValidThread();
   return helper_.ControlTaskQueue();
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
@@ skipping 162 matching lines @@
 
   end_renderer_hidden_idle_period_closure_.Cancel();
 
   if (hidden) {
     idle_helper_.EnableLongIdlePeriod();
 
     // Ensure that we stop running idle tasks after a few seconds of being
     // 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;
   } else {
     GetMainThreadOnly().renderer_hidden = false;
     EndIdlePeriod();
   }
 
   // TODO(alexclarke): Should we update policy here?
   CreateTraceEventObjectSnapshot();
@@ skipping 28 matching lines @@
   GetMainThreadOnly().foreground_main_thread_load_tracker.Pause(now);
   GetMainThreadOnly().background_main_thread_load_tracker.Resume(now);
 
   if (!GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled)
     return;
 
   suspend_timers_when_backgrounded_closure_.Cancel();
   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);
 }
 
 void RendererSchedulerImpl::OnRendererForegrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererForegrounded");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || !GetMainThreadOnly().renderer_backgrounded)
     return;
@@ skipping 287 matching lines @@
   // for it since these tasks are not user-provided work and they are only
   // intended to run before the next task, not interrupt the tasks.
   switch (GetMainThreadOnly().current_use_case) {
     case UseCase::COMPOSITOR_GESTURE:
     case UseCase::NONE:
       return GetMainThreadOnly().touchstart_expected_soon;
 
     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:
       return true;
 
     case UseCase::LOADING:
       return false;
 
     default:
       NOTREACHED();
@@ skipping 22 matching lines @@
   }
 }
 
 void RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread(
     const tracked_objects::Location& from_here) {
   // TODO(scheduler-dev): Check that this method isn't called from the main
   // thread.
   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_);
   }
 }
 
 void RendererSchedulerImpl::UpdatePolicy() {
   base::AutoLock lock(any_thread_lock_);
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::ForceUpdatePolicy() {
   base::AutoLock lock(any_thread_lock_);
@@ skipping 253 matching lines @@
                  "RendererScheduler.timer_tasks_seem_expensive",
                  GetMainThreadOnly().timer_tasks_seem_expensive);
 
   // TODO(alexclarke): Can we get rid of force update now?
   if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
       new_policy == GetMainThreadOnly().current_policy) {
     return;
   }
 
   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);
 
   for (const auto& pair : loading_task_runners_) {
     ApplyTaskQueuePolicy(
         pair.first.get(), pair.second.get(),
         GetMainThreadOnly().current_policy.loading_queue_policy,
         new_policy.loading_queue_policy);
   }
 
@@ skipping 19 matching lines @@
 
   if (new_policy.should_disable_throttling !=
       GetMainThreadOnly().current_policy.should_disable_throttling) {
     if (new_policy.should_disable_throttling) {
       task_queue_throttler()->DisableThrottling();
     } else {
       task_queue_throttler()->EnableThrottling();
     }
   }
 
-  DCHECK(compositor_task_runner_->IsQueueEnabled());
+  DCHECK(compositor_task_queue_->IsQueueEnabled());
   GetMainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
     TaskQueue::QueueEnabledVoter* task_queue_enabled_voter,
     const TaskQueuePolicy& old_task_queue_policy,
     const TaskQueuePolicy& new_task_queue_policy) const {
   if (task_queue_enabled_voter &&
       old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
@@ skipping 134 matching lines @@
 }
 
 IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() {
   return &GetMainThreadOnly().idle_time_estimator;
 }
 
 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());
   }
 #endif
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   GetMainThreadOnly().timer_queue_suspend_count--;
   DCHECK_GE(GetMainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
@@ skipping 275 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);
+  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);
 }
 
 void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) {
   GetMainThreadOnly().rail_mode_observer = observer;
 }
 
 bool RendererSchedulerImpl::MainThreadSeemsUnresponsive(
     base::TimeDelta main_thread_responsiveness_threshold) {
   base::TimeTicks now = tick_clock()->NowTicks();
@@ skipping 278 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink