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

third_party/WebKit/Source/platform/TimerTest.cpp

 // 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/Timer.h"
 
 #include <memory>
 #include <queue>
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/child/web_task_runner_impl.h"
@@ skipping 36 matching lines @@
     EXPECT_GE(period, 0.0);
     platform_->RunForPeriodSeconds(period);
   }
 
   // Returns false if there are no pending delayed tasks, otherwise sets |time|
   // to the delay in seconds till the next pending delayed task is scheduled to
   // fire.
   bool TimeTillNextDelayedTask(double* time) const {
     base::TimeTicks next_run_time;
     if (!platform_->GetRendererScheduler()
-             ->TimerTaskRunner()
+             ->TimerTaskQueue()
              ->GetTimeDomain()
              ->NextScheduledRunTime(&next_run_time))
       return false;
     *time = (next_run_time - platform_->GetRendererScheduler()
-                                 ->TimerTaskRunner()
+                                 ->TimerTaskQueue()
                                  ->GetTimeDomain()
                                  ->Now())
                 .InSecondsF();
     return true;
   }
 
  protected:
   double start_time_;
   WTF::Vector<double> run_times_;
   WTF::Vector<double> next_fire_times_;
@@ skipping 456 matching lines @@
   TimerForTest(RefPtr<WebTaskRunner> web_task_runner,
                TimerFiredClass* timer_fired_class,
                TimerFiredFunction timer_fired_function)
       : TaskRunnerTimer<TimerFiredClass>(std::move(web_task_runner),
                                          timer_fired_class,
                                          timer_fired_function) {}
 };
 
 TEST_F(TimerTest, UserSuppliedWebTaskRunner) {
   scoped_refptr<scheduler::TaskQueue> task_runner(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner =
       scheduler::WebTaskRunnerImpl::Create(task_runner);
   TimerForTest<TimerTest> timer(web_task_runner, this,
                                 &TimerTest::CountingTask);
   timer.StartOneShot(0, BLINK_FROM_HERE);
 
   // Make sure the task was posted on taskRunner.
   EXPECT_FALSE(task_runner->IsEmpty());
 }
@@ skipping 67 matching lines @@
   RefPtr<WebTaskRunner> task_runner_;
   std::vector<RefPtr<WebTaskRunner>>* run_order_;
 };
 
 }  // namespace
 
 TEST_F(TimerTest, MoveToNewTaskRunnerOneShot) {
   std::vector<RefPtr<WebTaskRunner>> run_order;
 
   scoped_refptr<scheduler::TaskQueue> task_runner1(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner1 =
       scheduler::WebTaskRunnerImpl::Create(task_runner1);
   TaskObserver task_observer1(web_task_runner1, &run_order);
   task_runner1->AddTaskObserver(&task_observer1);
 
   scoped_refptr<scheduler::TaskQueue> task_runner2(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner2 =
       scheduler::WebTaskRunnerImpl::Create(task_runner2);
   TaskObserver task_observer2(web_task_runner2, &run_order);
   task_runner2->AddTaskObserver(&task_observer2);
 
   TimerForTest<TimerTest> timer(web_task_runner1, this,
                                 &TimerTest::CountingTask);
 
   double start_time = MonotonicallyIncreasingTime();
@@ skipping 11 matching lines @@
   EXPECT_THAT(run_order, ElementsAre(web_task_runner2));
 
   EXPECT_TRUE(task_runner1->IsEmpty());
   EXPECT_TRUE(task_runner2->IsEmpty());
 }
 
 TEST_F(TimerTest, MoveToNewTaskRunnerRepeating) {
   std::vector<RefPtr<WebTaskRunner>> run_order;
 
   scoped_refptr<scheduler::TaskQueue> task_runner1(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner1 =
       scheduler::WebTaskRunnerImpl::Create(task_runner1);
   TaskObserver task_observer1(web_task_runner1, &run_order);
   task_runner1->AddTaskObserver(&task_observer1);
 
   scoped_refptr<scheduler::TaskQueue> task_runner2(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner2 =
       scheduler::WebTaskRunnerImpl::Create(task_runner2);
   TaskObserver task_observer2(web_task_runner2, &run_order);
   task_runner2->AddTaskObserver(&task_observer2);
 
   TimerForTest<TimerTest> timer(web_task_runner1, this,
                                 &TimerTest::CountingTask);
 
   double start_time = MonotonicallyIncreasingTime();
@@ skipping 13 matching lines @@
                                      web_task_runner2, web_task_runner2));
 
   EXPECT_TRUE(task_runner1->IsEmpty());
   EXPECT_FALSE(task_runner2->IsEmpty());
 }
 
 // This test checks that when inactive timer is moved to a different task
 // runner it isn't activated.
 TEST_F(TimerTest, MoveToNewTaskRunnerWithoutTasks) {
   scoped_refptr<scheduler::TaskQueue> task_runner1(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner1 =
       scheduler::WebTaskRunnerImpl::Create(task_runner1);
 
   scoped_refptr<scheduler::TaskQueue> task_runner2(
-      platform_->GetRendererScheduler()->NewTimerTaskRunner(
+      platform_->GetRendererScheduler()->NewTimerTaskQueue(
           scheduler::TaskQueue::QueueType::TEST));
   RefPtr<scheduler::WebTaskRunnerImpl> web_task_runner2 =
       scheduler::WebTaskRunnerImpl::Create(task_runner2);
 
   TimerForTest<TimerTest> timer(web_task_runner1, this,
                                 &TimerTest::CountingTask);
 
   platform_->RunUntilIdle();
   EXPECT_TRUE(!run_times_.size());
   EXPECT_TRUE(task_runner1->IsEmpty());
   EXPECT_TRUE(task_runner2->IsEmpty());
 }
 
 }  // namespace
 }  // namespace blink