Move blink scheduler implementation into a component

components/scheduler/child/scheduler_helper_unittest.cc

 // Copyright 2014 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/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"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 
-namespace content {
+namespace scheduler {
 
 namespace {
 void AppendToVectorTestTask(std::vector<std::string>* vector,
                             std::string value) {
   vector->push_back(value);
 }
 
 void AppendToVectorIdleTestTask(std::vector<std::string>* vector,
                                 std::string value,
                                 base::TimeTicks deadline) {
   AppendToVectorTestTask(vector, value);
 }
 
 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));
   }
 }
 
 void NullIdleTask(base::TimeTicks) {
 }
 
 void IdleTestTask(int* run_count,
                   base::TimeTicks* deadline_out,
                   base::TimeTicks deadline) {
   (*run_count)++;
   *deadline_out = deadline;
 }
 
 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)++;
 }
 
 void UpdateClockToDeadlineIdleTestTask(
     scoped_refptr<cc::TestNowSource> clock,
     base::SingleThreadTaskRunner* task_runner,
     int* run_count,
     base::TimeTicks deadline) {
   clock->SetNow(deadline);
@@ skipping 193 matching lines @@
   base::TimeTicks deadline_in_task;
 
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   RunUntilIdle();
   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);
 }
 
 TEST_F(SchedulerHelperTest, TestPostIdleTask_EndIdlePeriod) {
   int run_count = 0;
   base::TimeTicks deadline_in_task;
 
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   RunUntilIdle();
   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);
 }
 
 TEST_F(SchedulerHelperTest, TestRepostingIdleTask) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
       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);
 
   // Reposted tasks shouldn't run until next idle period.
   RunUntilIdle();
   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);
 }
 
 TEST_F(SchedulerHelperTest, TestIdleTaskExceedsDeadline) {
   int run_count = 0;
 
   // Post two UpdateClockToDeadlineIdleTestTask tasks.
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,
                             default_task_runner_, &run_count));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,
                             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);
 }
 
 TEST_F(SchedulerHelperTest, TestPostIdleTaskAfterWakeup) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       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);
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       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);
 
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   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);
 }
 
 TEST_F(SchedulerHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   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);
 }
 
 TEST_F(SchedulerHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_task_runner_->PostIdleTask(
       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);
 }
 
 TEST_F(SchedulerHelperTest, TestDelayedEndIdlePeriod) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   EXPECT_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _))
       .Times(2)
@@ skipping 51 matching lines @@
       std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) {
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get());
     for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) {
       if (pair.second) {
         idle_task_runner_->PostIdleTask(FROM_HERE, pair.first);
       } else {
         idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first);
       }
     }
     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();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SchedulerHelperWithMessageLoopTest);
 };
 
 TEST_F(SchedulerHelperWithMessageLoopTest,
        NonNestableIdleTaskDoesntExecuteInNestedLoop) {
   std::vector<std::string> order;
@@ skipping 14 matching lines @@
   tasks_to_post_from_nested_loop.push_back(std::make_pair(
       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true));
 
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SchedulerHelperWithMessageLoopTest::PostFromNestedRunloop,
                  base::Unretained(this),
                  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"),
                                           std::string("4"), std::string("5"),
                                           std::string("3")));
 }
 
 TEST_F(SchedulerHelperTest, TestLongIdlePeriod) {
   base::TimeTicks expected_deadline =
       clock_->Now() + maximum_idle_period_duration();
@@ skipping 138 matching lines @@
 }
 
 TEST_F(SchedulerHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) {
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta halfDelay = base::TimeDelta::FromMilliseconds(500);
   base::TimeTicks delayOver = clock_->Now() + delay;
   base::TimeTicks deadline_in_task;
   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);
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   // Make sure Idle tasks don't run until the delay has occured.
   scheduler_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
@@ skipping 26 matching lines @@
 
   // Should return false if not in an idle period.
   EXPECT_FALSE(scheduler_helper_->CanExceedIdleDeadlineIfRequired());
 
   // Should return false for short idle periods.
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask,
                             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);
 
   // Should return false for a long idle period which is shortened due to a
   // pending delayed task.
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask,
@@ skipping 140 matching lines @@
   base::TimeTicks expected_deadline =
       clock_->Now() +
       base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs);
   default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask));
   RunUntilIdle();
 
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
-}  // namespace content
+}  // namespace scheduler