Introduce a SchedulerHelper in content/child/scheduler

content/renderer/scheduler/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 "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
-#include "content/renderer/scheduler/nestable_task_runner_for_test.h"
-#include "content/renderer/scheduler/renderer_scheduler_message_loop_delegate.h"
+#include "content/child/scheduler/nestable_task_runner_for_test.h"
+#include "content/child/scheduler/scheduler_message_loop_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 class FakeInputEvent : public blink::WebInputEvent {
  public:
   explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
       : WebInputEvent(sizeof(FakeInputEvent)) {
@@ skipping 11 matching lines @@
                             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) {
+  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));
+  }
+}
+
+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) {
+  if ((*run_count + 1) < max_idle_task_reposts) {
+    idle_task_runner->PostIdleTask(
+        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) {
+  *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,
+                          bool simulate_input,
+                          bool* is_anticipated_before,
+                          bool* is_anticipated_after) {
+  *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
+  if (simulate_input) {
+    scheduler->DidReceiveInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
+  }
+  *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
+}
 };  // namespace
 
 class RendererSchedulerImplTest : public testing::Test {
  public:
   using Policy = RendererSchedulerImpl::Policy;
 
   RendererSchedulerImplTest()
       : clock_(cc::TestNowSource::Create(5000)),
         mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
         nestable_task_runner_(
             NestableTaskRunnerForTest::Create(mock_task_runner_)),
         scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
         idle_task_runner_(scheduler_->IdleTaskRunner()) {
     scheduler_->SetTimeSourceForTesting(clock_);
   }
 
   RendererSchedulerImplTest(base::MessageLoop* message_loop)
       : clock_(cc::TestNowSource::Create(5000)),
         message_loop_(message_loop),
         nestable_task_runner_(
-            RendererSchedulerMessageLoopDelegate::Create(message_loop)),
+            SchedulerMessageLoopDelegate::Create(message_loop)),
         scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
         idle_task_runner_(scheduler_->IdleTaskRunner()) {
     scheduler_->SetTimeSourceForTesting(clock_);
   }
   ~RendererSchedulerImplTest() override {}
 
   void TearDown() override {
@@ skipping 76 matching lines @@
   }
 
  protected:
   static base::TimeDelta priority_escalation_after_input_duration() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kPriorityEscalationAfterInputMillis);
   }
 
   static base::TimeDelta maximum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
-        RendererSchedulerImpl::kMaximumIdlePeriodMillis);
-  }
-
-  base::TimeTicks CurrentIdleTaskDeadline() {
-    base::TimeTicks deadline;
-    scheduler_->CurrentIdleTaskDeadlineCallback(&deadline);
-    return deadline;
+        SchedulerHelper::kMaximumIdlePeriodMillis);
   }
 
   scoped_refptr<cc::TestNowSource> clock_;
   // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_ptr<base::MessageLoop> message_loop_;
 
   scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
   scoped_ptr<RendererSchedulerImpl> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
 };
 
-void NullTask() {
-}
-
-void AppendToVectorReentrantTask(
-    scoped_refptr<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, 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;
-}
-
-void RepostingIdleTestTask(
-    scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner,
-    int* run_count,
-    base::TimeTicks deadline) {
-  if (*run_count == 0) {
-    idle_task_runner->PostIdleTask(
-        FROM_HERE,
-        base::Bind(&RepostingIdleTestTask, idle_task_runner, run_count));
-  }
-  (*run_count)++;
-}
-
-void UpdateClockToDeadlineIdleTestTask(
-    scoped_refptr<cc::TestNowSource> clock,
-    scoped_refptr<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,
-    scoped_refptr<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,
-                          bool simulate_input,
-                          bool* is_anticipated_before,
-                          bool* is_anticipated_after) {
-  *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
-  if (simulate_input) {
-    scheduler->DidReceiveInputEventOnCompositorThread(
-        FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
-  }
-  *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
-}
-
 TEST_F(RendererSchedulerImplTest, TestPostDefaultTask) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 D2 D3 D4");
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("D2"),
                                    std::string("D3"), std::string("D4")));
 }
 
@@ skipping 46 matching lines @@
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(800));
   scheduler_->DidCommitFrameToCompositor();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
   int run_count = 0;
 
+  max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // Reposted tasks shouldn't run until next idle period.
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
@@ skipping 816 matching lines @@
 
   // After the delayed task has been run we should trigger an idle period.
   clock_->AdvanceNow(maximum_idle_period_duration());
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodRepeating) {
   int run_count = 0;
 
+  max_idle_task_reposts = 3;
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
 
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should only run once per idle period.
 
   // Advance time to start of next long idle period and check task reposted task
   // gets run.
@@ skipping 14 matching lines @@
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodDoesNotWakeScheduler) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   // Start a long idle period and get the time it should end.
   scheduler_->BeginFrameNotExpectedSoon();
   // The scheduler should not run the initiate_next_long_idle_period task if
   // there are no idle tasks and no other task woke up the scheduler, thus
   // the idle period deadline shouldn't update at the end of the current long
   // idle period.
-  base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadline();
+  base::TimeTicks idle_period_deadline =
+      scheduler_->CurrentIdleTaskDeadlineForTesting();
   clock_->AdvanceNow(maximum_idle_period_duration());
   RunUntilIdle();
 
-  base::TimeTicks new_idle_period_deadline = CurrentIdleTaskDeadline();
+  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));
   RunUntilIdle();
-  new_idle_period_deadline = CurrentIdleTaskDeadline();
+  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 = CurrentIdleTaskDeadline();
+  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;
 
@@ skipping 65 matching lines @@
 
   // Next long idle period will be for the maximum time, so
   // CanExceedIdleDeadlineIfRequired should return true.
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
   EXPECT_FALSE(scheduler_->CanExceedIdleDeadlineIfRequired());
 }
 
 }  // namespace content