scheduler: Ensure consistent delayed task ordering between task queues

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.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_TASK_QUEUE_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 93 matching lines @@
     bool enqueue_order_set_;
 #endif
     // Similar to sequence number, but ultimately the |enqueue_order_| is what
     // the scheduler uses for task ordering. For immediate tasks |enqueue_order|
     // is set when posted, but for delayed tasks it's not defined until they are
     // enqueued on the |delayed_work_queue_|. This is because otherwise delayed
     // tasks could run before an immediate task posted after the delayed task.
     EnqueueOrder enqueue_order_;
   };
 
+  // Represents a time at which a task wants to run. Tasks scheduled for the
+  // same point in time will be ordered by their sequence numbers.
+  struct DelayedWakeUp {
+    base::TimeTicks time;
+    int sequence_num;
+
+    bool operator<=(const DelayedWakeUp& other) const {
+      if (time == other.time) {
+        DCHECK_NE(sequence_num, other.sequence_num);
+        return (sequence_num - other.sequence_num) < 0;
+      }
+      return time < other.time;
+    }
+  };
+
   // TaskQueue implementation.
   void UnregisterTaskQueue() override;
   bool RunsTasksOnCurrentThread() const override;
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override;
   std::unique_ptr<QueueEnabledVoter> CreateQueueEnabledVoter() override;
@@ skipping 46 matching lines @@
 
   const WorkQueue* immediate_work_queue() const {
     return main_thread_only().immediate_work_queue.get();
   }
 
   bool should_report_when_execution_blocked() const {
     return should_report_when_execution_blocked_;
   }
 
   // Enqueues any delayed tasks which should be run now on the
-  // |delayed_work_queue|. Returns the deadline if a subsequent wakeup is
-  // required. Must be called from the main thread.
-  base::Optional<base::TimeTicks> WakeUpForDelayedWork(LazyNow* lazy_now);
+  // |delayed_work_queue|. Returns the subsequent wakeup that is required, if
+  // any. Must be called from the main thread.
+  base::Optional<DelayedWakeUp> WakeUpForDelayedWork(LazyNow* lazy_now);
 
   base::TimeTicks scheduled_time_domain_wakeup() const {
     return main_thread_only().scheduled_time_domain_wakeup;
   }
 
   void set_scheduled_time_domain_wakeup(
       base::TimeTicks scheduled_time_domain_wakeup) {
     main_thread_only().scheduled_time_domain_wakeup =
         scheduled_time_domain_wakeup;
   }
@@ skipping 156 matching lines @@
   const bool should_report_when_execution_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_