Move blink scheduler implementation into a component

components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

Index: components/scheduler/renderer/renderer_scheduler_impl_unittest.cc
diff --git a/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc b/components/scheduler/renderer/renderer_scheduler_impl_unittest.cc
similarity index 96%
rename from content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
rename to components/scheduler/renderer/renderer_scheduler_impl_unittest.cc
index 150be2e1f71636a86958f980a43f3316c03b9eaf..27ec4319c2beb2077106ea6f642cdbb1497e113a 100644
--- a/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
+++ b/components/scheduler/renderer/renderer_scheduler_impl_unittest.cc
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/scheduler/renderer_scheduler_impl.h"
+#include "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/test_now_source.h"
-#include "content/child/scheduler/nestable_task_runner_for_test.h"
-#include "content/child/scheduler/scheduler_message_loop_delegate.h"
-#include "content/test/test_time_source.h"
+#include "components/scheduler/child/nestable_task_runner_for_test.h"
+#include "components/scheduler/child/scheduler_message_loop_delegate.h"
+#include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace content {
+namespace scheduler {
 
 namespace {
 class FakeInputEvent : public blink::WebInputEvent {
@@ -45,17 +45,16 @@ void AppendToVectorIdleTestTask(std::vector<std::string>* vector,
 void NullTask() {
 }
 
-void AppendToVectorReentrantTask(
-    base::SingleThreadTaskRunner* task_runner,
-    std::vector<int>* vector,
-    int* reentrant_count,
-    int max_reentrant_count) {
+void AppendToVectorReentrantTask(base::SingleThreadTaskRunner* task_runner,
+                                 std::vector<int>* vector,
+                                 int* reentrant_count,
+                                 int max_reentrant_count) {
   vector->push_back((*reentrant_count)++);
   if (*reentrant_count < max_reentrant_count) {
     task_runner->PostTask(
-        FROM_HERE, base::Bind(AppendToVectorReentrantTask,
-                              base::Unretained(task_runner), vector,
-                              reentrant_count, max_reentrant_count));
+        FROM_HERE,
+        base::Bind(AppendToVectorReentrantTask, base::Unretained(task_runner),
+                   vector, reentrant_count, max_reentrant_count));
   }
 }
 
@@ -68,15 +67,13 @@ void IdleTestTask(int* run_count,
 
 int max_idle_task_reposts = 2;
 
-void RepostingIdleTestTask(
-    SingleThreadIdleTaskRunner* idle_task_runner,
-    int* run_count,
-    base::TimeTicks deadline) {
+void RepostingIdleTestTask(SingleThreadIdleTaskRunner* idle_task_runner,
+                           int* run_count,
+                           base::TimeTicks deadline) {
   if ((*run_count + 1) < max_idle_task_reposts) {
     idle_task_runner->PostIdleTask(
-        FROM_HERE,
-        base::Bind(&RepostingIdleTestTask, base::Unretained(idle_task_runner),
-                   run_count));
+        FROM_HERE, base::Bind(&RepostingIdleTestTask,
+                              base::Unretained(idle_task_runner), run_count));
   }
   (*run_count)++;
 }
@@ -95,12 +92,11 @@ void UpdateClockToDeadlineIdleTestTask(
   (*run_count)++;
 }
 
-void PostingYieldingTestTask(
-    RendererSchedulerImpl* scheduler,
-    base::SingleThreadTaskRunner* task_runner,
-    bool simulate_input,
-    bool* should_yield_before,
-    bool* should_yield_after) {
+void PostingYieldingTestTask(RendererSchedulerImpl* scheduler,
+                             base::SingleThreadTaskRunner* task_runner,
+                             bool simulate_input,
+                             bool* should_yield_before,
+                             bool* should_yield_after) {
   *should_yield_before = scheduler->ShouldYieldForHighPriorityWork();
   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
   if (simulate_input) {
@@ -553,8 +549,7 @@ TEST_F(RendererSchedulerImplTest, TestTouchstartPolicy) {
       FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));
   RunUntilIdle();
 
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1")));
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("L1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
@@ -1167,8 +1162,8 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodWithPendingDelayedTask) {
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
-  default_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&NullTask), pending_task_delay);
+  default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
+                                        pending_task_delay);
 
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
@@ -1182,8 +1177,8 @@ TEST_F(RendererSchedulerImplTest,
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
-  default_task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&NullTask), pending_task_delay);
+  default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
+                                        pending_task_delay);
 
   // Advance clock until after delayed task was meant to be run.
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(20));
@@ -1253,8 +1248,7 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodDoesNotWakeScheduler) {
   // Posting a after-wakeup idle task also shouldn't wake the scheduler or
   // initiate the next long idle period.
   idle_task_runner_->PostIdleTaskAfterWakeup(
-      FROM_HERE,
-      base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
+      FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   RunUntilIdle();
   new_idle_period_deadline = scheduler_->CurrentIdleTaskDeadlineForTesting();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
@@ -1275,8 +1269,7 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodInTouchStartPolicy) {
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
+      FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   // Observation of touchstart should defer the start of the long idle period.
   scheduler_->DidReceiveInputEventOnCompositorThread(
@@ -1424,4 +1417,4 @@ TEST_F(RendererSchedulerImplTest, MultipleSuspendsNeedMultipleResumes) {
               testing::ElementsAre(std::string("T1"), std::string("T2")));
 }
 
-}  // namespace content
+}  // namespace scheduler