Prepare for per-webview virtual time

components/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 "components/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 30 matching lines @@
     : real_time_domain_(new RealTimeDomain()),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
       work_batch_size_(1),
       task_count_(0),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
+      currently_executing_task_queue_(nullptr),
       observer_(nullptr),
       deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(delegate->RunsTasksOnCurrentThread());
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(disabled_by_default_tracing_category,
                                      "TaskQueueManager", this);
   selector_.SetTaskQueueSelectorObserver(this);
 
   from_main_thread_immediate_do_work_closure_ =
       base::Bind(&TaskQueueManager::DoWork, weak_factory_.GetWeakPtr(),
@@ skipping 150 matching lines @@
 
     // 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.
-  if (!selector_.EnabledWorkQueuesEmpty() || TryAdvanceTimeDomains()) {
+  if (!selector_.EnabledWorkQueuesEmpty() || TryAdvanceTimeDomains())
     MaybeScheduleImmediateWork(FROM_HERE);
-  } else {
-    // Tell the task runner we have no more work.
-    delegate_->OnNoMoreImmediateWork();
-  }
 }
 
 bool TaskQueueManager::TryAdvanceTimeDomains() {
   bool can_advance = false;
   for (TimeDomain* time_domain : time_domains_) {
     can_advance |= time_domain->MaybeAdvanceTime();
   }
   return can_advance;
 }
 
@@ skipping 36 matching lines @@
 
   TRACE_TASK_EXECUTION("TaskQueueManager::ProcessTaskFromWorkQueue",
                        pending_task);
   if (queue->GetShouldNotifyObservers()) {
     FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                       WillProcessTask(pending_task));
     queue->NotifyWillProcessTask(pending_task);
   }
   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 = pending_task;
   return ProcessTaskResult::EXECUTED;
 }
@@ skipping 99 matching lines @@
     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