[scheduler] Remove TaskQueue reference from MainThread/NonMainThreadSchedulerHelper.

Currently you can request a reference to the MainThreadTaskQueue as well
as the underlying TaskQueue from the SchedulerHelper. In all cases, the
TaskQueue is only used to directly get the TaskRunner. We don't need to
return the TaskQueue here so this change returns a reference to the
TaskRunner instead.

This CL is a follow-up to this CL[1] and removes a spot where we need to
return a raw pointer to the underlying TaskQueue.

[1] https://chromium-review.googlesource.com/c/chromium/src/+/2453591

Bug: 1143007
Change-Id: I40e751f77447c54961c0102ddb596ddcfb035f69
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2519718Reviewed-by: Scott Haseley <shaseley@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Katie Dillon <kdillon@chromium.org>
Cr-Commit-Position: refs/heads/master@{#824607}

base/task/sequence_manager/task_queue.h

@@ -338,7 +338,7 @@ class BASE_EXPORT TaskQueue : public RefCountedThreadSafe<TaskQueue> {
   scoped_refptr<SingleThreadTaskRunner> CreateTaskRunner(TaskType task_type);
 
   // Default task runner which doesn't annotate tasks with a task type.
-  scoped_refptr<SingleThreadTaskRunner> task_runner() const {
+  const scoped_refptr<SingleThreadTaskRunner>& task_runner() const {
     return default_task_runner_;
   }
 

third_party/blink/renderer/platform/scheduler/common/idle_helper.cc

@@ -139,7 +139,7 @@ void IdleHelper::EnableLongIdlePeriod() {
   EndIdlePeriod();
 
   if (ShouldWaitForQuiescence()) {
-    helper_->ControlTaskQueue()->task_runner()->PostDelayedTask(
+    helper_->ControlTaskRunner()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.GetCallback(),
         required_quiescence_duration_before_long_idle_period_);
     delegate_->IsNotQuiescent();
@@ -155,7 +155,7 @@ void IdleHelper::EnableLongIdlePeriod() {
                     now + next_long_idle_period_delay);
   } else {
     // Otherwise wait for the next long idle period delay before trying again.
-    helper_->ControlTaskQueue()->task_runner()->PostDelayedTask(
+    helper_->ControlTaskRunner()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.GetCallback(),
         next_long_idle_period_delay);
   }
@@ -263,7 +263,7 @@ void IdleHelper::UpdateLongIdlePeriodStateAfterIdleTask() {
     if (next_long_idle_period_delay.is_zero()) {
       EnableLongIdlePeriod();
     } else {
-      helper_->ControlTaskQueue()->task_runner()->PostDelayedTask(
+      helper_->ControlTaskRunner()->PostDelayedTask(
           FROM_HERE, enable_next_long_idle_period_closure_.GetCallback(),
           next_long_idle_period_delay);
     }
@@ -283,7 +283,7 @@ void IdleHelper::OnIdleTaskPosted() {
   if (idle_task_runner_->RunsTasksInCurrentSequence()) {
     OnIdleTaskPostedOnMainThread();
   } else {
-    helper_->ControlTaskQueue()->task_runner()->PostTask(
+    helper_->ControlTaskRunner()->PostTask(
         FROM_HERE, on_idle_task_posted_closure_.GetCallback());
   }
 }
@@ -296,7 +296,7 @@ void IdleHelper::OnIdleTaskPostedOnMainThread() {
   delegate_->OnPendingTasksChanged(true);
   if (state_.idle_period_state() == IdlePeriodState::kInLongIdlePeriodPaused) {
     // Restart long idle period ticks.
-    helper_->ControlTaskQueue()->task_runner()->PostTask(
+    helper_->ControlTaskRunner()->PostTask(
         FROM_HERE, enable_next_long_idle_period_closure_.GetCallback());
   }
 }

third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc

@@ -57,11 +57,6 @@ void SchedulerHelper::Shutdown() {
   sequence_manager_ = nullptr;
 }
 
-scoped_refptr<base::SingleThreadTaskRunner>
-SchedulerHelper::DefaultTaskRunner() {
-  return default_task_runner_;
-}
-
 void SchedulerHelper::SetWorkBatchSizeForTesting(int work_batch_size) {
   CheckOnValidThread();
   DCHECK(sequence_manager_);

third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h

@@ -42,18 +42,15 @@ class PLATFORM_EXPORT SchedulerHelper
   base::TimeTicks NowTicks() const;
   void SetTimerSlack(base::TimerSlack timer_slack);
 
-  // Returns the default task queue.
-  virtual scoped_refptr<base::sequence_manager::TaskQueue>
-  DefaultTaskQueue() = 0;
-
-  // Returns the control task queue.  Tasks posted to this queue are executed
-  // with the highest priority. Care must be taken to avoid starvation of other
-  // task queues.
-  virtual scoped_refptr<base::sequence_manager::TaskQueue>
-  ControlTaskQueue() = 0;
-
-  // Returns task runner for the default queue.
-  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner();
+  // Returns the task runner for the default task queue.
+  virtual const scoped_refptr<base::SingleThreadTaskRunner>&
+  DefaultTaskRunner() = 0;
+
+  // Returns the task runner for the control task queue.  Tasks posted to this
+  // queue are executed with the highest priority. Care must be taken to avoid
+  // starvation of other task queues.
+  virtual const scoped_refptr<base::SingleThreadTaskRunner>&
+  ControlTaskRunner() = 0;
 
   // Adds or removes a task observer from the scheduler. The observer will be
   // notified before and after every executed task. These functions can only be

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_helper.cc

@@ -40,8 +40,9 @@ MainThreadSchedulerHelper::DefaultMainThreadTaskQueue() {
   return default_task_queue_;
 }
 
-scoped_refptr<TaskQueue> MainThreadSchedulerHelper::DefaultTaskQueue() {
-  return default_task_queue_->GetTaskQueue();
+const scoped_refptr<base::SingleThreadTaskRunner>&
+MainThreadSchedulerHelper::DefaultTaskRunner() {
+  return default_task_queue_->GetTaskRunnerWithDefaultTaskType();
 }
 
 scoped_refptr<MainThreadTaskQueue>
@@ -49,8 +50,9 @@ MainThreadSchedulerHelper::ControlMainThreadTaskQueue() {
   return control_task_queue_;
 }
 
-scoped_refptr<TaskQueue> MainThreadSchedulerHelper::ControlTaskQueue() {
-  return control_task_queue_->GetTaskQueue();
+const scoped_refptr<base::SingleThreadTaskRunner>&
+MainThreadSchedulerHelper::ControlTaskRunner() {
+  return control_task_queue_->GetTaskRunnerWithDefaultTaskType();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_helper.h

@@ -32,9 +32,12 @@ class PLATFORM_EXPORT MainThreadSchedulerHelper : public SchedulerHelper {
   scoped_refptr<MainThreadTaskQueue> ControlMainThreadTaskQueue();
   scoped_refptr<base::SingleThreadTaskRunner> DeprecatedDefaultTaskRunner();
 
+  const scoped_refptr<base::SingleThreadTaskRunner>& DefaultTaskRunner()
+      override;
+  const scoped_refptr<base::SingleThreadTaskRunner>& ControlTaskRunner()
+      override;
+
  protected:
-  scoped_refptr<base::sequence_manager::TaskQueue> DefaultTaskQueue() override;
-  scoped_refptr<base::sequence_manager::TaskQueue> ControlTaskQueue() override;
   void ShutdownAllQueues() override;
 
  private:

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc

@@ -114,7 +114,6 @@ MainThreadTaskQueue::MainThreadTaskQueue(
       agent_group_scheduler_(params.agent_group_scheduler),
       frame_scheduler_(params.frame_scheduler) {
   task_queue_ = base::MakeRefCounted<TaskQueue>(std::move(impl), spec);
-  task_runner_ = task_queue_->task_runner();
   if (task_queue_->HasImpl() && spec.should_notify_observers) {
     // TaskQueueImpl may be null for tests.
     // TODO(scheduler-dev): Consider mapping directly to

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h

@@ -437,7 +437,7 @@ class PLATFORM_EXPORT MainThreadTaskQueue
   // the desired task type.
   const scoped_refptr<base::SingleThreadTaskRunner>&
   GetTaskRunnerWithDefaultTaskType() {
-    return task_runner_;
+    return task_queue_->task_runner();
   }
 
   base::WeakPtr<MainThreadTaskQueue> AsWeakPtr() {
@@ -470,7 +470,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
   void ClearReferencesToSchedulers();
 
   scoped_refptr<TaskQueue> task_queue_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   const QueueType queue_type_;
   const QueueTraits queue_traits_;

third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.cc

@@ -36,8 +36,9 @@ NonMainThreadSchedulerHelper::DefaultNonMainThreadTaskQueue() {
   return default_task_queue_;
 }
 
-scoped_refptr<TaskQueue> NonMainThreadSchedulerHelper::DefaultTaskQueue() {
-  return default_task_queue_;
+const scoped_refptr<base::SingleThreadTaskRunner>&
+NonMainThreadSchedulerHelper::DefaultTaskRunner() {
+  return default_task_queue_->GetTaskRunnerWithDefaultTaskType();
 }
 
 scoped_refptr<NonMainThreadTaskQueue>
@@ -45,8 +46,9 @@ NonMainThreadSchedulerHelper::ControlNonMainThreadTaskQueue() {
   return control_task_queue_;
 }
 
-scoped_refptr<TaskQueue> NonMainThreadSchedulerHelper::ControlTaskQueue() {
-  return control_task_queue_;
+const scoped_refptr<base::SingleThreadTaskRunner>&
+NonMainThreadSchedulerHelper::ControlTaskRunner() {
+  return control_task_queue_->GetTaskRunnerWithDefaultTaskType();
 }
 
 scoped_refptr<NonMainThreadTaskQueue>

third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.h

@@ -33,12 +33,12 @@ class PLATFORM_EXPORT NonMainThreadSchedulerHelper : public SchedulerHelper {
   scoped_refptr<NonMainThreadTaskQueue> DefaultNonMainThreadTaskQueue();
   scoped_refptr<NonMainThreadTaskQueue> ControlNonMainThreadTaskQueue();
 
-  scoped_refptr<base::SingleThreadTaskRunner> DefaultNonMainThreadTaskRunner();
-  scoped_refptr<base::SingleThreadTaskRunner> ControlNonMainThreadTaskRunner();
+  const scoped_refptr<base::SingleThreadTaskRunner>& DefaultTaskRunner()
+      override;
+  const scoped_refptr<base::SingleThreadTaskRunner>& ControlTaskRunner()
+      override;
 
  protected:
-  scoped_refptr<base::sequence_manager::TaskQueue> DefaultTaskQueue() override;
-  scoped_refptr<base::sequence_manager::TaskQueue> ControlTaskQueue() override;
   void ShutdownAllQueues() override;
 
  private:

third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.h

@@ -34,6 +34,15 @@ class PLATFORM_EXPORT NonMainThreadTaskQueue
     return TaskQueue::CreateTaskRunner(static_cast<int>(task_type));
   }
 
+  // This method returns the default task runner with task type kTaskTypeNone
+  // and is mostly used for tests. For most use cases, you'll want a more
+  // specific task runner and should use the 'CreateTaskRunner' method and pass
+  // the desired task type.
+  const scoped_refptr<base::SingleThreadTaskRunner>&
+  GetTaskRunnerWithDefaultTaskType() const {
+    return task_runner();
+  }
+
  private:
   // Not owned.
   NonMainThreadSchedulerImpl* non_main_thread_scheduler_;