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

third_party/WebKit/Source/platform/scheduler/renderer/webthread_impl_for_renderer_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/renderer/webthread_impl_for_renderer_scheduler.h"
 
 #include <stddef.h>
 
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 21 matching lines @@
   MOCK_METHOD0(Run, void());
 };
 
 class MockTaskObserver : public blink::WebThread::TaskObserver {
  public:
   MOCK_METHOD0(WillProcessTask, void());
   MOCK_METHOD0(DidProcessTask, void());
 };
 }  // namespace
 
-class WebThreadImplForRendererSchedulerTest : public testing::Test {
+class WebThreadImplForRendererSchedulerTest : public ::testing::Test {
  public:
   WebThreadImplForRendererSchedulerTest() {}
 
   void SetUp() override {
     clock_.reset(new base::SimpleTestTickClock());
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
     scheduler_.reset(new RendererSchedulerImpl(SchedulerTqmDelegateImpl::Create(
         &message_loop_, base::MakeUnique<TestTimeSource>(clock_.get()))));
     default_task_runner_ = scheduler_->DefaultTaskQueue();
     thread_ = scheduler_->CreateMainThread();
@@ skipping 17 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WebThreadImplForRendererSchedulerTest);
 };
 
 TEST_F(WebThreadImplForRendererSchedulerTest, TestTaskObserver) {
   MockTaskObserver observer;
   thread_->AddTaskObserver(&observer);
   MockTask task;
 
   {
-    testing::InSequence sequence;
+    ::testing::InSequence sequence;
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task, Run());
     EXPECT_CALL(observer, DidProcessTask());
   }
 
   thread_->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE, WTF::Bind(&MockTask::Run, WTF::Unretained(&task)));
   base::RunLoop().RunUntilIdle();
   thread_->RemoveTaskObserver(&observer);
 }
 
 TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithOneTask) {
   MockTaskObserver observer;
   thread_->AddTaskObserver(&observer);
   MockTask task;
 
   SetWorkBatchSizeForTesting(kWorkBatchSize);
   {
-    testing::InSequence sequence;
+    ::testing::InSequence sequence;
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task, Run());
     EXPECT_CALL(observer, DidProcessTask());
   }
 
   thread_->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE, WTF::Bind(&MockTask::Run, WTF::Unretained(&task)));
   base::RunLoop().RunUntilIdle();
   thread_->RemoveTaskObserver(&observer);
 }
 
 TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithTwoTasks) {
   MockTaskObserver observer;
   thread_->AddTaskObserver(&observer);
   MockTask task1;
   MockTask task2;
 
   SetWorkBatchSizeForTesting(kWorkBatchSize);
   {
-    testing::InSequence sequence;
+    ::testing::InSequence sequence;
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task1, Run());
     EXPECT_CALL(observer, DidProcessTask());
 
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task2, Run());
     EXPECT_CALL(observer, DidProcessTask());
   }
 
   thread_->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE, WTF::Bind(&MockTask::Run, WTF::Unretained(&task1)));
   thread_->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE, WTF::Bind(&MockTask::Run, WTF::Unretained(&task2)));
   base::RunLoop().RunUntilIdle();
   thread_->RemoveTaskObserver(&observer);
 }
 
 TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithThreeTasks) {
   MockTaskObserver observer;
   thread_->AddTaskObserver(&observer);
   MockTask task1;
   MockTask task2;
   MockTask task3;
 
   SetWorkBatchSizeForTesting(kWorkBatchSize);
   {
-    testing::InSequence sequence;
+    ::testing::InSequence sequence;
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task1, Run());
     EXPECT_CALL(observer, DidProcessTask());
 
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task2, Run());
     EXPECT_CALL(observer, DidProcessTask());
 
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(task3, Run());
@@ skipping 19 matching lines @@
       WTF::Bind(&base::RunLoop::Quit, WTF::Unretained(&run_loop)));
   message_loop->SetNestableTasksAllowed(true);
   run_loop.Run();
 }
 
 TEST_F(WebThreadImplForRendererSchedulerTest, TestNestedRunLoop) {
   MockTaskObserver observer;
   thread_->AddTaskObserver(&observer);
 
   {
-    testing::InSequence sequence;
+    ::testing::InSequence sequence;
 
     // One callback for EnterRunLoop.
     EXPECT_CALL(observer, WillProcessTask());
 
     // A pair for ExitRunLoopTask.
     EXPECT_CALL(observer, WillProcessTask());
     EXPECT_CALL(observer, DidProcessTask());
 
     // A final callback for EnterRunLoop.
     EXPECT_CALL(observer, DidProcessTask());
   }
 
   message_loop_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&EnterRunLoop, base::Unretained(&message_loop_),
                             base::Unretained(thread_.get())));
   base::RunLoop().RunUntilIdle();
   thread_->RemoveTaskObserver(&observer);
 }
 
 }  // namespace scheduler
 }  // namespace blink