Move blink scheduler implementation into a component

components/scheduler/child/scheduler_helper_unittest.cc

Index: components/scheduler/child/scheduler_helper_unittest.cc
diff --git a/content/child/scheduler/scheduler_helper_unittest.cc b/components/scheduler/child/scheduler_helper_unittest.cc
similarity index 89%
rename from content/child/scheduler/scheduler_helper_unittest.cc
rename to components/scheduler/child/scheduler_helper_unittest.cc
index d3e9bda3e669aa6fc4881e1ebb8dcd050ffa68ad..0418c0be3250d172d00ad2ab9234bf1f5312a79d 100644
--- a/content/child/scheduler/scheduler_helper_unittest.cc
+++ b/components/scheduler/child/scheduler_helper_unittest.cc
@@ -2,15 +2,15 @@
 // 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/callback.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/child/scheduler/task_queue_manager.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/task_queue_manager.h"
+#include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -19,7 +19,7 @@ using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 
-namespace content {
+namespace scheduler {
 
 namespace {
 void AppendToVectorTestTask(std::vector<std::string>* vector,
@@ -36,17 +36,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));
   }
 }
 
@@ -62,15 +61,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)++;
 }
@@ -284,10 +281,8 @@ TEST_F(SchedulerHelperTest, TestPostIdleTask) {
   EXPECT_EQ(0, run_count);
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      expected_deadline,
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      expected_deadline, true);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
@@ -305,10 +300,8 @@ TEST_F(SchedulerHelperTest, TestPostIdleTask_EndIdlePeriod) {
   EXPECT_EQ(0, run_count);
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   scheduler_helper_->EndIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
@@ -322,10 +315,8 @@ TEST_F(SchedulerHelperTest, TestRepostingIdleTask) {
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
@@ -334,10 +325,8 @@ TEST_F(SchedulerHelperTest, TestRepostingIdleTask) {
   EXPECT_EQ(1, run_count);
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
@@ -354,20 +343,16 @@ TEST_F(SchedulerHelperTest, TestIdleTaskExceedsDeadline) {
                             default_task_runner_, &run_count));
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Only the first idle task should execute since it's used up the deadline.
   EXPECT_EQ(1, run_count);
 
   scheduler_helper_->EndIdlePeriod();
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Second task should be run on the next idle period.
   EXPECT_EQ(2, run_count);
@@ -381,10 +366,8 @@ TEST_F(SchedulerHelperTest, TestPostIdleTaskAfterWakeup) {
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Shouldn't run yet as no other task woke up the scheduler.
   EXPECT_EQ(0, run_count);
@@ -393,10 +376,8 @@ TEST_F(SchedulerHelperTest, TestPostIdleTaskAfterWakeup) {
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Another after wakeup idle task shouldn't wake the scheduler.
   EXPECT_EQ(0, run_count);
@@ -406,10 +387,8 @@ TEST_F(SchedulerHelperTest, TestPostIdleTaskAfterWakeup) {
   RunUntilIdle();
   // Must start a new idle period before idle task runs.
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Execution of default task queue task should trigger execution of idle task.
   EXPECT_EQ(2, run_count);
@@ -426,10 +405,8 @@ TEST_F(SchedulerHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) {
   RunUntilIdle();
   // Must start a new idle period before idle task runs.
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Should run as the scheduler was already awakened by the normal task.
   EXPECT_EQ(1, run_count);
@@ -445,17 +422,13 @@ TEST_F(SchedulerHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) {
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Must start a new idle period before after-wakeup idle task runs.
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Normal idle task should wake up after-wakeup idle task.
   EXPECT_EQ(2, run_count);
@@ -527,10 +500,8 @@ class SchedulerHelperWithMessageLoopTest : public BaseSchedulerHelperTest {
       }
     }
     scheduler_helper_->StartIdlePeriod(
-        SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-        clock_->Now(),
-        clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-        true);
+        SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+        clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
     message_loop_->RunUntilIdle();
   }
 
@@ -565,10 +536,8 @@ TEST_F(SchedulerHelperWithMessageLoopTest,
                  base::Unretained(&tasks_to_post_from_nested_loop)));
 
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"),
@@ -727,14 +696,14 @@ TEST_F(SchedulerHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) {
   int run_count = 0;
 
   ON_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _))
-      .WillByDefault(Invoke([delay, delayOver](
-          base::TimeTicks now,
-          base::TimeDelta* next_long_idle_period_delay_out) {
-        if (now >= delayOver)
-          return true;
-        *next_long_idle_period_delay_out = delay;
-        return false;
-      }));
+      .WillByDefault(Invoke(
+          [delay, delayOver](base::TimeTicks now,
+                             base::TimeDelta* next_long_idle_period_delay_out) {
+            if (now >= delayOver)
+              return true;
+            *next_long_idle_period_delay_out = delay;
+            return false;
+          }));
 
   EXPECT_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _)).Times(3);
 
@@ -781,10 +750,8 @@ TEST_F(SchedulerHelperTest, CanExceedIdleDeadlineIfRequired) {
                             scheduler_helper_.get(), &can_exceed_idle_deadline,
                             &run_count));
   scheduler_helper_->StartIdlePeriod(
-      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-      clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10),
-      true);
+      SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      clock_->Now() + base::TimeDelta::FromMilliseconds(10), true);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_FALSE(can_exceed_idle_deadline);
@@ -945,4 +912,4 @@ TEST_F(SchedulerHelperWithQuiescencePeriodTest,
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
-}  // namespace content
+}  // namespace scheduler