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

third_party/WebKit/Source/platform/scheduler/child/webthread_impl_for_worker_scheduler_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/webthread_impl_for_worker_scheduler.h"
 
 #include "base/macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/scheduler/child/web_scheduler_impl.h"
 #include "platform/scheduler/child/worker_scheduler_impl.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::_;
-using testing::AnyOf;
-using testing::ElementsAre;
-using testing::Invoke;
+using ::testing::_;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::Invoke;
 
 namespace blink {
 namespace scheduler {
 namespace {
 
 class MockTask {
  public:
   MOCK_METHOD0(Run, void());
 };
 
@@ skipping 33 matching lines @@
 }
 
 void ShutdownOnThread(WebThreadImplForWorkerScheduler* thread) {
   WebSchedulerImpl* web_scheduler_impl =
       static_cast<WebSchedulerImpl*>(thread->Scheduler());
   web_scheduler_impl->Shutdown();
 }
 
 }  // namespace
 
-class WebThreadImplForWorkerSchedulerTest : public testing::Test {
+class WebThreadImplForWorkerSchedulerTest : public ::testing::Test {
  public:
   WebThreadImplForWorkerSchedulerTest() {}
 
   ~WebThreadImplForWorkerSchedulerTest() override {}
 
   void SetUp() override {
     thread_.reset(new WebThreadImplForWorkerScheduler("test thread"));
     thread_->Init();
   }
 
@@ skipping 82 matching lines @@
   thread_->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE, WTF::Bind(&RunTestTask, WTF::Unretained(&calls)));
   RunOnWorkerThread(FROM_HERE,
                     base::Bind(&RemoveTaskObserver, thread_.get(), &observer));
 
   // We need to be careful what we test here.  We want to make sure the
   // observers are un in the expected order before and after the task.
   // Sometimes we get an internal scheduler task running before or after
   // TestTask as well. This is not a bug, and we need to make sure the test
   // doesn't fail when that happens.
-  EXPECT_THAT(calls, testing::HasSubstr("willProcessTask run didProcessTask"));
+  EXPECT_THAT(calls,
+              ::testing::HasSubstr("willProcessTask run didProcessTask"));
 }
 
 TEST_F(WebThreadImplForWorkerSchedulerTest, TestShutdown) {
   MockTask task;
   MockTask delayed_task;
 
   EXPECT_CALL(task, Run()).Times(0);
   EXPECT_CALL(delayed_task, Run()).Times(0);
 
   RunOnWorkerThread(FROM_HERE, base::Bind(&ShutdownOnThread, thread_.get()));
   thread_->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE, WTF::Bind(&MockTask::Run, WTF::Unretained(&task)));
   thread_->GetWebTaskRunner()->PostDelayedTask(
       BLINK_FROM_HERE,
       WTF::Bind(&MockTask::Run, WTF::Unretained(&delayed_task)),
       TimeDelta::FromMilliseconds(50));
   thread_.reset();
 }
 
 }  // namespace scheduler
 }  // namespace blink