Move blink scheduler implementation into a component

components/scheduler/child/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/child/scheduler/task_queue_manager.h"
+#include "components/scheduler/child/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/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 "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_selector.h"
+#include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
 using testing::_;
 
-namespace content {
+namespace scheduler {
 namespace {
 
 class SelectorForTest : public TaskQueueSelector {
  public:
   ~SelectorForTest() override {}
 
   virtual void AppendQueueToService(size_t queue_index) = 0;
 
   virtual const std::vector<const base::TaskQueue*>& work_queues() = 0;
 
@@ skipping 22 matching lines @@
   }
 
   void AppendQueueToService(size_t queue_index) override {
     DCHECK(false) << "Not supported";
   }
 
   const std::vector<const base::TaskQueue*>& work_queues() override {
     return work_queues_;
   }
 
-  void SetTaskQueueSelectorObserver(Observer* observer) override {
-  }
+  void SetTaskQueueSelectorObserver(Observer* observer) override {}
 
  private:
   std::vector<const base::TaskQueue*> work_queues_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomaticSelectorForTest);
 };
 
 class ExplicitSelectorForTest : public SelectorForTest {
  public:
   ExplicitSelectorForTest() {}
@@ skipping 13 matching lines @@
   }
 
   void AppendQueueToService(size_t queue_index) override {
     queues_to_service_.push_back(queue_index);
   }
 
   const std::vector<const base::TaskQueue*>& work_queues() override {
     return work_queues_;
   }
 
-  void SetTaskQueueSelectorObserver(Observer* observer) override {
-  }
+  void SetTaskQueueSelectorObserver(Observer* observer) override {}
 
  private:
   std::deque<size_t> queues_to_service_;
   std::vector<const base::TaskQueue*> work_queues_;
 
   DISALLOW_COPY_AND_ASSIGN(ExplicitSelectorForTest);
 };
 
 class TaskQueueManagerTest : public testing::Test {
  public:
-  void DeleteTaskQueueManager() {
-    manager_.reset();
-  }
+  void DeleteTaskQueueManager() { manager_.reset(); }
 
  protected:
   enum class SelectorType {
     Automatic,
     Explicit,
   };
 
   void Initialize(size_t num_queues, SelectorType type) {
     now_src_ = cc::TestNowSource::Create(1000);
     test_task_runner_ =
@@ skipping 325 matching lines @@
 
   TestObject::destructor_count_ = 0;
 
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runner->PostDelayedTask(
       FROM_HERE, base::Bind(&TestObject::Run, base::Owned(new TestObject())),
       delay);
-  runner->PostTask(
-      FROM_HERE, base::Bind(&TestObject::Run, base::Owned(new TestObject())));
+  runner->PostTask(FROM_HERE,
+                   base::Bind(&TestObject::Run, base::Owned(new TestObject())));
 
   manager_.reset();
 
   EXPECT_EQ(2, TestObject::destructor_count_);
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumping) {
   Initialize(1u, SelectorType::Automatic);
   manager_->SetPumpPolicy(0, TaskQueueManager::PumpPolicy::MANUAL);
 
@@ skipping 627 matching lines @@
 
 TEST_F(TaskQueueManagerTest, GetAndClearTaskWasRunBitmap_ManyQueues) {
   Initialize(64u, SelectorType::Automatic);
 
   manager_->TaskRunnerForQueue(63)->PostTask(FROM_HERE, base::Bind(&NopTask));
   test_task_runner_->RunUntilIdle();
   EXPECT_EQ(1ull << 63, manager_->GetAndClearTaskWasRunOnQueueBitmap());
 }
 
 }  // namespace
-}  // namespace content
+}  // namespace scheduler