scheduler: Move the Blink scheduler into Blink

third_party/WebKit/Source/platform/scheduler/renderer/throttling_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/renderer/throttling_helper.h"
+#include "platform/scheduler/renderer/throttling_helper.h"
 
 #include "base/logging.h"
-#include "components/scheduler/base/real_time_domain.h"
-#include "components/scheduler/child/scheduler_tqm_delegate.h"
-#include "components/scheduler/renderer/renderer_scheduler_impl.h"
-#include "components/scheduler/renderer/throttled_time_domain.h"
-#include "components/scheduler/renderer/web_frame_scheduler_impl.h"
-#include "third_party/WebKit/public/platform/WebFrameScheduler.h"
+#include "platform/scheduler/base/real_time_domain.h"
+#include "platform/scheduler/child/scheduler_tqm_delegate.h"
+#include "platform/scheduler/renderer/renderer_scheduler_impl.h"
+#include "platform/scheduler/renderer/throttled_time_domain.h"
+#include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
+#include "public/platform/WebFrameScheduler.h"
 
+namespace blink {
 namespace scheduler {
 
 ThrottlingHelper::ThrottlingHelper(RendererSchedulerImpl* renderer_scheduler,
                                    const char* tracing_category)
     : task_runner_(renderer_scheduler->ControlTaskRunner()),
       renderer_scheduler_(renderer_scheduler),
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
       time_domain_(new ThrottledTimeDomain(this, tick_clock_)),
       weak_factory_(this) {
@@ skipping 129 matching lines @@
     MaybeSchedulePumpThrottledTasksLocked(FROM_HERE, now,
                                           next_scheduled_delayed_task);
   }
 }
 
 /* static */
 base::TimeTicks ThrottlingHelper::ThrottledRunTime(
     base::TimeTicks unthrottled_runtime) {
   const base::TimeDelta one_second = base::TimeDelta::FromSeconds(1);
   return unthrottled_runtime + one_second -
-      ((unthrottled_runtime - base::TimeTicks()) % one_second);
+         ((unthrottled_runtime - base::TimeTicks()) % one_second);
 }
 
 void ThrottlingHelper::MaybeSchedulePumpThrottledTasksLocked(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     base::TimeTicks unthrottled_runtime) {
   base::TimeTicks throttled_runtime =
       ThrottledRunTime(std::max(now, unthrottled_runtime));
   // If there is a pending call to PumpThrottledTasks and it's sooner than
   // |unthrottled_runtime| then return.
   if (!pending_pump_throttled_tasks_runtime_.is_null() &&
       throttled_runtime >= pending_pump_throttled_tasks_runtime_) {
     return;
   }
 
   pending_pump_throttled_tasks_runtime_ = throttled_runtime;
 
   suspend_timers_when_backgrounded_closure_.Cancel();
 
   base::TimeDelta delay = pending_pump_throttled_tasks_runtime_ - now;
   TRACE_EVENT1(tracing_category_,
                "ThrottlingHelper::MaybeSchedulePumpThrottledTasksLocked",
                "delay_till_next_pump_ms", delay.InMilliseconds());
   task_runner_->PostDelayedTask(
       from_here, suspend_timers_when_backgrounded_closure_.callback(), delay);
 }
 
 }  // namespace scheduler
+}  // namespace blink