Prevent redundant DoWorks due to canceled delayed tasks (v2)

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/trace_event/blame_context.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/time_domain.h"
@@ skipping 197 matching lines @@
     base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueLocked(
         Task(from_here, task, time_domain_delayed_run_time, sequence_number,
              task_type != TaskType::NON_NESTABLE));
   }
   return true;
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
     Task pending_task, base::TimeTicks now) {
+  base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
   main_thread_only().task_queue_manager->DidQueueTask(pending_task);
+  main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
 
-  // Schedule a later call to MoveReadyDelayedTasksToDelayedWorkQueue.
-  base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
-  main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
-  main_thread_only().time_domain->ScheduleDelayedWork(this, delayed_run_time,
-                                                      now);
+  // If |pending_task| is at the head of the queue, then make sure a wakeup
+  // is requested.
+  if (main_thread_only().delayed_incoming_queue.top().delayed_run_time ==
+      delayed_run_time) {
+    main_thread_only().time_domain->ScheduleDelayedWork(
+        this, pending_task.delayed_run_time, 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();
   PushOntoImmediateIncomingQueueLocked(
      FROM_HERE,
      base::Bind(&TaskQueueImpl::ScheduleDelayedWorkTask, this,
                 base::Passed(&pending_task)),
      base::TimeTicks(),
      thread_hop_task_sequence_number,
      false);
 }
 
+void TaskQueueImpl::ScheduleDelayedWorkTask(Task pending_task) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  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);
+  } 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,
-         const base::Closure& task,
-         base::TimeTicks desired_run_time,
-         EnqueueOrder sequence_number,
-         bool nestable) {
+    const tracked_objects::Location& posted_from,
+    const base::Closure& task,
+    base::TimeTicks desired_run_time,
+    EnqueueOrder sequence_number,
+    bool nestable) {
   if (any_thread().immediate_incoming_queue.empty())
     any_thread().time_domain->RegisterAsUpdatableTaskQueue(this);
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
     // There's no point posting a DoWork for a disabled queue, however we can
     // only tell if it's disabled from the main thread.
     if (base::PlatformThread::CurrentId() == thread_id_) {
       if (main_thread_only().is_enabled && !BlockedByFenceLocked())
         any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     } else {
       any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     }
   }
   any_thread().immediate_incoming_queue.emplace(
       posted_from, task, desired_run_time, sequence_number, nestable, sequence_number);
   any_thread().task_queue_manager->DidQueueTask( any_thread().immediate_incoming_queue.back());
   TraceQueueSize(true);
 }
 
-void TaskQueueImpl::ScheduleDelayedWorkTask(Task pending_task) {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
-  base::TimeTicks time_domain_now = main_thread_only().time_domain->Now();
-  // Make sure |delayed_run_time| isn't in the past.
-  if (delayed_run_time < time_domain_now) {
-    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);
-    MoveReadyDelayedTasksToDelayedWorkQueue(&lazy_now);
-  } else {
-    main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
-    main_thread_only().time_domain->ScheduleDelayedWork(
-        this, delayed_run_time, main_thread_only().time_domain->Now());
-  }
-  TraceQueueSize(false);
-}
-
 void TaskQueueImpl::SetQueueEnabled(bool enabled) {
   if (main_thread_only().is_enabled == enabled)
     return;
   main_thread_only().is_enabled = enabled;
   if (!main_thread_only().task_queue_manager)
     return;
   if (enabled) {
     // Note it's the job of the selector to tell the TaskQueueManager if
     // a DoWork needs posting.
     main_thread_only().task_queue_manager->selector_.EnableQueue(this);
@@ skipping 30 matching lines @@
       main_thread_only().delayed_incoming_queue.top().delayed_run_time <=
           main_thread_only().time_domain->CreateLazyNow().Now()) {
     return true;
   }
 
   // Finally tasks on |immediate_incoming_queue| count as immediate work.
   base::AutoLock lock(any_thread_lock_);
   return !any_thread().immediate_incoming_queue.empty();
 }
 
-void TaskQueueImpl::MoveReadyDelayedTasksToDelayedWorkQueue(LazyNow* lazy_now) {
+void TaskQueueImpl::WakeUpForDelayedWork(LazyNow* lazy_now) {
   // Enqueue all delayed tasks that should be running now, skipping any that
   // have been canceled.
   while (!main_thread_only().delayed_incoming_queue.empty()) {
-    // TODO(alexclarke): Use extract() when C++17 is allowed.
     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()) {
+    main_thread_only().time_domain->ScheduleDelayedWork(
+        this, main_thread_only().delayed_incoming_queue.top().delayed_run_time,
+        lazy_now->Now());
+  }
 }
 
 bool TaskQueueImpl::MaybeUpdateImmediateWorkQueues() {
   if (!main_thread_only().task_queue_manager)
     return false;
 
   if (!main_thread_only().immediate_work_queue->Empty())
     return true;
 
   base::AutoLock lock(any_thread_lock_);
@@ skipping 80 matching lines @@
                     main_thread_only().immediate_work_queue->Size());
   state->SetInteger("delayed_work_queue_size",
                     main_thread_only().delayed_work_queue->Size());
   if (!main_thread_only().delayed_incoming_queue.empty()) {
     base::TimeDelta delay_to_next_task =
         (main_thread_only().delayed_incoming_queue.top().delayed_run_time -
          main_thread_only().time_domain->CreateLazyNow().Now());
     state->SetDouble("delay_to_next_task_ms",
                      delay_to_next_task.InMillisecondsF());
   }
+  if (main_thread_only().current_fence)
+    state->SetInteger("current_fence", main_thread_only().current_fence);
   if (verbose_tracing_enabled) {
     state->BeginArray("immediate_incoming_queue");
     QueueAsValueInto(any_thread().immediate_incoming_queue, state);
     state->EndArray();
     state->BeginArray("delayed_work_queue");
     main_thread_only().delayed_work_queue->AsValueInto(state);
     state->EndArray();
     state->BeginArray("immediate_work_queue");
     main_thread_only().immediate_work_queue->AsValueInto(state);
     state->EndArray();
@@ skipping 205 matching lines @@
   state->SetBoolean("is_cancelled", task.task.IsCancelled());
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink