scheduler: Move the Blink scheduler into Blink

third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc

 // Copyright 2015 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 "components/scheduler/child/idle_helper.h"
+#include "platform/scheduler/child/idle_helper.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
-#include "components/scheduler/base/real_time_domain.h"
-#include "components/scheduler/base/task_queue.h"
-#include "components/scheduler/base/task_queue_manager.h"
-#include "components/scheduler/base/test_time_source.h"
-#include "components/scheduler/child/scheduler_helper.h"
-#include "components/scheduler/child/scheduler_tqm_delegate_for_test.h"
-#include "components/scheduler/child/scheduler_tqm_delegate_impl.h"
+#include "platform/scheduler/base/real_time_domain.h"
+#include "public/platform/scheduler/base/task_queue.h"
+#include "platform/scheduler/base/task_queue_manager.h"
+#include "platform/scheduler/base/test_time_source.h"
+#include "platform/scheduler/child/scheduler_helper.h"
+#include "platform/scheduler/child/scheduler_tqm_delegate_for_test.h"
+#include "platform/scheduler/child/scheduler_tqm_delegate_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::Exactly;
 using testing::Invoke;
 using testing::Return;
 
+namespace blink {
 namespace scheduler {
 
 namespace {
 void AppendToVectorTestTask(std::vector<std::string>* vector,
                             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 NullTask() {}
 
-void NullIdleTask(base::TimeTicks deadline) {
-}
+void NullIdleTask(base::TimeTicks deadline) {}
 
 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),
@@ skipping 465 matching lines @@
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   idle_helper_->EndIdlePeriod();
 }
 
 class IdleHelperWithMessageLoopTest : public BaseIdleHelperTest {
  public:
   IdleHelperWithMessageLoopTest()
       : BaseIdleHelperTest(new base::MessageLoop(), base::TimeDelta()) {}
   ~IdleHelperWithMessageLoopTest() override {}
 
-  void PostFromNestedRunloop(std::vector<
-      std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) {
+  void PostFromNestedRunloop(
+      std::vector<std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>*
+          tasks) {
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get());
     for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) {
       if (pair.second) {
         idle_task_runner_->PostIdleTask(FROM_HERE, pair.first);
       } else {
         idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first);
       }
     }
     idle_helper_->StartIdlePeriod(
         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
@@ skipping 431 matching lines @@
   void MakeNonQuiescent() {
     // Run an arbitrary task so we're deemed to be not quiescent.
     default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask));
     RunUntilIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperWithQuiescencePeriodTest);
 };
 
-class IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver :
-    public IdleHelperWithQuiescencePeriodTest {
+class IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver
+    : public IdleHelperWithQuiescencePeriodTest {
  public:
-
   IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver()
       : IdleHelperWithQuiescencePeriodTest() {}
 
   ~IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver() override {}
 
   void SetUp() override {
     // Don't set expectations on IdleHelper::Delegate.
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       IdleHelperWithQuiescencePeriodTestWithIdlePeriodObserver);
 };
 
-
 TEST_F(IdleHelperWithQuiescencePeriodTest,
        LongIdlePeriodStartsImmediatelyIfQuiescent) {
   base::TimeTicks actual_deadline;
   int run_count = 0;
   max_idle_task_reposts = 1;
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, base::RetainedRef(idle_task_runner_),
                  &run_count, &actual_deadline));
 
@@ skipping 133 matching lines @@
   EXPECT_EQ(0, run_count);
 
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         more_than_min_deadline_duration);
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 }  // namespace scheduler
+}  // namespace blink