[scheduler] Fix bug in task queue throttler

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 82 matching lines @@
                                                   TaskQueue* queue) {
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       task_queue_throttler_->queue_details_.insert(
           std::make_pair(queue, Metadata(0, queue->IsQueueEnabled())));
   Metadata& metadata = insert_result.first->second;
   DCHECK(!metadata.time_budget_pool);
   metadata.time_budget_pool = this;
 
   associated_task_queues_.insert(queue);
 
-  if (!is_enabled_ || !metadata.IsThrottled())
+  if (!is_enabled_ || !task_queue_throttler_->IsThrottled(queue))
     return;
 
   queue->SetQueueEnabled(false);
 
   task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                 GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::TimeBudgetPool::RemoveQueue(base::TimeTicks now,
                                                      TaskQueue* queue) {
   auto find_it = task_queue_throttler_->queue_details_.find(queue);
   DCHECK(find_it != task_queue_throttler_->queue_details_.end() &&
          find_it->second.time_budget_pool == this);
   find_it->second.time_budget_pool = nullptr;
-  bool is_throttled = find_it->second.IsThrottled();
+  bool is_throttled = task_queue_throttler_->IsThrottled(queue);
 
   task_queue_throttler_->MaybeDeleteQueueMetadata(find_it);
   associated_task_queues_.erase(queue);
 
   if (!is_enabled_ || !is_throttled)
     return;
 
   task_queue_throttler_->MaybeSchedulePumpQueue(FROM_HERE, now, queue,
                                                 base::nullopt);
 }
@@ skipping 158 matching lines @@
       base::Bind(&TaskQueueThrottler::OnTimeDomainHasImmediateWork,
                  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_) {
-    if (map_entry.second.IsThrottled()) {
-      TaskQueue* task_queue = map_entry.first;
+    TaskQueue* task_queue = map_entry.first;
+    if (IsThrottled(task_queue)) {

[Sami, 2016/11/23 16:47:18]

Hmm, this could end badly if the throttler is shut down while throttling is
disabled, no?

[altimin, 2016/11/23 16:56:08]

If throttling is disabled then all queues are enabled and we don't have to do
anything during shutdown.

[Sami, 2016/11/23 17:00:59]

I see, okay.

       task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
       task_queue->RemoveFence();
     }
   }
 
   renderer_scheduler_->UnregisterTimeDomain(time_domain_.get());
 }
 
 void TaskQueueThrottler::SetQueueEnabled(TaskQueue* task_queue, bool enabled) {
   TaskQueueMap::iterator find_it = queue_details_.find(task_queue);
 
   if (find_it == queue_details_.end()) {
     task_queue->SetQueueEnabled(enabled);
     return;
   }
 
   find_it->second.enabled = enabled;
 
-  if (!find_it->second.IsThrottled()) {
+  if (!IsThrottled(task_queue)) {
     task_queue->SetQueueEnabled(enabled);
     return;
   }
 
   // We don't enable the queue here because it's throttled and there might be
   // tasks in it's work queue that would execute immediatly rather than after
   // PumpThrottledTasks runs.
   if (!enabled) {
     task_queue->SetQueueEnabled(false);
     MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue,
                            base::nullopt);
   }
 }
 
 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()));
+  std::pair<TaskQueueMap::iterator, bool> insert_result = queue_details_.insert(
+      std::make_pair(task_queue, Metadata(0 /* ref_count */,
+                                          task_queue->IsQueueEnabled())));
 
-  if (!insert_result.first->second.IsThrottled()) {
-    // The insert was successful so we need to throttle the queue.
-    insert_result.first->second.enabled = task_queue->IsQueueEnabled();
-
+  if (insert_result.first->second.throttling_ref_count == 0) {
     if (allow_throttling_) {
       task_queue->SetTimeDomain(time_domain_.get());
       task_queue->RemoveFence();
       task_queue->SetQueueEnabled(false);
 
       if (!task_queue->IsEmpty()) {
         if (task_queue->HasPendingImmediateWork()) {
           OnTimeDomainHasImmediateWork(task_queue);
         } else {
           OnTimeDomainHasDelayedWork(task_queue);
@@ skipping 22 matching lines @@
       task_queue->RemoveFence();
       task_queue->SetQueueEnabled(enabled);
     }
 
     TRACE_EVENT1(tracing_category_, "TaskQueueThrottler_TaskQueueUntrottled",
                  "task_queue", task_queue);
   }
 }
 
 bool TaskQueueThrottler::IsThrottled(TaskQueue* task_queue) const {
+  if (!allow_throttling_)
+    return false;
+
   auto find_it = queue_details_.find(task_queue);
   if (find_it == queue_details_.end())
     return false;
-  return find_it->second.IsThrottled();
+  return find_it->second.throttling_ref_count > 0;
 }
 
 void TaskQueueThrottler::UnregisterTaskQueue(TaskQueue* task_queue) {
   LazyNow lazy_now(tick_clock_);
   auto find_it = queue_details_.find(task_queue);
 
   if (find_it == queue_details_.end())
     return;
 
   if (find_it->second.time_budget_pool)
@@ skipping 33 matching lines @@
 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_) {
     TaskQueue* task_queue = map_entry.first;
     if (!map_entry.second.enabled || task_queue->IsEmpty() ||
-        !map_entry.second.IsThrottled())
+        !IsThrottled(task_queue))
       continue;
 
     // Don't enable queues whose budget pool doesn't allow them to run now.
     base::TimeTicks next_allowed_run_time =
         GetNextAllowedRunTime(lazy_now.Now(), task_queue);
     base::Optional<base::TimeTicks> next_desired_run_time =
         NextTaskRunTime(&lazy_now, task_queue);
 
     if (next_desired_run_time &&
         next_allowed_run_time > next_desired_run_time.value()) {
@@ skipping 135 matching lines @@
 
 base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(base::TimeTicks now,
                                                           TaskQueue* queue) {
   TimeBudgetPool* time_budget_pool = GetTimeBudgetPoolForQueue(queue);
   if (!time_budget_pool)
     return now;
   return std::max(now, time_budget_pool->GetNextAllowedRunTime());
 }
 
 void TaskQueueThrottler::MaybeDeleteQueueMetadata(TaskQueueMap::iterator it) {
-  if (!it->second.IsThrottled() && !it->second.time_budget_pool)
+  if (it->second.throttling_ref_count == 0 && !it->second.time_budget_pool)
     queue_details_.erase(it);
 }
 
 void TaskQueueThrottler::DisableThrottling() {
   if (!allow_throttling_)
     return;
 
   allow_throttling_ = false;
 
   for (const auto& map_entry : queue_details_) {
-    if (!map_entry.second.IsThrottled())
+    if (map_entry.second.throttling_ref_count == 0)
       continue;
 
     TaskQueue* queue = map_entry.first;
 
     queue->SetTimeDomain(renderer_scheduler_->GetActiveTimeDomain());
 
     queue->RemoveFence();
     queue->SetQueueEnabled(map_entry.second.enabled);
   }
 
   pump_throttled_tasks_closure_.Cancel();
   pending_pump_throttled_tasks_runtime_ = base::nullopt;
 }
 
 void TaskQueueThrottler::EnableThrottling() {
   if (allow_throttling_)
     return;
 
   allow_throttling_ = true;
 
   LazyNow lazy_now(tick_clock_);
 
   for (const auto& map_entry : queue_details_) {
-    if (!map_entry.second.IsThrottled())
+    if (map_entry.second.throttling_ref_count == 0)
       continue;
 
     TaskQueue* queue = map_entry.first;
 
     queue->SetQueueEnabled(false);
     queue->SetTimeDomain(time_domain_.get());
     MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
                            GetNextAllowedRunTime(lazy_now.Now(), queue));
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink