scheduler: Implement WebFrameScheduler and WebPageScheduler

components/scheduler/child/task_queue_manager.cc

Index: components/scheduler/child/task_queue_manager.cc
diff --git a/components/scheduler/child/task_queue_manager.cc b/components/scheduler/child/task_queue_manager.cc
index bf1e1565c3be775581bd9f9475a8375f85a2d3d1..a0e3c3affa73d552c7d58937891903206f4008b0 100644
--- a/components/scheduler/child/task_queue_manager.cc
+++ b/components/scheduler/child/task_queue_manager.cc
@@ -34,6 +34,7 @@ TaskQueueManager::TaskQueueManager(
           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());
@@ -73,12 +74,20 @@ scoped_refptr<internal::TaskQueueImpl> TaskQueueManager::NewTaskQueue(
   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);
@@ -352,7 +361,7 @@ TaskQueueManager::ProcessTaskResult TaskQueueManager::ProcessTaskFromWorkQueue(
     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