Be explicit about namespace testing to not mix it with blink::testing

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 "platform/scheduler/child/idle_helper.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "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;
+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);
 }
 
@@ skipping 127 matching lines @@
   MOCK_METHOD2(CanEnterLongIdlePeriod,
                bool(base::TimeTicks now,
                     base::TimeDelta* next_long_idle_period_delay_out));
 
   MOCK_METHOD0(IsNotQuiescent, void());
   MOCK_METHOD0(OnIdlePeriodStarted, void());
   MOCK_METHOD0(OnIdlePeriodEnded, void());
   MOCK_METHOD1(OnPendingTasksChanged, void(bool has_tasks));
 };
 
-class BaseIdleHelperTest : public testing::Test {
+class BaseIdleHelperTest : public ::testing::Test {
  public:
   BaseIdleHelperTest(
       base::MessageLoop* message_loop,
       base::TimeDelta required_quiescence_duration_before_long_idle_period)
       : clock_(new base::SimpleTestTickClock()),
         mock_task_runner_(
             message_loop
                 ? nullptr
                 : new cc::OrderedSimpleTaskRunner(clock_.get(), false)),
         message_loop_(message_loop),
@@ skipping 229 matching lines @@
 
   TaskQueueManager* task_queue_manager() const {
     return scheduler_helper_->GetTaskQueueManagerForTesting();
   }
 
   void ExpectIdlePeriodStartsButNeverEnds() {
     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(1);
     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(0);
   }
 
-  void ExpectIdlePeriodStartsAndEnds(const testing::Cardinality& cardinality) {
+  void ExpectIdlePeriodStartsAndEnds(
+      const ::testing::Cardinality& cardinality) {
     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(cardinality);
     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(cardinality);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperTestWithIdlePeriodObserver);
 };
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestEnterButNotExitIdlePeriod) {
   ExpectIdlePeriodStartsButNeverEnds();
@@ skipping 76 matching lines @@
       FROM_HERE,
       base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop,
                  base::Unretained(this),
                  base::Unretained(&tasks_to_post_from_nested_loop)));
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
-  EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"),
-                                          std::string("4"), std::string("5"),
-                                          std::string("3")));
+  EXPECT_THAT(order, ::testing::ElementsAre(std::string("1"), std::string("2"),
+                                            std::string("4"), std::string("5"),
+                                            std::string("3")));
 }
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestLongIdlePeriod) {
   base::TimeTicks expected_deadline =
       clock_->NowTicks() + maximum_idle_period_duration();
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
@@ skipping 72 matching lines @@
       base::Bind(&RepostingUpdateClockIdleTestTask,
                  base::RetainedRef(idle_task_runner_), &run_count, clock_.get(),
                  idle_task_runtime, &actual_deadlines));
 
   // Check each idle task runs in their own idle period.
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(3, run_count);
   EXPECT_THAT(
       actual_deadlines,
-      testing::ElementsAre(
+      ::testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration(),
           clock_before + (2 * idle_task_runtime) +
               maximum_idle_period_duration()));
 
   g_max_idle_task_reposts = 5;
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingUpdateClockIdleTestTask,
                  base::RetainedRef(idle_task_runner_), &run_count, clock_.get(),
@@ skipping 61 matching lines @@
       FROM_HERE,
       base::Bind(&RepostingUpdateClockIdleTestTask,
                  base::RetainedRef(idle_task_runner_), &run_count, clock_.get(),
                  idle_task_runtime, &actual_deadlines));
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_THAT(
       actual_deadlines,
-      testing::ElementsAre(
+      ::testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodRestartWaitsIfNotMaxDeadline) {
   base::TimeTicks actual_deadline;
   int run_count = 0;
 
   base::TimeDelta pending_task_delay(base::TimeDelta::FromMilliseconds(20));
   base::TimeDelta idle_task_duration(base::TimeDelta::FromMilliseconds(10));
@@ skipping 50 matching lines @@
   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingUpdateClockIdleTestTask,
                  base::RetainedRef(idle_task_runner_), &run_count, clock_.get(),
                  idle_task_runtime, &actual_deadlines));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_THAT(
       actual_deadlines,
-      testing::ElementsAre(
+      ::testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 
   // Once all task have been run we should go back to the paused state.
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
   EXPECT_FALSE(scheduler_helper_->real_time_domain()->NextScheduledRunTime(
       &next_pending_delayed_task));
 
   idle_helper_->EndIdlePeriod();
   CheckIdlePeriodStateIs("not_in_idle_period");
@@ skipping 333 matching lines @@
 
 // Tests that the OnPendingTasksChanged callback is called once when the idle
 // queue becomes non-empty and again when it becomes empty.
 TEST_F(IdleHelperTest, OnPendingTasksChanged) {
   int run_count = 0;
   base::TimeTicks expected_deadline =
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);
   base::TimeTicks deadline_in_task;
 
   {
-    testing::InSequence dummy;
+    ::testing::InSequence dummy;
     // This will be called once. I.e when the one and only task is posted.
     EXPECT_CALL(*idle_helper_, OnPendingTasksChanged(true)).Times(1);
     // This will be called once. I.e when the one and only task completes.
     EXPECT_CALL(*idle_helper_, OnPendingTasksChanged(false)).Times(1);
   }
 
   clock_->Advance(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
@@ skipping 10 matching lines @@
 
 // Tests that the OnPendingTasksChanged callback is still only called once
 // with false despite there being two idle tasks posted.
 TEST_F(IdleHelperTest, OnPendingTasksChanged_TwoTasksAtTheSameTime) {
   int run_count = 0;
   base::TimeTicks expected_deadline =
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);
   base::TimeTicks deadline_in_task;
 
   {
-    testing::InSequence dummy;
+    ::testing::InSequence dummy;
     // This will be called 3 times. I.e when T1 and T2 are posted and when T1
     // completes.
     EXPECT_CALL(*idle_helper_, OnPendingTasksChanged(true)).Times(3);
     // This will be called once. I.e when T2 completes.
     EXPECT_CALL(*idle_helper_, OnPendingTasksChanged(false)).Times(1);
   }
 
   clock_->Advance(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   idle_helper_->StartIdlePeriod(
       IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
       expected_deadline);
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 }  // namespace scheduler
 }  // namespace blink