[scheduler] Rename member variables from task_runner_ to task_queue_.

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

 // Copyright 2017 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/child/idle_canceled_delayed_task_sweeper.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "platform/scheduler/base/lazy_now.h"
@@ skipping 34 matching lines @@
             new IdleHelper(scheduler_helper_.get(),
                            this,
                            "test.scheduler",
                            TRACE_DISABLED_BY_DEFAULT("test.scheduler"),
                            TRACE_DISABLED_BY_DEFAULT("test.scheduler.dbg"),
                            base::TimeDelta::FromSeconds(30))),
         idle_canceled_delayed_taks_sweeper_(
             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));
   }
 
   ~IdleCanceledDelayedTaskSweeperTest() override {}
 
   void TearDown() override {
     // Check that all tests stop posting tasks.
     mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
     while (mock_task_runner_->RunUntilIdle()) {
     }
@@ skipping 11 matching lines @@
 
  protected:
   std::unique_ptr<base::SimpleTestTickClock> clock_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
 
   scoped_refptr<SchedulerTqmDelegateForTest> delegate_;
   std::unique_ptr<SchedulerHelper> scheduler_helper_;
   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);
 };
 
 TEST_F(IdleCanceledDelayedTaskSweeperTest, TestSweep) {
   TestClass class1;
   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));
 
   // Cancel the last four tasks.
   class2.weak_factory_.InvalidateWeakPtrs();
 
   // Give the IdleCanceledDelayedTaskSweeper a chance to run but don't let
   // the first non canceled delayed task run.  This is important because the
   // canceled tasks would get removed by TaskQueueImpl::WakeUpForDelayedWork.
   clock_->Advance(base::TimeDelta::FromSeconds(40));
   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
 }  // namespace blink