[scheduler] Fix TaskQueueThrottler::SetQueueEnabled logic.

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 297 matching lines @@
       TaskQueue* task_queue = map_entry.first;
       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) {
+  // Both the TaskQueueThrottler and other systems want to enable and disable
+  // task queues. The policy we've adopted to deal with this is:
+  //
+  // A task queue is disabled if either the TaskQueueThrottler or the caller
+  // vote to disable it.
+  //
+  // A task queue is enabled only if both the TaskQueueThrottler and the caller
+  // vote to enable it.
   TaskQueueMap::iterator find_it = queue_details_.find(task_queue);
 
+  // If TaskQueueThrottler does not know about this queue, just call
+  // SetQueueEnabled directly.
   if (find_it == queue_details_.end()) {
     task_queue->SetQueueEnabled(enabled);
     return;
   }
 
+  // Remember the caller's preference so we know what to do when the task queue
+  // isn't throttled, or has budget to run.
   find_it->second.enabled = enabled;
 
+  // If this queue is not throttled by task queue throttler, just call
+  // SetQueueEnabled directly.
   if (!find_it->second.IsThrottled()) {

[Sami, 2016/11/24 16:05:49]

I think this needs a rebase; IsThrottled() isn't there anymore.

[altimin, 2016/11/24 16:09:36]

It does indeed, thanks. 

     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);
+  if (enabled) {
+    // If the task queue is throttled and we want to enable it, we can't
+    // do it immediately due to task alignment requirement and we should
+    // schedule a call to PumpThrottledTasks.
     MaybeSchedulePumpQueue(FROM_HERE, tick_clock_->NowTicks(), task_queue,
                            base::nullopt);
+  } else {
+    task_queue->SetQueueEnabled(false);
   }
 }
 
 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()));
 
   if (!insert_result.first->second.IsThrottled()) {
@@ skipping 313 matching lines @@
     queue->SetTimeDomain(time_domain_.get());
     MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
                            GetNextAllowedRunTime(lazy_now.Now(), queue));
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink