scheduler: Ensure consistent delayed task ordering between task queues

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
index 742f845ba65bda18adc3e1ffe093d88567620901..d099c037933935a96697bf720f21f2d6ae8b2d8f 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
@@ -282,8 +282,8 @@ void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
   base::TimeTicks next_delayed_task =
       main_thread_only().delayed_incoming_queue.top().delayed_run_time;
   if (next_delayed_task == delayed_run_time && IsQueueEnabled()) {
-    main_thread_only().time_domain->ScheduleDelayedWork(this, delayed_run_time,
-                                                        now);
+    main_thread_only().time_domain->ScheduleDelayedWork(
+        this, delayed_run_time, pending_task.sequence_num, now);
   }
 
   TraceQueueSize(false);
@@ -315,7 +315,10 @@ void TaskQueueImpl::ScheduleDelayedWorkTask(Task pending_task) {
     pending_task.delayed_run_time = time_domain_now;
     main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
     LazyNow lazy_now(time_domain_now);
-    WakeUpForDelayedWork(&lazy_now);
+    base::TimeTicks ignored_next_wake_up_time;
+    int ignored_next_wake_up_sequence_num;
+    WakeUpForDelayedWork(&lazy_now, &ignored_next_wake_up_time,
+                         &ignored_next_wake_up_sequence_num);
   } else {
     // If |delayed_run_time| is in the future we can queue it as normal.
     PushOntoDelayedIncomingQueueFromMainThread(std::move(pending_task),
@@ -414,8 +417,9 @@ base::Optional<base::TimeTicks> TaskQueueImpl::GetNextScheduledWakeUp() {
   return main_thread_only().delayed_incoming_queue.top().delayed_run_time;
 }
 
-base::Optional<base::TimeTicks> TaskQueueImpl::WakeUpForDelayedWork(
-    LazyNow* lazy_now) {
+bool TaskQueueImpl::WakeUpForDelayedWork(LazyNow* lazy_now,
+                                         base::TimeTicks* out_next_wake_up_time,
+                                         int* out_next_wake_up_sequence_num) {
   // Enqueue all delayed tasks that should be running now, skipping any that
   // have been canceled.
   while (!main_thread_only().delayed_incoming_queue.empty()) {
@@ -434,10 +438,15 @@ base::Optional<base::TimeTicks> TaskQueueImpl::WakeUpForDelayedWork(
   }
 
   // Make sure the next wake up is scheduled.
-  if (!main_thread_only().delayed_incoming_queue.empty())
-    return main_thread_only().delayed_incoming_queue.top().delayed_run_time;
+  if (!main_thread_only().delayed_incoming_queue.empty()) {
+    *out_next_wake_up_time =
+        main_thread_only().delayed_incoming_queue.top().delayed_run_time;
+    *out_next_wake_up_sequence_num =
+        main_thread_only().delayed_incoming_queue.top().sequence_num;
+    return true;
+  }
 
-  return base::nullopt;
+  return false;
 }
 
 void TaskQueueImpl::TraceQueueSize(bool is_locked) const {
@@ -588,6 +597,7 @@ void TaskQueueImpl::SetTimeDomain(TimeDomain* time_domain) {
   if (IsQueueEnabled() && !main_thread_only().delayed_incoming_queue.empty()) {
     time_domain->ScheduleDelayedWork(
         this, main_thread_only().delayed_incoming_queue.top().delayed_run_time,
+        main_thread_only().delayed_incoming_queue.top().sequence_num,
         time_domain->Now());
   }
 }
@@ -818,6 +828,7 @@ void TaskQueueImpl::EnableOrDisableWithSelector(bool enable) {
       main_thread_only().time_domain->ScheduleDelayedWork(
           this,
           main_thread_only().delayed_incoming_queue.top().delayed_run_time,
+          main_thread_only().delayed_incoming_queue.top().sequence_num,
           main_thread_only().time_domain->Now());
     }
     // Note the selector calls TaskQueueManager::OnTaskQueueEnabled which posts
@@ -865,6 +876,7 @@ void TaskQueueImpl::SweepCanceledDelayedTasks(base::TimeTicks now) {
       main_thread_only().time_domain->ScheduleDelayedWork(
           this,
           main_thread_only().delayed_incoming_queue.top().delayed_run_time,
+          main_thread_only().delayed_incoming_queue.top().sequence_num,
           main_thread_only().time_domain->Now());
     }
   }