Introduce a SchedulerHelper in content/child/scheduler

content/child/scheduler/task_queue_manager_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/task_queue_manager.h"
+#include "content/child/scheduler/task_queue_manager.h"
 
 #include "base/threading/thread.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/test_now_source.h"
-#include "content/renderer/scheduler/nestable_task_runner_for_test.h"
-#include "content/renderer/scheduler/renderer_scheduler_message_loop_delegate.h"
-#include "content/renderer/scheduler/task_queue_selector.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_selector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
 using testing::_;
 
 namespace content {
 namespace {
 
 class SelectorForTest : public TaskQueueSelector {
  public:
@@ skipping 81 matching lines @@
     Explicit,
   };
 
   void Initialize(size_t num_queues, SelectorType type) {
     now_src_ = cc::TestNowSource::Create(1000);
     test_task_runner_ =
         make_scoped_refptr(new cc::OrderedSimpleTaskRunner(now_src_, false));
     selector_ = make_scoped_ptr(createSelectorForTest(type));
     manager_ = make_scoped_ptr(new TaskQueueManager(
         num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()),
-        selector_.get()));
+        selector_.get(), "test.scheduler"));
     manager_->SetTimeSourceForTesting(now_src_);
 
     EXPECT_EQ(num_queues, selector_->work_queues().size());
   }
 
   void InitializeWithRealMessageLoop(size_t num_queues, SelectorType type) {
     message_loop_.reset(new base::MessageLoop());
     selector_ = make_scoped_ptr(createSelectorForTest(type));
     manager_ = make_scoped_ptr(new TaskQueueManager(
-        num_queues,
-        RendererSchedulerMessageLoopDelegate::Create(message_loop_.get()),
-        selector_.get()));
+        num_queues, SchedulerMessageLoopDelegate::Create(message_loop_.get()),
+        selector_.get(), "test.scheduler"));
     EXPECT_EQ(num_queues, selector_->work_queues().size());
   }
 
   SelectorForTest* createSelectorForTest(SelectorType type) {
     switch (type) {
       case SelectorType::Automatic:
         return new AutomaticSelectorForTest();
 
       case SelectorType::Explicit:
         return new ExplicitSelectorForTest();
@@ skipping 144 matching lines @@
 
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 
   runner->PostTask(
-      FROM_HERE,
-      base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
-                 base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
+                            base::Unretained(&tasks_to_post_from_nested_loop)));
 
   message_loop_->RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
 TEST_F(TaskQueueManagerTest, QueuePolling) {
   Initialize(1u, SelectorType::Automatic);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   EXPECT_TRUE(manager_->IsQueueEmpty(0));
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(manager_->IsQueueEmpty(0));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(manager_->IsQueueEmpty(0));
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) {
   Initialize(1u, SelectorType::Automatic);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
-  runner->PostDelayedTask(
-      FROM_HERE, base::Bind(&TestTask, 1, &run_order), delay);
+  runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
+                          delay);
   EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime());
   EXPECT_TRUE(manager_->IsQueueEmpty(0));
   EXPECT_TRUE(run_order.empty());
 
   // The task doesn't run before the delay has completed.
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9));
   EXPECT_TRUE(run_order.empty());
 
   // After the delay has completed, the task runs normally.
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1));
@@ skipping 180 matching lines @@
   Initialize(1u, SelectorType::Automatic);
   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   // Posting a delayed task when pumping will apply the delay, but won't cause
   // work to executed afterwards.
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
-  runner->PostDelayedTask(
-      FROM_HERE, base::Bind(&TestTask, 1, &run_order), delay);
+  runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
+                          delay);
 
   // After pumping but before the delay period has expired, task does not run.
   manager_->PumpQueue(0);
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
   EXPECT_TRUE(run_order.empty());
 
   // Once the delay has expired, pumping causes the task to run.
   now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(5));
   manager_->PumpQueue(0);
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
@@ skipping 122 matching lines @@
       FROM_HERE, base::Bind(&PostTaskToRunner, runner, &run_order));
   thread.Stop();
 
   message_loop_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 void RePostingTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
                        int* run_count) {
   (*run_count)++;
-  runner->PostTask(
-      FROM_HERE,
-      Bind(&RePostingTestTask, base::Unretained(runner.get()), run_count));
+  runner->PostTask(FROM_HERE, Bind(&RePostingTestTask,
+                                   base::Unretained(runner.get()), run_count));
 }
 
 TEST_F(TaskQueueManagerTest, DoWorkCantPostItselfMultipleTimes) {
   Initialize(1u, SelectorType::Automatic);
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   int run_count = 0;
   runner->PostTask(FROM_HERE,
                    base::Bind(&RePostingTestTask, runner, &run_count));
@@ skipping 138 matching lines @@
       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(0);
 
   // Check that a task which posts a task to an auto pump after wakeup queue
   // doesn't cause the queue to wake up.
   base::Closure after_wakeup_task = base::Bind(&TestTask, 1, &run_order);
   runners[1]->PostTask(
-      FROM_HERE,
-      base::Bind(&TestPostingTask, runners[0], after_wakeup_task));
+      FROM_HERE, base::Bind(&TestPostingTask, runners[0], after_wakeup_task));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // Wake up the queue.
   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupFromMultipleTasks) {
   Initialize(2u, SelectorType::Explicit);
   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::AFTER_WAKEUP);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(0);
   selector_->AppendQueueToService(0);
 
   // Check that a task which posts a task to an auto pump after wakeup queue
   // doesn't cause the queue to wake up.
   base::Closure after_wakeup_task_1 = base::Bind(&TestTask, 1, &run_order);
   base::Closure after_wakeup_task_2 = base::Bind(&TestTask, 2, &run_order);
   runners[1]->PostTask(
-      FROM_HERE,
-      base::Bind(&TestPostingTask, runners[0], after_wakeup_task_1));
+      FROM_HERE, base::Bind(&TestPostingTask, runners[0], after_wakeup_task_1));
   runners[1]->PostTask(
-      FROM_HERE,
-      base::Bind(&TestPostingTask, runners[0], after_wakeup_task_2));
+      FROM_HERE, base::Bind(&TestPostingTask, runners[0], after_wakeup_task_2));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // Wake up the queue.
   runners[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(3, 1, 2));
 }
 
 TEST_F(TaskQueueManagerTest, AutoPumpAfterWakeupBecomesQuiescent) {
@@ skipping 160 matching lines @@
   runners[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1);
   runners[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2);
   runners[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay3);
 
   EXPECT_EQ(now_src_->Now() + delay2,
             manager_->NextPendingDelayedTaskRunTime());
 }
 
 }  // namespace
 }  // namespace content
-