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

third_party/WebKit/Source/platform/scheduler/base/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 "platform/scheduler/base/task_queue_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 15 matching lines @@
 #include "platform/scheduler/base/task_queue_manager_delegate_for_test.h"
 #include "platform/scheduler/base/task_queue_selector.h"
 #include "platform/scheduler/base/test_count_uses_time_source.h"
 #include "platform/scheduler/base/test_task_time_observer.h"
 #include "platform/scheduler/base/test_time_source.h"
 #include "platform/scheduler/base/virtual_time_domain.h"
 #include "platform/scheduler/base/work_queue.h"
 #include "platform/scheduler/base/work_queue_sets.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
-using testing::AnyNumber;
-using testing::Contains;
-using testing::ElementsAre;
-using testing::ElementsAreArray;
-using testing::Mock;
-using testing::Not;
-using testing::_;
+using ::testing::AnyNumber;
+using ::testing::Contains;
+using ::testing::ElementsAre;
+using ::testing::ElementsAreArray;
+using ::testing::Mock;
+using ::testing::Not;
+using ::testing::_;
 using blink::scheduler::internal::EnqueueOrder;
 
 namespace blink {
 namespace scheduler {
 
 class TaskQueueManagerForTest : public TaskQueueManager {
  public:
   explicit TaskQueueManagerForTest(
       scoped_refptr<TaskQueueManagerDelegate> delegate)
       : TaskQueueManager(delegate) {}
@@ skipping 23 matching lines @@
     base::RunLoop::RemoveNestingObserverOnCurrentThread(observer);
   }
 
  private:
   explicit MessageLoopTaskRunner(std::unique_ptr<base::TickClock> tick_clock)
       : TaskQueueManagerDelegateForTest(base::ThreadTaskRunnerHandle::Get(),
                                         std::move(tick_clock)) {}
   ~MessageLoopTaskRunner() override {}
 };
 
-class TaskQueueManagerTest : public testing::Test {
+class TaskQueueManagerTest : public ::testing::Test {
  public:
   TaskQueueManagerTest() {}
   void DeleteTaskQueueManager() { manager_.reset(); }
 
  protected:
   void InitializeWithClock(size_t num_queues,
                            std::unique_ptr<base::TickClock> test_time_source) {
     test_task_runner_ = make_scoped_refptr(
         new cc::OrderedSimpleTaskRunner(now_src_.get(), false));
     main_task_runner_ = TaskQueueManagerDelegateForTest::Create(
@@ skipping 1677 matching lines @@
   base::TimeDelta delay10s(base::TimeDelta::FromSeconds(10));
 
   EXPECT_CALL(observer,
               OnQueueNextWakeUpChanged(runners_[0].get(), start_time + delay1s))
       .Times(1);
   EXPECT_CALL(observer, OnQueueNextWakeUpChanged(runners_[1].get(),
                                                  start_time + delay10s))
       .Times(1);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1s);
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay10s);
-  testing::Mock::VerifyAndClearExpectations(&observer);
+  ::testing::Mock::VerifyAndClearExpectations(&observer);
 
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
       runners_[0]->CreateQueueEnabledVoter();
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
       runners_[1]->CreateQueueEnabledVoter();
 
   // Disabling a queue should not trigger a notification.
   EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_, _)).Times(0);
   voter0->SetQueueEnabled(false);
   Mock::VerifyAndClearExpectations(&observer);
@@ skipping 1152 matching lines @@
   manager_->RegisterTimeDomain(domain.get());
   runners_[0]->SetTimeDomain(domain.get());
 
   // Tidy up.
   runners_[0]->UnregisterTaskQueue();
   manager_->UnregisterTimeDomain(domain.get());
 }
 
 }  // namespace scheduler
 }  // namespace blink