[scheduler] Add TaskQueue::Observer

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
index 289893c700a258000988ebdc952d32ea22dbdff9..e9744e259d6f4b2ed021c828e9b90c8a4e1df9e1 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
@@ -79,13 +79,13 @@ TaskQueueThrottler::TaskQueueThrottler(
       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());
@@ -100,6 +100,8 @@ TaskQueueThrottler::~TaskQueueThrottler() {
       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());
@@ -119,6 +121,8 @@ void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
   TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueThrottled",
                "task_queue", task_queue);
 
+  task_queue->SetObserver(this);
+
   if (!allow_throttling_)
     return;
 
@@ -131,11 +135,9 @@ void TaskQueueThrottler::IncreaseThrottleRefCount(TaskQueue* task_queue) {
     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());
   }
 }
 
@@ -150,6 +152,8 @@ void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
   TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUnthrottled",
                "task_queue", task_queue);
 
+  task_queue->SetObserver(nullptr);
+
   MaybeDeleteQueueMetadata(iter);
 
   if (!allow_throttling_)
@@ -183,17 +187,22 @@ void TaskQueueThrottler::UnregisterTaskQueue(TaskQueue* 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.
@@ -201,22 +210,9 @@ void TaskQueueThrottler::OnTimeDomainHasImmediateWork(TaskQueue* queue) {
     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() {