scheduler: Ensure consistent delayed task ordering between task 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 76 matching lines @@
   bool NextScheduledTaskQueue(TaskQueue** out_task_queue) const;
 
   // 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,
+                           internal::TaskQueueImpl::DelayedWakeUp wake_up,
                            base::TimeTicks 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.
@@ skipping 22 matching lines @@
 
   // Call TaskQueueImpl::UpdateDelayedWorkQueue for each queue where the delay
   // has elapsed.
   void WakeupReadyDelayedQueues(LazyNow* lazy_now);
 
   size_t NumberOfScheduledWakeups() const {
     return delayed_wakeup_queue_.size();
   }
 
  private:
-  struct DelayedWakeup {
-    base::TimeTicks time;
+  struct ScheduledDelayedWakeUp {
+    internal::TaskQueueImpl::DelayedWakeUp wake_up;
     internal::TaskQueueImpl* queue;
 
-    bool operator<=(const DelayedWakeup& other) const {
-      if (time == other.time)
-        return queue <= other.queue;
-      return time < other.time;
+    bool operator<=(const ScheduledDelayedWakeUp& other) const {
+      return wake_up <= other.wake_up;
     }
 
     void SetHeapHandle(HeapHandle handle) {
       DCHECK(handle.IsValid());
       queue->set_heap_handle(handle);
     }
 
     void ClearHeapHandle() {
       DCHECK(queue->heap_handle().IsValid());
       queue->set_heap_handle(HeapHandle());
 
       DCHECK_NE(queue->scheduled_time_domain_wakeup(), base::TimeTicks());
       queue->set_scheduled_time_domain_wakeup(base::TimeTicks());
     }
   };
 
-  IntrusiveHeap<DelayedWakeup> delayed_wakeup_queue_;
+  IntrusiveHeap<ScheduledDelayedWakeUp> delayed_wakeup_queue_;
 
   Observer* const observer_;  // NOT OWNED.
 
   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_