scheduler: Move the Blink scheduler into Blink

third_party/WebKit/Source/platform/scheduler/child/idle_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/idle_helper.h"
+#include "platform/scheduler/child/idle_helper.h"
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
-#include "components/scheduler/base/real_time_domain.h"
-#include "components/scheduler/base/task_queue.h"
-#include "components/scheduler/base/task_queue_manager.h"
-#include "components/scheduler/child/scheduler_helper.h"
-#include "components/scheduler/child/scheduler_tqm_delegate.h"
+#include "platform/scheduler/base/real_time_domain.h"
+#include "public/platform/scheduler/base/task_queue.h"
+#include "platform/scheduler/base/task_queue_manager.h"
+#include "platform/scheduler/child/scheduler_helper.h"
+#include "platform/scheduler/child/scheduler_tqm_delegate.h"
 
+namespace blink {
 namespace scheduler {
 
 IdleHelper::IdleHelper(
     SchedulerHelper* helper,
     Delegate* delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
     base::TimeDelta required_quiescence_duration_before_long_idle_period)
     : helper_(helper),
@@ skipping 24 matching lines @@
   idle_queue_->SetQueueEnabled(false);
   idle_queue_->SetQueuePriority(TaskQueue::BEST_EFFORT_PRIORITY);
 
   helper_->AddTaskObserver(this);
 }
 
 IdleHelper::~IdleHelper() {
   helper_->RemoveTaskObserver(this);
 }
 
-IdleHelper::Delegate::Delegate() {
-}
+IdleHelper::Delegate::Delegate() {}
 
-IdleHelper::Delegate::~Delegate() {
-}
+IdleHelper::Delegate::~Delegate() {}
 
 scoped_refptr<SingleThreadIdleTaskRunner> IdleHelper::IdleTaskRunner() {
   helper_->CheckOnValidThread();
   return idle_task_runner_;
 }
 
 IdleHelper::IdlePeriodState IdleHelper::ComputeNewLongIdlePeriodState(
     const base::TimeTicks now,
     base::TimeDelta* next_long_idle_period_delay_out) {
   helper_->CheckOnValidThread();
@@ skipping 115 matching lines @@
 
   // If we weren't already within an idle period then early-out.
   if (!IsInIdlePeriod(state_.idle_period_state()))
     return;
 
   idle_queue_->SetQueueEnabled(false);
   state_.UpdateState(IdlePeriodState::NOT_IN_IDLE_PERIOD, base::TimeTicks(),
                      base::TimeTicks());
 }
 
-void IdleHelper::WillProcessTask(const base::PendingTask& pending_task) {
-}
+void IdleHelper::WillProcessTask(const base::PendingTask& pending_task) {}
 
 void IdleHelper::DidProcessTask(const base::PendingTask& pending_task) {
   helper_->CheckOnValidThread();
   TRACE_EVENT0(disabled_by_default_tracing_category_, "DidProcessTask");
   if (IsInIdlePeriod(state_.idle_period_state()) &&
       state_.idle_period_state() !=
           IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED &&
       helper_->scheduler_tqm_delegate()->NowTicks() >=
           state_.idle_period_deadline()) {
     // If the idle period deadline has now been reached, either end the idle
@@ skipping 114 matching lines @@
                          const char* disabled_by_default_tracing_category,
                          const char* idle_period_tracing_name)
     : helper_(helper),
       delegate_(delegate),
       idle_period_state_(IdlePeriodState::NOT_IN_IDLE_PERIOD),
       idle_period_trace_event_started_(false),
       running_idle_task_for_tracing_(false),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
-      idle_period_tracing_name_(idle_period_tracing_name) {
-}
+      idle_period_tracing_name_(idle_period_tracing_name) {}
 
-IdleHelper::State::~State() {
-}
+IdleHelper::State::~State() {}
 
 IdleHelper::IdlePeriodState IdleHelper::State::idle_period_state() const {
   helper_->CheckOnValidThread();
   return idle_period_state_;
 }
 
 base::TimeTicks IdleHelper::State::idle_period_deadline() const {
   helper_->CheckOnValidThread();
   return idle_period_deadline_;
 }
 
 void IdleHelper::State::UpdateState(IdlePeriodState new_state,
                                     base::TimeTicks new_deadline,
                                     base::TimeTicks optional_now) {
   IdlePeriodState old_idle_period_state = idle_period_state_;
 
   helper_->CheckOnValidThread();
   if (new_state == idle_period_state_) {
     DCHECK_EQ(new_deadline, idle_period_deadline_);
     return;
   }
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
     base::TimeTicks now(optional_now.is_null()
                             ? helper_->scheduler_tqm_delegate()->NowTicks()
                             : optional_now);
-    TraceEventIdlePeriodStateChange(
-        new_state, running_idle_task_for_tracing_, idle_period_deadline_, now);
+    TraceEventIdlePeriodStateChange(new_state, running_idle_task_for_tracing_,
+                                    idle_period_deadline_, now);
   }
 
   idle_period_state_ = new_state;
   idle_period_deadline_ = new_deadline;
 
   // Inform the delegate if we are starting or ending an idle period.
   if (IsInIdlePeriod(new_state) && !IsInIdlePeriod(old_idle_period_state)) {
     delegate_->OnIdlePeriodStarted();
   } else if (!IsInIdlePeriod(new_state) &&
              IsInIdlePeriod(old_idle_period_state)) {
     delegate_->OnIdlePeriodEnded();
   }
 }
 
 void IdleHelper::State::TraceIdleIdleTaskStart() {
   helper_->CheckOnValidThread();
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
-    TraceEventIdlePeriodStateChange(
-        idle_period_state_, true, idle_period_deadline_,
-        base::TimeTicks::Now());
+    TraceEventIdlePeriodStateChange(idle_period_state_, true,
+                                    idle_period_deadline_,
+                                    base::TimeTicks::Now());
   }
 }
 
 void IdleHelper::State::TraceIdleIdleTaskEnd() {
   helper_->CheckOnValidThread();
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
-    TraceEventIdlePeriodStateChange(
-        idle_period_state_, false, idle_period_deadline_,
-        base::TimeTicks::Now());
+    TraceEventIdlePeriodStateChange(idle_period_state_, false,
+                                    idle_period_deadline_,
+                                    base::TimeTicks::Now());
   }
 }
 
 void IdleHelper::State::TraceEventIdlePeriodStateChange(
     IdlePeriodState new_state,
     bool new_running_idle_task,
     base::TimeTicks new_deadline,
     base::TimeTicks now) {
   TRACE_EVENT2(disabled_by_default_tracing_category_, "SetIdlePeriodState",
                "old_state",
                IdleHelper::IdlePeriodStateToString(idle_period_state_),
                "new_state", IdleHelper::IdlePeriodStateToString(new_state));
 
   if (idle_period_trace_event_started_ && running_idle_task_for_tracing_ &&
       !new_running_idle_task) {
     running_idle_task_for_tracing_ = false;
     if (!idle_period_deadline_.is_null() && now > idle_period_deadline_) {
       TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(
-          tracing_category_, idle_period_tracing_name_, this,
-          "DeadlineOverrun",
-          std::max(idle_period_deadline_,
-                   last_idle_task_trace_time_).ToInternalValue());
+          tracing_category_, idle_period_tracing_name_, this, "DeadlineOverrun",
+          std::max(idle_period_deadline_, last_idle_task_trace_time_)
+              .ToInternalValue());
     }
   }
 
   if (IsInIdlePeriod(new_state)) {
     if (!idle_period_trace_event_started_) {
       idle_period_trace_event_started_ = true;
-      TRACE_EVENT_ASYNC_BEGIN1(
-          tracing_category_, idle_period_tracing_name_, this,
-          "idle_period_length_ms", (new_deadline - now).ToInternalValue());
+      TRACE_EVENT_ASYNC_BEGIN1(tracing_category_, idle_period_tracing_name_,
+                               this, "idle_period_length_ms",
+                               (new_deadline - now).ToInternalValue());
     }
 
     if (new_running_idle_task) {
       last_idle_task_trace_time_ = now;
       running_idle_task_for_tracing_ = true;
-      TRACE_EVENT_ASYNC_STEP_INTO0(
-          tracing_category_, idle_period_tracing_name_, this,
-          "RunningIdleTask");
+      TRACE_EVENT_ASYNC_STEP_INTO0(tracing_category_, idle_period_tracing_name_,
+                                   this, "RunningIdleTask");
     } else if (new_state == IdlePeriodState::IN_SHORT_IDLE_PERIOD) {
-      TRACE_EVENT_ASYNC_STEP_INTO0(
-          tracing_category_, idle_period_tracing_name_, this,
-          "ShortIdlePeriod");
+      TRACE_EVENT_ASYNC_STEP_INTO0(tracing_category_, idle_period_tracing_name_,
+                                   this, "ShortIdlePeriod");
     } else if (IsInLongIdlePeriod(new_state) &&
-        new_state != IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
-      TRACE_EVENT_ASYNC_STEP_INTO0(
-          tracing_category_, idle_period_tracing_name_, this,
-          "LongIdlePeriod");
+               new_state != IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
+      TRACE_EVENT_ASYNC_STEP_INTO0(tracing_category_, idle_period_tracing_name_,
+                                   this, "LongIdlePeriod");
     } else if (new_state == IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
-      TRACE_EVENT_ASYNC_STEP_INTO0(
-          tracing_category_, idle_period_tracing_name_, this,
-          "LongIdlePeriodPaused");
+      TRACE_EVENT_ASYNC_STEP_INTO0(tracing_category_, idle_period_tracing_name_,
+                                   this, "LongIdlePeriodPaused");
     }
   } else if (idle_period_trace_event_started_) {
     idle_period_trace_event_started_ = false;
     TRACE_EVENT_ASYNC_END0(tracing_category_, idle_period_tracing_name_, this);
   }
 }
 
 // static
 const char* IdleHelper::IdlePeriodStateToString(
     IdlePeriodState idle_period_state) {
   switch (idle_period_state) {
     case IdlePeriodState::NOT_IN_IDLE_PERIOD:
       return "not_in_idle_period";
     case IdlePeriodState::IN_SHORT_IDLE_PERIOD:
       return "in_short_idle_period";
     case IdlePeriodState::IN_LONG_IDLE_PERIOD:
       return "in_long_idle_period";
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE:
       return "in_long_idle_period_with_max_deadline";
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
+}  // namespace blink