Implement WebFrameScheduler and WebPageScheduler

components/scheduler/child/scheduler_helper.cc

 // Copyright 2015 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/scheduler_helper.h"
 
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/child/scheduler_task_runner_delegate.h"
 #include "components/scheduler/child/task_queue_impl.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : main_task_runner_(main_task_runner),
       task_queue_manager_(
           new TaskQueueManager(main_task_runner,
                                disabled_by_default_tracing_category,
                                disabled_by_default_verbose_tracing_category)),
       control_task_runner_(NewTaskQueue(
           TaskQueue::Spec("control_tq")
-              .SetWakeupPolicy(
-                  TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES)
+              .SetWakeupPolicy(TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES)
               .SetShouldNotifyObservers(false))),
       control_after_wakeup_task_runner_(NewTaskQueue(
           TaskQueue::Spec("control_after_wakeup_tq")
               .SetPumpPolicy(TaskQueue::PumpPolicy::AFTER_WAKEUP)
-              .SetWakeupPolicy(
-                  TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES)
+              .SetWakeupPolicy(TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES)
               .SetShouldNotifyObservers(false))),
       default_task_runner_(NewTaskQueue(TaskQueue::Spec("default_tq")
                                             .SetShouldMonitorQuiescence(true))),
       time_source_(new base::DefaultTickClock),
+      queue_observer_(nullptr),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category) {
   control_task_runner_->SetQueuePriority(TaskQueue::CONTROL_PRIORITY);
   control_after_wakeup_task_runner_->SetQueuePriority(
       TaskQueue::CONTROL_PRIORITY);
 
   task_queue_manager_->SetWorkBatchSize(4);
 
   main_task_runner_->SetDefaultTaskRunner(default_task_runner_.get());
@@ skipping 68 matching lines @@
     task_queue_manager_->AddTaskObserver(task_observer);
 }
 
 void SchedulerHelper::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
+void SchedulerHelper::SetQueueObserver(Observer* observer) {
+  CheckOnValidThread();
+  queue_observer_ = observer;
+  if (task_queue_manager_)

[Sami, 2015/09/10 15:10:23]

I think DCHECKing that we still have a manager would lead to fewer surprises.

[alex clarke (OOO till 29th), 2015/09/10 15:56:24]

Done.

+    task_queue_manager_->SetQueueObserver(this);

[Sami, 2015/09/10 15:10:23]

Should probably remove this in the destructor.

[alex clarke (OOO till 29th), 2015/09/10 15:56:24]

Not sure that's worth doing since this class owns task_queue_manager_.  WDYT?

[Sami, 2015/09/11 11:34:43]

Ah right I didn't notice that. Usually I like to have explicit calls but this
works too.

+}
+
+void SchedulerHelper::OnUnregisterTaskQueue(
+    const scoped_refptr<internal::TaskQueueImpl>& queue) {
+  if (queue_observer_)
+    queue_observer_->OnUnregisterTaskQueue(queue);
+}
+
 }  // namespace scheduler