[scheduler] Add TaskQueue::Observer

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.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/renderer/task_queue_throttler.h"
 
 #include <cstdint>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 61 matching lines @@
 
 }  // namespace
 
 TaskQueueThrottler::TaskQueueThrottler(
     RendererSchedulerImpl* renderer_scheduler,
     const char* tracing_category)
     : task_runner_(renderer_scheduler->ControlTaskRunner()),
       renderer_scheduler_(renderer_scheduler),
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
-      time_domain_(new ThrottledTimeDomain(this, tracing_category)),
+      time_domain_(new ThrottledTimeDomain(tracing_category)),
       allow_throttling_(true),
       weak_factory_(this) {
   pump_throttled_tasks_closure_.Reset(base::Bind(
       &TaskQueueThrottler::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
   forward_immediate_work_callback_ =
-      base::Bind(&TaskQueueThrottler::OnTimeDomainHasImmediateWork,
+      base::Bind(&TaskQueueThrottler::OnQueueNextWakeUpChanged,
                  weak_factory_.GetWeakPtr());
 
   renderer_scheduler_->RegisterTimeDomain(time_domain_.get());
 }
 
 TaskQueueThrottler::~TaskQueueThrottler() {
   // It's possible for queues to be still throttled, so we need to tidy up
   // before unregistering the time domain.
   for (const TaskQueueMap::value_type& map_entry : queue_details_) {
     TaskQueue* task_queue = map_entry.first;
     if (IsThrottled(task_queue)) {
       task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
       task_queue->RemoveFence();
     }
+    if (map_entry.second.throttling_ref_count != 0)
+      task_queue->SetObserver(nullptr);
   }
 
   renderer_scheduler_->UnregisterTimeDomain(time_domain_.get());
 }
 
 void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
   DCHECK_NE(task_queue, task_runner_.get());
 
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       queue_details_.insert(std::make_pair(task_queue, Metadata()));
   insert_result.first->second.throttling_ref_count++;
 
   // If ref_count is 1, the task queue is newly throttled.
   if (insert_result.first->second.throttling_ref_count != 1)
     return;
 
   TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueThrottled",
                "task_queue", task_queue);
 
+  task_queue->SetObserver(this);
+
   if (!allow_throttling_)
     return;
 
   task_queue->SetTimeDomain(time_domain_.get());
   // This blocks any tasks from |task_queue| until PumpThrottledTasks() to
   // enforce task alignment.
   task_queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
 
   if (!task_queue->IsQueueEnabled())
     return;
 
   if (!task_queue->IsEmpty()) {
-    if (task_queue->HasPendingImmediateWork()) {
-      OnTimeDomainHasImmediateWork(task_queue);
-    } else {
-      OnTimeDomainHasDelayedWork(task_queue);
-    }
+    LazyNow lazy_now(tick_clock_);
+    OnQueueNextWakeUpChanged(task_queue,
+                             NextTaskRunTime(&lazy_now, task_queue).value());
   }
 }
 
 void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
   TaskQueueMap::iterator iter = queue_details_.find(task_queue);
 
   if (iter == queue_details_.end() ||
       --iter->second.throttling_ref_count != 0) {
     return;
   }
 
   TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUnthrottled",
                "task_queue", task_queue);
 
+  task_queue->SetObserver(nullptr);
+
   MaybeDeleteQueueMetadata(iter);
 
   if (!allow_throttling_)
     return;
 
   task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
   task_queue->RemoveFence();
 }
 
 bool TaskQueueThrottler::IsThrottled(TaskQueue* task_queue) const {
@@ skipping 13 matching lines @@
 
   LazyNow lazy_now(tick_clock_);
   std::unordered_set<BudgetPool*> budget_pools = find_it->second.budget_pools;
   for (BudgetPool* budget_pool : budget_pools) {
     budget_pool->RemoveQueue(lazy_now.Now(), task_queue);
   }
 
   // Iterator may have been deleted by BudgetPool::RemoveQueue, so don't
   // use it here.
   queue_details_.erase(task_queue);
+
+  // NOTE: Observer is automatically unregistered when unregistering task queue.
 }
 
-void TaskQueueThrottler::OnTimeDomainHasImmediateWork(TaskQueue* queue) {
-  // Forward to the main thread if called from another thread
+void TaskQueueThrottler::OnQueueNextWakeUpChanged(
+    TaskQueue* queue,
+    base::TimeTicks next_wake_up) {
   if (!task_runner_->RunsTasksOnCurrentThread()) {
-    task_runner_->PostTask(FROM_HERE,
-                           base::Bind(forward_immediate_work_callback_, queue));
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(forward_immediate_work_callback_, queue, next_wake_up));
     return;
   }
+
   TRACE_EVENT0(tracing_category_,
-               "TaskQueueThrottler::OnTimeDomainHasImmediateWork");
+               "TaskQueueThrottler::OnQueueNextWakeUpChanged");
 
   // We don't expect this to get called for disabled queues, but we can't DCHECK
   // because of the above thread hop.  Just bail out if the queue is disabled.
   if (!queue->IsQueueEnabled())
     return;
 
   base::TimeTicks now = tick_clock_->NowTicks();
-  base::TimeTicks next_allowed_run_time = GetNextAllowedRunTime(now, queue);
-  MaybeSchedulePumpThrottledTasks(FROM_HERE, now, next_allowed_run_time);
-}
-
-void TaskQueueThrottler::OnTimeDomainHasDelayedWork(TaskQueue* queue) {
-  TRACE_EVENT0(tracing_category_,
-               "TaskQueueThrottler::OnTimeDomainHasDelayedWork");
-  DCHECK(queue->IsQueueEnabled());
-  base::TimeTicks now = tick_clock_->NowTicks();
-  LazyNow lazy_now(now);
-
-  base::Optional<base::TimeTicks> next_scheduled_delayed_task =
-      NextTaskRunTime(&lazy_now, queue);
-  DCHECK(next_scheduled_delayed_task);
-  MaybeSchedulePumpThrottledTasks(FROM_HERE, now,
-                                  next_scheduled_delayed_task.value());
+  MaybeSchedulePumpThrottledTasks(
+      FROM_HERE, now,
+      std::max(GetNextAllowedRunTime(now, queue), next_wake_up));
 }
 
 void TaskQueueThrottler::PumpThrottledTasks() {
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler::PumpThrottledTasks");
   pending_pump_throttled_tasks_runtime_.reset();
 
   LazyNow lazy_now(tick_clock_);
   base::Optional<base::TimeTicks> next_scheduled_delayed_task;
 
   for (const TaskQueueMap::value_type& map_entry : queue_details_) {
@@ skipping 258 matching lines @@
     queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
     queue->SetTimeDomain(time_domain_.get());
     SchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue);
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink