scheduler: Implement WebFrameScheduler and WebPageScheduler

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 16 matching lines @@
     const char* disabled_by_default_verbose_tracing_category)
     : main_task_runner_(main_task_runner),
       task_was_run_on_quiescence_monitored_queue_(false),
       pending_dowork_count_(0),
       work_batch_size_(1),
       time_source_(new base::DefaultTickClock),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
+      observer_(nullptr),
       deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(main_task_runner->RunsTasksOnCurrentThread());
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(disabled_by_default_tracing_category,
                                      "TaskQueueManager", this);
   selector_.SetTaskQueueSelectorObserver(this);
 
   do_work_from_main_thread_closure_ =
       base::Bind(&TaskQueueManager::DoWork, weak_factory_.GetWeakPtr(), true);
   do_work_from_other_thread_closure_ =
@@ skipping 19 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<internal::TaskQueueImpl> queue(
       make_scoped_refptr(new internal::TaskQueueImpl(
           this, spec, disabled_by_default_tracing_category_,
           disabled_by_default_verbose_tracing_category_)));
   queues_.insert(queue);
   selector_.AddQueue(queue.get());
   return queue;
 }
 
+void TaskQueueManager::SetObserver(Observer* observer) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  observer_ = observer;
+}
+
 void TaskQueueManager::UnregisterTaskQueue(
     scoped_refptr<internal::TaskQueueImpl> task_queue) {
   TRACE_EVENT1(disabled_by_default_tracing_category_,
               "TaskQueueManager::UnregisterTaskQueue",
               "queue_name", task_queue->GetName());
   DCHECK(main_thread_checker_.CalledOnValidThread());
+  if (observer_)
+    observer_->OnUnregisterTaskQueue(task_queue);

[rmcilroy, 2015/09/18 13:15:46]

Rather than adding this observer interface chain, would it not be simpler to
have RendererScheduler::UnregisterTaskRunner(...) and have the blink side call
that and it would call TaskQueueManager::UnregisterTaskQueue, then the observer
shouldn't be necessary since the scheduler is the entry point of this call?

[Sami, 2015/09/21 10:52:36]

That was the other alternative we thought about. The problem is that there's an
Unregister() on the TaskQueue which anyone could call. In order to hide that
method we'd need to have a forwarding class like RendererTaskQueue that
delegates everything to the real task. We decided the observer chain would be
the lesser evil but I think I could be convinced to have a forwarding class
instead. WDYT?

[rmcilroy, 2015/09/23 09:44:25]

Ahh, I didn't realize Unregister() was a TaskQueue method.

+
   // 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());
 
   // We need to remove |task_queue| from delayed_wakeup_map_ which is a little
   // awkward since it's keyed by time. O(n) running time.
   for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_map_.begin();
        iter != delayed_wakeup_map_.end();) {
@@ skipping 253 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(disabled_by_default_tracing_category_,
-               "Run Task From Queue", "queue", queue->GetName());
+               "TaskQueueManager::RunTask", "queue", queue->GetName());
   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;
 
   if (queue->GetShouldNotifyObservers()) {
     FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                       DidProcessTask(pending_task));
@@ skipping 80 matching lines @@
 }
 
 void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Only schedule DoWork if there's something to do.
   if (!queue->work_queue().empty())
     MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler