[Reland] Dont post delayed DoWork for disabled queues.

third_party/WebKit/Source/platform/scheduler/base/time_domain.h

 // 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.
 
 #ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_
 
 #include <map>
 
 #include "base/callback.h"
@@ skipping 77 matching lines @@
 
   // Notifies the time domain observer (if any) that |queue| has incoming
   // immediate work.
   void OnQueueHasImmediateWork(internal::TaskQueueImpl* queue);
 
   // Schedules a call to TaskQueueImpl::WakeUpForDelayedWork when this
   // TimeDomain reaches |delayed_run_time|.  This supersedes any previously
   // registered wakeup for |queue|.
   void ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                            base::TimeTicks delayed_run_time,
-                           base::TimeTicks now);
+                           LazyNow* lazy_now);
 
   // Cancels any scheduled calls to TaskQueueImpl::WakeUpForDelayedWork for
   // |queue|.
   void CancelDelayedWork(internal::TaskQueueImpl* queue);
 
   // Registers the |queue|.
   void RegisterQueue(internal::TaskQueueImpl* queue);
 
   // Removes |queue| from all internal data structures.
   void UnregisterQueue(internal::TaskQueueImpl* queue);
 
   // Called by the TaskQueueManager when the TimeDomain is registered.
   virtual void OnRegisterWithTaskQueueManager(
       TaskQueueManager* task_queue_manager) = 0;
 
-  // The implementaion will secedule task processing to run with |delay| with
-  // respect to the TimeDomain's time source.  Always called on the main thread.
+  // The implementation will schedule task processing to run at time |run_time|
+  // within the TimeDomain's time line. Only called from the main thread.
   // NOTE this is only called by ScheduleDelayedWork if the scheduled runtime
   // is sooner than any previously sheduled work or if there is no other
   // scheduled work.
-  virtual void RequestWakeup(base::TimeTicks now, base::TimeDelta delay) = 0;
+  virtual void RequestWakeupAt(LazyNow* lazy_now, base::TimeTicks run_time) = 0;
+
+  // The implementation will cancel a wake up previously requested by
+  // RequestWakeupAt.  It's expected this will be a NOP for most virtual time
+  // domains.
+  virtual void CancelWakeupAt(base::TimeTicks run_time) = 0;
 
   // For implementation specific tracing.
   virtual void AsValueIntoInternal(
       base::trace_event::TracedValue* state) const = 0;
 
   // Call TaskQueueImpl::UpdateDelayedWorkQueue for each queue where the delay
   // has elapsed.
   void WakeupReadyDelayedQueues(LazyNow* lazy_now);
 
   size_t NumberOfScheduledWakeups() const {
@@ skipping 31 matching lines @@
 
   base::ThreadChecker main_thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(TimeDomain);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_