scheduler: Encapsulate TaskQueueManager inside SchedulerHelper

content/child/scheduler/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 "base/callback.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "content/child/scheduler/nestable_task_runner_for_test.h"
 #include "content/child/scheduler/scheduler_message_loop_delegate.h"
@@ skipping 106 matching lines @@
       base::TimeDelta required_quiescence_duration_before_long_idle_period)
       : SchedulerHelper(main_task_runner,
                         this,
                         "test.scheduler",
                         TRACE_DISABLED_BY_DEFAULT("test.scheduler"),
                         TASK_QUEUE_COUNT,
                         required_quiescence_duration_before_long_idle_period) {}
 
   ~SchedulerHelperForTest() override {}
 
-  using SchedulerHelper::CanExceedIdleDeadlineIfRequired;
-  using SchedulerHelper::EndIdlePeriod;
-  using SchedulerHelper::StartIdlePeriod;
-  using SchedulerHelper::EnableLongIdlePeriod;
-
   // SchedulerHelperDelegate implementation:
   MOCK_METHOD2(CanEnterLongIdlePeriod,
                bool(base::TimeTicks now,
                     base::TimeDelta* next_long_idle_period_delay_out));
 
   MOCK_METHOD0(IsNotQuiescent, void());
 };
 
 class BaseSchedulerHelperTest : public testing::Test {
  public:
@@ skipping 90 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BaseSchedulerHelperTest);
 };
 
 class SchedulerHelperTest : public BaseSchedulerHelperTest {
  public:
   SchedulerHelperTest() : BaseSchedulerHelperTest(nullptr, base::TimeDelta()) {}
 
   ~SchedulerHelperTest() override {}
 
+  TaskQueueManager* task_queue_manager() const {
+    return scheduler_helper_->task_queue_manager_.get();
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SchedulerHelperTest);
 };
 
 TEST_F(SchedulerHelperTest, TestPostDefaultTask) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 D2 D3 D4");
 
   RunUntilIdle();
   EXPECT_THAT(run_order,
@@ skipping 198 matching lines @@
       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);
-  TaskQueueManager* task_queue_manager =
-      scheduler_helper_->SchedulerTaskQueueManager();
 
   EXPECT_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _))
       .Times(2)
       .WillRepeatedly(Return(true));
 
   // We need an idle task posted or EnableLongIdlePeriod will use the
   // control_task_after_wakeup_runner_ instead of the control_task_runner_.
   idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
   scheduler_helper_->EnableLongIdlePeriod();
 
   // Check there is a pending delayed task.
-  EXPECT_GT(
-      task_queue_manager->NextPendingDelayedTaskRunTime(), base::TimeTicks());
+  EXPECT_GT(task_queue_manager()->NextPendingDelayedTaskRunTime(),
+            base::TimeTicks());
 
   RunUntilIdle();
 
   // If the delayed task ran, it will an EnableLongIdlePeriod on the control
   // task after wake up queue.
-  EXPECT_FALSE(task_queue_manager->IsQueueEmpty(
+  EXPECT_FALSE(task_queue_manager()->IsQueueEmpty(
       SchedulerHelper::CONTROL_TASK_AFTER_WAKEUP_QUEUE));
 }
 
 TEST_F(SchedulerHelperTest, TestDelayedEndIdlePeriodCanceled) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-  TaskQueueManager* task_queue_manager =
-      scheduler_helper_->SchedulerTaskQueueManager();
 
   EXPECT_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _))
       .Times(1)
       .WillRepeatedly(Return(true));
 
   // We need an idle task posted or EnableLongIdlePeriod will use the
   // control_task_after_wakeup_runner_ instead of the control_task_runner_.
   idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
   scheduler_helper_->EnableLongIdlePeriod();
 
   // Check there is a pending delayed task.
-  EXPECT_GT(
-      task_queue_manager->NextPendingDelayedTaskRunTime(), base::TimeTicks());
+  EXPECT_GT(task_queue_manager()->NextPendingDelayedTaskRunTime(),
+            base::TimeTicks());
 
   scheduler_helper_->EndIdlePeriod();
   RunUntilIdle();
 
   // If the delayed task didn't run, there will be nothing on the control task
   // after wake up queue.
-  EXPECT_TRUE(task_queue_manager->IsQueueEmpty(
+  EXPECT_TRUE(scheduler_helper_->IsQueueEmpty(
       SchedulerHelper::CONTROL_TASK_AFTER_WAKEUP_QUEUE));
 }
 
 class SchedulerHelperWithMessageLoopTest : public BaseSchedulerHelperTest {
  public:
   SchedulerHelperWithMessageLoopTest()
       : BaseSchedulerHelperTest(new base::MessageLoop(), base::TimeDelta()) {}
   ~SchedulerHelperWithMessageLoopTest() override {}
 
   void PostFromNestedRunloop(std::vector<
@@ skipping 419 matching lines @@
       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