[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 299 matching lines @@
       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 TaskQueueThrottler does not know about this queue, just call

[alex clarke (OOO till 29th), 2016/11/24 14:45:07]

Please add a comment in here saying:

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.

[altimin, 2016/11/24 15:00:55]

Done.

+  // SetQueueEnabled directly.
   if (find_it == queue_details_.end()) {
     task_queue->SetQueueEnabled(enabled);
     return;
   }
 
+  // Even when this queue is not throttled by task queue throttler, we

[alex clarke (OOO till 29th), 2016/11/24 14:45:07]

Maybe:

// Remember the caller's preference so we know what to do when the task queue
isn't throttled, or has budget to run.

[altimin, 2016/11/24 15:00:55]

Done.

+  // need to remember this setting for the times when it wil..
   find_it->second.enabled = enabled;
 
+  // If this queue is not throttled by task queue throttler, just call
+  // SetQueueEnabled directly.
   if (!find_it->second.IsThrottled()) {
     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);
+  // Task queue should be disabled here because it is throttled.
+  // If it is enabled, a call to PumpThrottledTask will be scheduled.
+  task_queue->SetQueueEnabled(false);

[alex clarke (OOO till 29th), 2016/11/24 14:45:07]

That doesn't look right to me.  I think it should be:

if (enabled) { 
  MaybeSchedulePumpQueue(...) 
} else { 
  task_queue->SetQueueEnabled(false);
}

[altimin, 2016/11/24 15:00:55]

That's intentional. Even when queue is enabled, we want to disable it at the
moment and enable in PumpThrottledTasks.

+  if (enabled) {
     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()));
@@ skipping 315 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