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),
+      queue_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::SetQueueObserver(Observer* observer) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  queue_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 (queue_observer_)
+    queue_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());
 
   // 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 242 matching lines @@
     main_task_runner_->PostNonNestableTask(pending_task.posted_from,
                                            pending_task.task);
   } else {
     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());
+    TRACE_EVENT2(disabled_by_default_tracing_category_,
+                 "TaskQueueManager::ProcessTaskFromWorkQueue", "queue",
+                 queue->GetName(), "origin", queue->GetOrigin());
     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 true;
 
     if (queue->GetShouldNotifyObservers()) {
       FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                         DidProcessTask(pending_task));
@@ skipping 81 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