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

third_party/WebKit/Source/platform/scheduler/child/idle_helper.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/child/idle_helper.h"
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "platform/scheduler/base/real_time_domain.h"
-#include "public/platform/scheduler/base/task_queue.h"
+#include "platform/scheduler/base/task_queue.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/child/scheduler_helper.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
 
 namespace blink {
 namespace scheduler {
 
 IdleHelper::IdleHelper(
     SchedulerHelper* helper,
     Delegate* delegate,
@@ skipping 112 matching lines @@
 void IdleHelper::EnableLongIdlePeriod() {
   TRACE_EVENT0(disabled_by_default_tracing_category_, "EnableLongIdlePeriod");
   helper_->CheckOnValidThread();
   if (is_shutdown_)
     return;
 
   // End any previous idle period.
   EndIdlePeriod();
 
   if (ShouldWaitForQuiescence()) {
-    helper_->ControlTaskRunner()->PostDelayedTask(
+    helper_->ControlTaskQueue()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.GetCallback(),
         required_quiescence_duration_before_long_idle_period_);
     delegate_->IsNotQuiescent();
     return;
   }
 
   base::TimeTicks now(helper_->scheduler_tqm_delegate()->NowTicks());
   base::TimeDelta next_long_idle_period_delay;
   IdlePeriodState new_idle_period_state =
       ComputeNewLongIdlePeriodState(now, &next_long_idle_period_delay);
   if (IsInIdlePeriod(new_idle_period_state)) {
     StartIdlePeriod(new_idle_period_state, now,
                     now + next_long_idle_period_delay);
   } else {
     // Otherwise wait for the next long idle period delay before trying again.
-    helper_->ControlTaskRunner()->PostDelayedTask(
+    helper_->ControlTaskQueue()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.GetCallback(),
         next_long_idle_period_delay);
   }
 }
 
 void IdleHelper::StartIdlePeriod(IdlePeriodState new_state,
                                  base::TimeTicks now,
                                  base::TimeTicks idle_period_deadline) {
   DCHECK(!is_shutdown_);
   DCHECK_GT(idle_period_deadline, now);
@@ skipping 94 matching lines @@
     } else {
       // Otherwise ensure that we kick the scheduler at the right time to
       // initiate the next idle period.
       next_long_idle_period_delay = std::max(
           base::TimeDelta(), state_.idle_period_deadline() -
                                  helper_->scheduler_tqm_delegate()->NowTicks());
     }
     if (next_long_idle_period_delay.is_zero()) {
       EnableLongIdlePeriod();
     } else {
-      helper_->ControlTaskRunner()->PostDelayedTask(
+      helper_->ControlTaskQueue()->PostDelayedTask(
           FROM_HERE, enable_next_long_idle_period_closure_.GetCallback(),
           next_long_idle_period_delay);
     }
   }
 }
 
 base::TimeTicks IdleHelper::CurrentIdleTaskDeadline() const {
   helper_->CheckOnValidThread();
   return state_.idle_period_deadline();
 }
 
 void IdleHelper::OnIdleTaskPosted() {
   TRACE_EVENT0(disabled_by_default_tracing_category_, "OnIdleTaskPosted");
   if (is_shutdown_)
     return;
   if (idle_task_runner_->RunsTasksOnCurrentThread()) {
     OnIdleTaskPostedOnMainThread();
   } else {
-    helper_->ControlTaskRunner()->PostTask(
+    helper_->ControlTaskQueue()->PostTask(
         FROM_HERE, on_idle_task_posted_closure_.GetCallback());
   }
 }
 
 void IdleHelper::OnIdleTaskPostedOnMainThread() {
   TRACE_EVENT0(disabled_by_default_tracing_category_,
                "OnIdleTaskPostedOnMainThread");
   if (is_shutdown_)
     return;
   if (state_.idle_period_state() ==
       IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
     // Restart long idle period ticks.
-    helper_->ControlTaskRunner()->PostTask(
+    helper_->ControlTaskQueue()->PostTask(
         FROM_HERE, enable_next_long_idle_period_closure_.GetCallback());
   }
 }
 
 base::TimeTicks IdleHelper::WillProcessIdleTask() {
   helper_->CheckOnValidThread();
   DCHECK(!is_shutdown_);
   state_.TraceIdleIdleTaskStart();
   return CurrentIdleTaskDeadline();
 }
@@ skipping 185 matching lines @@
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink