Move blink scheduler implementation into a component

components/scheduler/renderer/renderer_scheduler_impl_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/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 {
  public:
   explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
       : WebInputEvent(sizeof(FakeInputEvent)) {
     type = event_type;
   }
 
   FakeInputEvent(blink::WebInputEvent::Type event_type, int event_modifiers)
@@ skipping 10 matching lines @@
 
 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 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(
     cc::TestNowSource* clock,
     base::SingleThreadTaskRunner* task_runner,
     int* run_count,
     base::TimeTicks deadline) {
   clock->SetNow(deadline);
   // Due to the way in which OrderedSimpleTestRunner orders tasks and the fact
   // that we updated the time within a task, the delayed pending task to call
   // EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so
   // post a normal task here to ensure it runs before the next idle task.
   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
   (*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) {
     scheduler->DidReceiveInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   }
   *should_yield_after = scheduler->ShouldYieldForHighPriorityWork();
 }
 
 void AnticipationTestTask(RendererSchedulerImpl* scheduler,
@@ skipping 432 matching lines @@
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // Action events like ScrollBegin will kick us back into compositor priority,
   // allowing service of the timer, loading and idle queues.
   run_order.clear();
   scheduler_->DidReceiveInputEventOnCompositorThread(
       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,
        DidReceiveInputEventOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseMove));
   EnableIdleTasks();
@@ skipping 592 matching lines @@
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodWithPendingDelayedTask) {
   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30);
   base::TimeTicks expected_deadline = clock_->Now() + pending_task_delay;
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   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();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestLongIdlePeriodWithLatePendingDelayedTask) {
   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(10);
   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));
 
   // Post an idle task and BeginFrameNotExpectedSoon to initiate a long idle
   // period. Since there is a late pending delayed task this shouldn't actually
   // start an idle period.
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   scheduler_->BeginFrameNotExpectedSoon();
@@ skipping 49 matching lines @@
   clock_->AdvanceNow(maximum_idle_period_duration());
   RunUntilIdle();
 
   base::TimeTicks new_idle_period_deadline =
       scheduler_->CurrentIdleTaskDeadlineForTesting();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 
   // 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);
   EXPECT_EQ(0, run_count);
 
   // Running a normal task should initiate a new long idle period though.
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   RunUntilIdle();
   new_idle_period_deadline = scheduler_->CurrentIdleTaskDeadlineForTesting();
   EXPECT_EQ(idle_period_deadline + maximum_idle_period_duration(),
             new_idle_period_deadline);
 
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodInTouchStartPolicy) {
   base::TimeTicks deadline_in_task;
   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(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // The long idle period should start after the touchstart policy has finished.
   clock_->AdvanceNow(priority_escalation_after_input_duration());
@@ skipping 127 matching lines @@
   scheduler_->ResumeTimerQueue();
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   scheduler_->ResumeTimerQueue();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T1"), std::string("T2")));
 }
 
-}  // namespace content
+}  // namespace scheduler