[Reland] Dont post delayed DoWork for disabled queues.

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.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/base/task_queue_impl.h"
 
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/blame_context.h"
@@ skipping 258 matching lines @@
   return true;
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
     Task pending_task, base::TimeTicks now) {
   base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
   main_thread_only().task_queue_manager->DidQueueTask(pending_task);
   main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
 
   // If |pending_task| is at the head of the queue, then make sure a wakeup
-  // is requested.
+  // is requested if the queue is enabled.  Note we still want to schedule a
+  // wakeup even if blocked by a fence, because we'd break throttling logic
+  // otherwise.
   if (main_thread_only().delayed_incoming_queue.top().delayed_run_time ==
-      delayed_run_time) {
+          delayed_run_time &&
+      IsQueueEnabled()) {
+    LazyNow lazy_now(now);
     main_thread_only().time_domain->ScheduleDelayedWork(
-        this, pending_task.delayed_run_time, now);
+        this, pending_task.delayed_run_time, &lazy_now);
   }
 
   TraceQueueSize(false);
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueLocked(Task pending_task) {
   any_thread().task_queue_manager->DidQueueTask(pending_task);
 
   int thread_hop_task_sequence_number =
       any_thread().task_queue_manager->GetNextSequenceNumber();
@@ skipping 515 matching lines @@
   bool is_enabled = IsQueueEnabled();
   if (was_enabled != is_enabled)
     EnableOrDisableWithSelector(is_enabled);
 }
 
 void TaskQueueImpl::EnableOrDisableWithSelector(bool enable) {
   if (!main_thread_only().task_queue_manager)
     return;
 
   if (enable) {
+    if (!main_thread_only().delayed_incoming_queue.empty()) {
+      LazyNow lazy_now = main_thread_only().time_domain->CreateLazyNow();
+      main_thread_only().time_domain->ScheduleDelayedWork(
+          this,
+          main_thread_only().delayed_incoming_queue.top().delayed_run_time,
+          &lazy_now);
+    }
     // Note it's the job of the selector to tell the TaskQueueManager if
-    // a DoWork needs posting.
+    // an immediate DoWork needs posting.
     main_thread_only().task_queue_manager->selector_.EnableQueue(this);
   } else {
+    if (!main_thread_only().delayed_incoming_queue.empty())
+      main_thread_only().time_domain->CancelDelayedWork(this);
     main_thread_only().task_queue_manager->selector_.DisableQueue(this);
   }
 }
 
 std::unique_ptr<TaskQueueImpl::QueueEnabledVoter>
 TaskQueueImpl::CreateQueueEnabledVoter() {
   main_thread_only().voter_refcount++;
   main_thread_only().is_enabled_refcount++;
   return base::MakeUnique<QueueEnabledVoterImpl>(this);
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink