Move blink scheduler implementation into a component

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 "content/child/scheduler/scheduler_helper.h"
+#include "components/scheduler/child/scheduler_helper.h"
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
-#include "content/child/scheduler/nestable_single_thread_task_runner.h"
-#include "content/child/scheduler/prioritizing_task_queue_selector.h"
-#include "content/child/scheduler/time_source.h"
+#include "components/scheduler/child/nestable_single_thread_task_runner.h"
+#include "components/scheduler/child/prioritizing_task_queue_selector.h"
+#include "components/scheduler/child/time_source.h"
 
-namespace content {
+namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     SchedulerHelperDelegate* scheduler_helper_delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
     size_t total_task_queue_count,
     base::TimeDelta required_quiescence_duration_before_long_idle_period)
     : task_queue_selector_(new PrioritizingTaskQueueSelector()),
@@ skipping 173 matching lines @@
     scheduler_helper_delegate_->IsNotQuiescent();
     return;
   }
 
   base::TimeTicks now(Now());
   base::TimeDelta next_long_idle_period_delay;
   IdlePeriodState new_idle_period_state =
       ComputeNewLongIdlePeriodState(now, &next_long_idle_period_delay);
   if (IsInIdlePeriod(new_idle_period_state)) {
     StartIdlePeriod(new_idle_period_state, now,
-                    now + next_long_idle_period_delay,
-                    false);
+                    now + next_long_idle_period_delay, false);
   }
 
   if (task_queue_manager_->IsQueueEmpty(QueueId::IDLE_TASK_QUEUE)) {
     // If there are no current idle tasks then post the call to initiate the
     // next idle for execution after wakeup (at which point after-wakeup idle
     // tasks might be eligible to run or more idle tasks posted).
     control_task_after_wakeup_runner_->PostDelayedTask(
         FROM_HERE,
         enable_next_long_idle_period_after_wakeup_closure_.callback(),
         next_long_idle_period_delay);
@@ skipping 38 matching lines @@
   DCHECK(IsInIdlePeriod(new_state));
 
   task_queue_selector_->EnableQueue(
       QueueId::IDLE_TASK_QUEUE,
       PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
   task_queue_manager_->PumpQueue(QueueId::IDLE_TASK_QUEUE);
   idle_period_state_ = new_state;
 
   idle_period_deadline_ = idle_period_deadline;
   if (post_end_idle_period) {
-    control_task_runner_->PostDelayedTask(
-        FROM_HERE,
-        end_idle_period_closure_.callback(),
-        idle_period_deadline_ - now);
+    control_task_runner_->PostDelayedTask(FROM_HERE,
+                                          end_idle_period_closure_.callback(),
+                                          idle_period_deadline_ - now);
   }
 }
 
 void SchedulerHelper::EndIdlePeriod() {
   CheckOnValidThread();
 
   end_idle_period_closure_.Cancel();
   enable_next_long_idle_period_closure_.Cancel();
   enable_next_long_idle_period_after_wakeup_closure_.Cancel();
 
@@ skipping 45 matching lines @@
 
 TaskQueueManager* SchedulerHelper::GetTaskQueueManagerForTesting() {
   CheckOnValidThread();
   return task_queue_manager_.get();
 }
 
 base::TimeTicks SchedulerHelper::Now() const {
   return time_source_->Now();
 }
 
-SchedulerHelper::IdlePeriodState
-SchedulerHelper::SchedulerIdlePeriodState() const {
+SchedulerHelper::IdlePeriodState SchedulerHelper::SchedulerIdlePeriodState()
+    const {
   return idle_period_state_;
 }
 
-PrioritizingTaskQueueSelector*
-SchedulerHelper::SchedulerTaskQueueSelector() const {
+PrioritizingTaskQueueSelector* SchedulerHelper::SchedulerTaskQueueSelector()
+    const {
   return task_queue_selector_.get();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> SchedulerHelper::TaskRunnerForQueue(
     size_t queue_index) const {
   CheckOnValidThread();
   return task_queue_manager_->TaskRunnerForQueue(queue_index);
 }
 
 void SchedulerHelper::SetQueueName(size_t queue_index, const char* name) {
@@ skipping 50 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);
 }
 
-}  // namespace content
+}  // namespace scheduler