[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 54096186b21d12094fb3cf064c9a393e760bc7c6..036f77426d48699d34803775ba6c3455a6981f13 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->RemoveObserver(this);
   }
 
   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->AddObserver(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->RemoveObserver(this);
+
   MaybeDeleteQueueMetadata(iter);
 
   if (!allow_throttling_)
@@ -183,40 +187,28 @@ 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 deleted when unregistering task queue.

[Sami, 2017/04/04 19:07:30]

s/deleted/unregistered/?

[altimin, 2017/04/05 11:35:58]

Done.

 }
 
-void TaskQueueThrottler::OnTimeDomainHasImmediateWork(TaskQueue* queue) {
-  // Forward to the main thread if called from another thread
+void TaskQueueThrottler::OnQueueNextWakeupChanged(TaskQueue* queue,
+                                                  base::TimeTicks next_wakeup) {
   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_wakeup));
     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

[Sami, 2017/04/04 19:07:30]

Still relevant?

[altimin, 2017/04/05 11:35:58]

Done.

-  // 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_wakeup));
 }
 
 void TaskQueueThrottler::PumpThrottledTasks() {