Reland: Explicitly track the scheduler task enqueueing order in a new field

components/scheduler/child/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 "components/scheduler/child/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 86 matching lines @@
 }
 
 void TaskQueueManager::UnregisterAsUpdatableTaskQueue(
     internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   updatable_queue_set_.erase(queue);
 }
 
 void TaskQueueManager::UpdateWorkQueues(
     bool should_trigger_wakeup,
-    const base::PendingTask* previous_task) {
+    const internal::TaskQueueImpl::Task* previous_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   internal::LazyNow lazy_now(this);
 
   // Insert any newly updatable queues into the updatable_queue_set_.
   {
     base::AutoLock lock(newly_updatable_lock_);
     while (!newly_updatable_.empty()) {
       updatable_queue_set_.insert(newly_updatable_.back());
       newly_updatable_.pop_back();
     }
   }
 
   auto iter = updatable_queue_set_.begin();
   while (iter != updatable_queue_set_.end()) {
     internal::TaskQueueImpl* queue = *iter++;
     // NOTE Update work queue may erase itself from |updatable_queue_set_|.
     // This is fine, erasing an element won't invalidate any interator, as long
     // as the iterator isn't the element being delated.
     if (queue->work_queue().empty())
         queue->UpdateWorkQueue(&lazy_now, should_trigger_wakeup, previous_task);
-    if (!queue->work_queue().empty()) {
-      // Currently we should not be getting tasks with delayed run times in any
-      // of the work queues.
-      DCHECK(queue->work_queue().front().delayed_run_time.is_null());
-    }
   }
 }
 
 void TaskQueueManager::MaybePostDoWorkOnMainRunner() {
   bool on_main_thread = main_task_runner_->BelongsToCurrentThread();
   if (on_main_thread) {
     // We only want one pending DoWork posted from the main thread, or we risk
     // an explosion of pending DoWorks which could starve out everything else.
     if (pending_dowork_count_ > 0) {
       return;
     }
     pending_dowork_count_++;
     main_task_runner_->PostTask(FROM_HERE, do_work_from_main_thread_closure_);
   } else {
     main_task_runner_->PostTask(FROM_HERE, do_work_from_other_thread_closure_);
   }
 }
 
 void TaskQueueManager::DoWork(bool posted_from_main_thread) {
   if (posted_from_main_thread) {
     pending_dowork_count_--;
     DCHECK_GE(pending_dowork_count_, 0);
   }
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // Pass false and nullptr to UpdateWorkQueues here to prevent waking up a
   // pump-after-wakeup queue.
   UpdateWorkQueues(false, nullptr);
 
-  base::PendingTask previous_task((tracked_objects::Location()),
-                                  (base::Closure()));
+  internal::TaskQueueImpl::Task previous_task;
   for (int i = 0; i < work_batch_size_; i++) {
     internal::TaskQueueImpl* queue;
     if (!SelectQueueToService(&queue))
       return;
     // Note that this function won't post another call to DoWork if one is
     // already pending, so it is safe to call it in a loop.
     MaybePostDoWorkOnMainRunner();
 
     if (ProcessTaskFromWorkQueue(queue, &previous_task))
       return;  // The TaskQueueManager got deleted, we must bail out.
@@ skipping 11 matching lines @@
 
 bool TaskQueueManager::SelectQueueToService(
     internal::TaskQueueImpl** out_queue) {
   bool should_run = selector_.SelectQueueToService(out_queue);
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       disabled_by_default_tracing_category_, "TaskQueueManager", this,
       AsValueWithSelectorResult(should_run, *out_queue));
   return should_run;
 }
 
-void TaskQueueManager::DidQueueTask(const base::PendingTask& pending_task) {
+void TaskQueueManager::DidQueueTask(
+    const internal::TaskQueueImpl::Task& pending_task) {
   task_annotator_.DidQueueTask("TaskQueueManager::PostTask", pending_task);
 }
 
 bool TaskQueueManager::ProcessTaskFromWorkQueue(
     internal::TaskQueueImpl* queue,
-    base::PendingTask* out_previous_task) {
+    internal::TaskQueueImpl::Task* out_previous_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<DeletionSentinel> protect(deletion_sentinel_);
-  base::PendingTask pending_task = queue->TakeTaskFromWorkQueue();
+  // TODO(alexclarke): consider std::move() when allowed.
+  internal::TaskQueueImpl::Task pending_task = queue->TakeTaskFromWorkQueue();
 
   if (queue->GetQuiescenceMonitored())
     task_was_run_on_quiescence_monitored_queue_ = true;
 
   if (!pending_task.nestable && main_task_runner_->IsNested()) {
     // Defer non-nestable work to the main task runner.  NOTE these tasks can be
     // arbitrarily delayed so the additional delay should not be a problem.
     main_task_runner_->PostNonNestableTask(pending_task.posted_from,
                                            pending_task.task);
   } else {
@@ skipping 94 matching lines @@
   state->EndArray();
   return state;
 }
 
 void TaskQueueManager::OnTaskQueueEnabled() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler