Remove after wakeup logic and replace PumpTask with Fences

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

 // Copyright 2014 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_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 110 matching lines @@
   if (observer_)
     observer_->OnUnregisterTaskQueue(task_queue);
 
   // Add |task_queue| to |queues_to_delete_| so we can prevent it from being
   // freed while any of our structures hold hold a raw pointer to it.
   queues_to_delete_.insert(task_queue);
   queues_.erase(task_queue);
   selector_.RemoveQueue(task_queue.get());
 }
 
-void TaskQueueManager::UpdateWorkQueues(
-    bool should_trigger_wakeup,
-    const internal::TaskQueueImpl::Task* previous_task,
-    LazyNow lazy_now) {
+void TaskQueueManager::UpdateWorkQueues(LazyNow lazy_now) {
   TRACE_EVENT0(disabled_by_default_tracing_category_,
                "TaskQueueManager::UpdateWorkQueues");
 
   for (TimeDomain* time_domain : time_domains_) {
     LazyNow lazy_now_in_domain = time_domain == real_time_domain_.get()
                                      ? lazy_now
                                      : time_domain->CreateLazyNow();
-    time_domain->UpdateWorkQueues(should_trigger_wakeup, previous_task,
-                                  lazy_now_in_domain);
+    time_domain->UpdateWorkQueues(lazy_now_in_domain);
   }
 }
 
 void TaskQueueManager::MaybeScheduleImmediateWork(
     const tracked_objects::Location& from_here) {
   bool on_main_thread = delegate_->BelongsToCurrentThread();
   // De-duplicate DoWork posts.
   if (on_main_thread) {
     if (!main_thread_pending_wakeups_.insert(base::TimeTicks()).second) {
       return;
@@ skipping 30 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT1(tracing_category_, "TaskQueueManager::DoWork",
                "from_main_thread", from_main_thread);
   if (from_main_thread) {
     main_thread_pending_wakeups_.erase(run_time);
   } else {
     base::AutoLock lock(other_thread_lock_);
     other_thread_pending_wakeups_.erase(run_time);
   }
 
+  // TODO(alexclarke): Add a base::RunLoop observer and prevent
+  // MaybeScheduleImmediateWork posting MaybeScheduleImmediateWork while DoWork
+  // is running.  We'll need to post a DoWork on entering and leaving a nested
+  // run loop.
+
   if (!delegate_->IsNested())
     queues_to_delete_.clear();
 
   LazyNow lazy_now(real_time_domain()->CreateLazyNow());
   base::TimeTicks task_start_time;
 
   if (!delegate_->IsNested() && task_time_tracker_)
     task_start_time = lazy_now.Now();
 
-  // Pass false and nullptr to UpdateWorkQueues here to prevent waking up a
-  // pump-after-wakeup queue.
-  UpdateWorkQueues(false, nullptr, lazy_now);
-
-  internal::TaskQueueImpl::Task previous_task;
+  // TODO(alexclarke): Get rid of this and call once per loop iteration.
+  UpdateWorkQueues(lazy_now);
 
   for (int i = 0; i < work_batch_size_; i++) {
     internal::WorkQueue* work_queue;
-    if (!SelectWorkQueueToService(&work_queue)) {
+    if (!SelectWorkQueueToService(&work_queue))
       break;
-    }
 
-    bool should_trigger_wakeup = work_queue->task_queue()->wakeup_policy() ==
-                                 TaskQueue::WakeupPolicy::CAN_WAKE_OTHER_QUEUES;
-
-    switch (ProcessTaskFromWorkQueue(work_queue, &previous_task)) {
+    switch (ProcessTaskFromWorkQueue(work_queue)) {
       case ProcessTaskResult::DEFERRED:
-        // If a task was deferred, try again with another task. Note that this
-        // means deferred tasks (i.e. non-nestable tasks) will never trigger
-        // queue wake-ups.
+        // If a task was deferred, try again with another task.
         continue;
       case ProcessTaskResult::EXECUTED:
         break;
       case ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED:
         return;  // The TaskQueueManager got deleted, we must bail out.
     }
 
     lazy_now = real_time_domain()->CreateLazyNow();
     if (!delegate_->IsNested() && task_time_tracker_) {
       // Only report top level task durations.
       base::TimeTicks task_end_time = lazy_now.Now();
       task_time_tracker_->ReportTaskTime(task_start_time, task_end_time);
       task_start_time = task_end_time;
     }
 
     work_queue = nullptr;  // The queue may have been unregistered.
 
-    UpdateWorkQueues(should_trigger_wakeup, &previous_task, lazy_now);
+    UpdateWorkQueues(lazy_now);
 
     // Only run a single task per batch in nested run loops so that we can
     // properly exit the nested loop when someone calls RunLoop::Quit().
     if (delegate_->IsNested())
       break;
   }
 
   // TODO(alexclarke): Consider refactoring the above loop to terminate only
   // when there's no more work left to be done, rather than posting a
   // continuation task.
@@ skipping 17 matching lines @@
       AsValueWithSelectorResult(should_run, *out_work_queue));
   return should_run;
 }
 
 void TaskQueueManager::DidQueueTask(
     const internal::TaskQueueImpl::Task& pending_task) {
   task_annotator_.DidQueueTask("TaskQueueManager::PostTask", pending_task);
 }
 
 TaskQueueManager::ProcessTaskResult TaskQueueManager::ProcessTaskFromWorkQueue(
-    internal::WorkQueue* work_queue,
-    internal::TaskQueueImpl::Task* out_previous_task) {
+    internal::WorkQueue* work_queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<DeletionSentinel> protect(deletion_sentinel_);
   internal::TaskQueueImpl* queue = work_queue->task_queue();
 
   if (queue->GetQuiescenceMonitored())
     task_was_run_on_quiescence_monitored_queue_ = true;
 
   internal::TaskQueueImpl::Task pending_task =
       work_queue->TakeTaskFromWorkQueue();
   if (!pending_task.nestable && delegate_->IsNested()) {
@@ skipping 16 matching lines @@
   }
   TRACE_EVENT1(tracing_category_, "TaskQueueManager::RunTask", "queue",
                queue->GetName());
   // NOTE when TaskQueues get unregistered a reference ends up getting retained
   // by |queues_to_delete_| which is cleared at the top of |DoWork|. This means
   // we are OK to use raw pointers here.
   internal::TaskQueueImpl* prev_executing_task_queue =
       currently_executing_task_queue_;
   currently_executing_task_queue_ = queue;
   task_annotator_.RunTask("TaskQueueManager::PostTask", pending_task);
-
   // Detect if the TaskQueueManager just got deleted.  If this happens we must
   // not access any member variables after this point.
   if (protect->HasOneRef())
     return ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED;
 
   currently_executing_task_queue_ = prev_executing_task_queue;
 
   if (queue->GetShouldNotifyObservers()) {
     FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                       DidProcessTask(pending_task));
     queue->NotifyDidProcessTask(pending_task);
   }
 
-  pending_task.task.Reset();
-  *out_previous_task = std::move(pending_task);
   return ProcessTaskResult::EXECUTED;
 }
 
 void TaskQueueManager::MaybeRecordTaskDelayHistograms(
     const internal::TaskQueueImpl::Task& pending_task,
     const internal::TaskQueueImpl* queue) {
   if ((task_count_++ % kRecordRecordTaskDelayHistogramsEveryNTasks) != 0)
     return;
 
-  // Record delayed task lateness and immediate task queueing durations, but
-  // only for auto-pumped queues.  Manually pumped and after wakeup queues can
-  // have arbitarially large delayes, which would cloud any analysis.
-  if (queue->GetPumpPolicy() == TaskQueue::PumpPolicy::AUTO) {
-    if (!pending_task.delayed_run_time.is_null()) {
-      RecordDelayedTaskLateness(delegate_->NowTicks() -
-                                pending_task.delayed_run_time);
-    } else if (!pending_task.time_posted.is_null()) {
-      RecordImmediateTaskQueueingDuration(tracked_objects::TrackedTime::Now() -
-                                          pending_task.time_posted);
-    }
+  // Record delayed task lateness and immediate task queuing durations.
+  if (!pending_task.delayed_run_time.is_null()) {
+    RecordDelayedTaskLateness(delegate_->NowTicks() -
+                              pending_task.delayed_run_time);
+  } else if (!pending_task.time_posted.is_null()) {
+    RecordImmediateTaskQueueingDuration(tracked_objects::TrackedTime::Now() -
+                                        pending_task.time_posted);
   }
 }
 
 bool TaskQueueManager::RunsTasksOnCurrentThread() const {
   return delegate_->RunsTasksOnCurrentThread();
 }
 
 void TaskQueueManager::SetWorkBatchSize(int work_batch_size) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_GE(work_batch_size, 1);
@@ skipping 54 matching lines @@
   state->BeginArray("time_domains");
   for (auto* time_domain : time_domains_)
     time_domain->AsValueInto(state.get());
   state->EndArray();
   return std::move(state);
 }
 
 void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Only schedule DoWork if there's something to do.
-  if (!queue->immediate_work_queue()->Empty() ||
-      !queue->delayed_work_queue()->Empty()) {
+  if (queue->HasPendingImmediateWork())
     MaybeScheduleImmediateWork(FROM_HERE);
-  }
 }
 
 void TaskQueueManager::OnTriedToSelectBlockedWorkQueue(
     internal::WorkQueue* work_queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!work_queue->Empty());
   if (observer_) {
     observer_->OnTriedToExecuteBlockedTask(*work_queue->task_queue(),
                                            *work_queue->GetFrontTask());
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink