[scheduling] MainThreadTaskQueue has a TaskQueue instead of extending…

… TaskQueue.

This cl modifies MainThreadTaskQueue so that it owns a TaskQueue instead
of extending the base/sequence_manager/TaskQueue. This is the first
step in a TaskQueue ownership refactor described in this doc[1].

For now, MainThreadTaskQueue remains reference counted but this will
change in follow-up CLs and these queues will be uniquely owned instead.

[1] https://docs.google.com/document/d/1E--SK7wIuxwd6aGNiPc0uEU8jm1tvAvD1UrHyipn9sQ/edit?usp=sharing

Change-Id: I124103bde681fe1f55c87b701691b53116f626a1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2453591
Commit-Queue: Katie Dillon <kdillon@chromium.org>
Reviewed-by: Scott Haseley <shaseley@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Cr-Commit-Position: refs/heads/master@{#821307}

base/task/sequence_manager/task_queue.cc

@@ -349,5 +349,29 @@ std::unique_ptr<internal::TaskQueueImpl> TaskQueue::TakeTaskQueueImpl() {
   return std::move(impl_);
 }
 
+void TaskQueue::SetOnTaskStartedHandler(OnTaskStartedHandler handler) {
+  DCHECK_CALLED_ON_VALID_THREAD(associated_thread_->thread_checker);
+  if (!impl_)
+    return;
+
+  impl_->SetOnTaskStartedHandler(std::move(handler));
+}
+
+void TaskQueue::SetOnTaskCompletedHandler(OnTaskCompletedHandler handler) {
+  DCHECK_CALLED_ON_VALID_THREAD(associated_thread_->thread_checker);
+  if (!impl_)
+    return;
+
+  impl_->SetOnTaskCompletedHandler(std::move(handler));
+}
+
+void TaskQueue::SetOnTaskPostedHandler(OnTaskPostedHandler handler) {
+  DCHECK_CALLED_ON_VALID_THREAD(associated_thread_->thread_checker);
+  if (!impl_)
+    return;
+
+  impl_->SetOnTaskPostedHandler(std::move(handler));
+}
+
 }  // namespace sequence_manager
 }  // namespace base

base/task/sequence_manager/task_queue.h

@@ -342,6 +342,35 @@ class BASE_EXPORT TaskQueue : public RefCountedThreadSafe<TaskQueue> {
     return default_task_runner_;
   }
 
+  // Checks whether or not this TaskQueue has a TaskQueueImpl.
+  // TODO(kdillon): Remove this method when TaskQueueImpl inherits from
+  // TaskQueue and TaskQueue no longer owns an Impl.
+  bool HasImpl() { return !!impl_; }
+
+  using OnTaskStartedHandler =
+      RepeatingCallback<void(const Task&, const TaskQueue::TaskTiming&)>;
+  using OnTaskCompletedHandler =
+      RepeatingCallback<void(const Task&, TaskQueue::TaskTiming*, LazyNow*)>;
+  using OnTaskPostedHandler = RepeatingCallback<void(const Task&)>;
+
+  // Sets a handler to subscribe for notifications about started and completed
+  // tasks.
+  void SetOnTaskStartedHandler(OnTaskStartedHandler handler);
+
+  // |task_timing| may be passed in Running state and may not have the end time,
+  // so that the handler can run an additional task that is counted as a part of
+  // the main task.
+  // The handler can call TaskTiming::RecordTaskEnd, which is optional, to
+  // finalize the task, and use the resulting timing.
+  void SetOnTaskCompletedHandler(OnTaskCompletedHandler handler);
+
+  // Set a callback for adding custom functionality for processing posted task.
+  // Callback will be dispatched while holding a scheduler lock. As a result,
+  // callback should not call scheduler APIs directly, as this can lead to
+  // deadlocks. For example, PostTask should not be called directly and
+  // ScopedDeferTaskPosting::PostOrDefer should be used instead.
+  void SetOnTaskPostedHandler(OnTaskPostedHandler handler);
+
  protected:
   virtual ~TaskQueue();
 

third_party/blink/renderer/platform/scheduler/common/throttling/budget_pool_unittest.cc

@@ -129,7 +129,7 @@ TEST_F(BudgetPoolTest, WakeUpBudgetPool) {
       task_queue_throttler_->CreateWakeUpBudgetPool("test");
 
   scoped_refptr<base::sequence_manager::TaskQueue> queue =
-      scheduler_->NewThrottleableTaskQueueForTest(nullptr);
+      scheduler_->NewTaskQueueForTest();
 
   pool->SetWakeUpInterval(base::TimeTicks(), base::TimeDelta::FromSeconds(10));
   pool->SetWakeUpDuration(base::TimeDelta::FromMilliseconds(10));

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

@@ -94,7 +94,7 @@ void CompositorPriorityExperiments::OnWillBeginMainFrame() {
 void CompositorPriorityExperiments::OnTaskCompleted(
     MainThreadTaskQueue* queue,
     QueuePriority current_compositor_priority,
-    MainThreadTaskQueue::TaskTiming* task_timing) {
+    TaskQueue::TaskTiming* task_timing) {
   if (!queue)
     return;
 
@@ -182,7 +182,7 @@ CompositorPriorityExperiments::CompositorBudgetPoolController::
       "CompositorBudgetPool", this, tracing_controller, now));
   compositor_budget_pool_->SetMinBudgetLevelToRun(now, min_budget);
   compositor_budget_pool_->SetTimeBudgetRecoveryRate(now, budget_recovery_rate);
-  compositor_budget_pool_->AddQueue(now, compositor_queue);
+  compositor_budget_pool_->AddQueue(now, compositor_queue->GetTaskQueue());
 }
 
 CompositorPriorityExperiments::CompositorBudgetPoolController::
@@ -210,7 +210,7 @@ void CompositorPriorityExperiments::CompositorBudgetPoolController::
 
 void CompositorPriorityExperiments::CompositorBudgetPoolController::
     OnTaskCompleted(MainThreadTaskQueue* queue,
-                    MainThreadTaskQueue::TaskTiming* task_timing,
+                    TaskQueue::TaskTiming* task_timing,
                     bool have_seen_stop_signal) {
   if (have_seen_stop_signal) {
     compositor_budget_pool_->RecordTaskRunTime(

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

@@ -46,7 +46,7 @@ class PLATFORM_EXPORT CompositorPriorityExperiments {
 
   void OnTaskCompleted(MainThreadTaskQueue* queue,
                        QueuePriority current_priority,
-                       MainThreadTaskQueue::TaskTiming* task_timing);
+                       TaskQueue::TaskTiming* task_timing);
 
   QueuePriority GetAlternatingPriority() const {
     return alternating_compositor_priority_;
@@ -78,7 +78,7 @@ class PLATFORM_EXPORT CompositorPriorityExperiments {
     void UpdateCompositorBudgetState(base::TimeTicks now);
 
     void OnTaskCompleted(MainThreadTaskQueue* queue,
-                         MainThreadTaskQueue::TaskTiming* task_timing,
+                         TaskQueue::TaskTiming* task_timing,
                          bool have_seen_stop_signal);
 
     // Unimplemented methods.

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

@@ -32,7 +32,7 @@ class PLATFORM_EXPORT FindInPageBudgetPoolController
   ~FindInPageBudgetPoolController() override;
 
   void OnTaskCompleted(MainThreadTaskQueue* queue,
-                       MainThreadTaskQueue::TaskTiming* task_timing);
+                       TaskQueue::TaskTiming* task_timing);
 
   QueuePriority CurrentTaskPriority() { return task_priority_; }
 

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

@@ -81,7 +81,8 @@ void UpdatePriority(MainThreadTaskQueue* task_queue) {
 
   FrameSchedulerImpl* frame_scheduler = task_queue->GetFrameScheduler();
   DCHECK(frame_scheduler);
-  task_queue->SetQueuePriority(frame_scheduler->ComputePriority(task_queue));
+  task_queue->GetTaskQueue()->SetQueuePriority(
+      frame_scheduler->ComputePriority(task_queue));
 }
 
 }  // namespace
@@ -212,7 +213,7 @@ void CleanUpQueue(MainThreadTaskQueue* queue) {
 
   queue->DetachFromMainThreadScheduler();
   DCHECK(!queue->GetFrameScheduler());
-  queue->SetBlameContext(nullptr);
+  queue->GetTaskQueue()->SetBlameContext(nullptr);
 }
 
 }  // namespace
@@ -268,8 +269,10 @@ void FrameSchedulerImpl::RemoveThrottleableQueueFromBudgetPools(
                 main_thread_scheduler_->tick_clock())
           : base::sequence_manager::LazyNow(base::TimeTicks::Now());
 
-  if (cpu_time_budget_pool)
-    cpu_time_budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
+  if (cpu_time_budget_pool) {
+    cpu_time_budget_pool->RemoveQueue(lazy_now.Now(),
+                                      task_queue->GetTaskQueue());
+  }
 
   parent_page_scheduler_->RemoveQueueFromWakeUpBudgetPool(
       task_queue, frame_origin_type_, &lazy_now);
@@ -536,7 +539,7 @@ FrameSchedulerImpl::CreateResourceLoadingTaskRunnerHandleImpl() {
     scoped_refptr<MainThreadTaskQueue> task_queue =
         frame_task_queue_controller_->NewResourceLoadingTaskQueue();
     resource_loading_task_queue_priorities_.insert(
-        task_queue, task_queue->GetQueuePriority());
+        task_queue, task_queue->GetTaskQueue()->GetQueuePriority());
     return ResourceLoadingTaskRunnerHandleImpl::WrapTaskRunner(task_queue);
   }
 
@@ -840,8 +843,10 @@ void FrameSchedulerImpl::SetShouldReportPostedTasksWhenDisabled(
   for (const auto& task_queue_and_voter :
        frame_task_queue_controller_->GetAllTaskQueuesAndVoters()) {
     auto* task_queue = task_queue_and_voter.first;
-    if (task_queue->CanBeFrozen())
-      task_queue->SetShouldReportPostedTasksWhenDisabled(should_report);
+    if (task_queue->CanBeFrozen()) {
+      task_queue->GetTaskQueue()->SetShouldReportPostedTasksWhenDisabled(
+          should_report);
+    }
   }
 }
 
@@ -989,10 +994,10 @@ void FrameSchedulerImpl::UpdateTaskQueueThrottling(
     return;
   if (should_throttle) {
     main_thread_scheduler_->task_queue_throttler()->IncreaseThrottleRefCount(
-        task_queue);
+        task_queue->GetTaskQueue());
   } else {
     main_thread_scheduler_->task_queue_throttler()->DecreaseThrottleRefCount(
-        task_queue);
+        task_queue->GetTaskQueue());
   }
 }
 
@@ -1212,7 +1217,7 @@ void FrameSchedulerImpl::OnTaskQueueCreated(
     base::sequence_manager::TaskQueue::QueueEnabledVoter* voter) {
   DCHECK(parent_page_scheduler_);
 
-  task_queue->SetBlameContext(blame_context_);
+  task_queue->GetTaskQueue()->SetBlameContext(blame_context_);
   UpdateQueuePolicy(task_queue, voter);
 
   if (task_queue->CanBeThrottled()) {
@@ -1222,7 +1227,8 @@ void FrameSchedulerImpl::OnTaskQueueCreated(
     CPUTimeBudgetPool* cpu_time_budget_pool =
         parent_page_scheduler_->background_cpu_time_budget_pool();
     if (cpu_time_budget_pool) {
-      cpu_time_budget_pool->AddQueue(lazy_now.Now(), task_queue);
+      cpu_time_budget_pool->AddQueue(lazy_now.Now(),
+                                     task_queue->GetTaskQueue());
     }
 
     parent_page_scheduler_->AddQueueToWakeUpBudgetPool(