scheduler: Ensure consistent delayed task ordering between task 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 264 matching lines @@
   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 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.
   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);
 }
 
 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 11 matching lines @@
   base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
   base::TimeTicks time_domain_now = main_thread_only().time_domain->Now();
   if (delayed_run_time <= time_domain_now) {
     // If |delayed_run_time| is in the past then push it onto the work queue
     // immediately. To ensure the right task ordering we need to temporarily
     // push it onto the |delayed_incoming_queue|.
     delayed_run_time = time_domain_now;
     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),
                                                time_domain_now);
   }
   TraceQueueSize(false);
 }
 
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
     const tracked_objects::Location& posted_from,
@@ skipping 78 matching lines @@
 }
 
 base::Optional<base::TimeTicks> TaskQueueImpl::GetNextScheduledWakeUp() {
   // Note we don't scheduled a wakeup for disabled queues.
   if (main_thread_only().delayed_incoming_queue.empty() || !IsQueueEnabled())
     return base::nullopt;
 
   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()) {
     Task& task =
         const_cast<Task&>(main_thread_only().delayed_incoming_queue.top());
     if (task.task.IsCancelled()) {
       main_thread_only().delayed_incoming_queue.pop();
       continue;
     }
     if (task.delayed_run_time > lazy_now->Now())
       break;
     task.set_enqueue_order(
         main_thread_only().task_queue_manager->GetNextSequenceNumber());
     main_thread_only().delayed_work_queue->Push(std::move(task));
     main_thread_only().delayed_incoming_queue.pop();
   }
 
   // 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 {
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(disabled_by_default_tracing_category_,
                                      &is_tracing);
   if (!is_tracing)
     return;
 
   // It's only safe to access the work queues from the main thread.
@@ skipping 130 matching lines @@
     any_thread().time_domain = time_domain;
   }
 
   main_thread_only().time_domain->UnregisterQueue(this);
   main_thread_only().time_domain = time_domain;
   time_domain->RegisterQueue(this);
 
   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());
   }
 }
 
 TimeDomain* TaskQueueImpl::GetTimeDomain() const {
   if (base::PlatformThread::CurrentId() == thread_id_)
     return main_thread_only().time_domain;
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().time_domain;
@@ skipping 210 matching lines @@
       immediate_queues_empty = any_thread().immediate_incoming_queue.empty();
     }
     // Avoid holding the lock while we fire the notification.
     if (!immediate_queues_empty)
       main_thread_only().time_domain->OnQueueHasImmediateWork(this);
 
     if (!main_thread_only().delayed_incoming_queue.empty()) {
       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
     // a DoWork if needed.
     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);
   }
@@ skipping 27 matching lines @@
 
   // Re-schedule delayed call to WakeUpForDelayedWork if needed.
   if (main_thread_only().delayed_incoming_queue.empty()) {
     main_thread_only().time_domain->CancelDelayedWork(this);
   } else if (first_task_runtime !=
              main_thread_only().delayed_incoming_queue.top().delayed_run_time) {
     if (IsQueueEnabled()) {
       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());
     }
   }
 }
 
 void TaskQueueImpl::PushImmediateIncomingTaskForTest(
     TaskQueueImpl::Task&& task) {
   base::AutoLock lock(any_thread_lock_);
   any_thread().immediate_incoming_queue.push_back(std::move(task));
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink