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

third_party/WebKit/Source/platform/graphics/gpu/DrawingBufferTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 29 matching lines @@
 #include "platform/graphics/CanvasColorParams.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/DrawingBufferTestHelpers.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefPtr.h"
 #include "public/platform/Platform.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::Test;
-using testing::_;
+using ::testing::Test;
+using ::testing::_;
 
 namespace blink {
 
 namespace {
 
 class FakePlatformSupport : public TestingPlatformSupport {
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override {
     return &test_gpu_memory_buffer_manager_;
   }
 
@@ skipping 341 matching lines @@
     RuntimeEnabledFeatures::SetWebGLImageChromiumEnabled(true);
     GLES2InterfaceForTests* gl_ =
         static_cast<GLES2InterfaceForTests*>(provider->ContextGL());
     image_id0_ = gl_->NextImageIdToBeCreated();
     EXPECT_CALL(*gl_, BindTexImage2DMock(image_id0_)).Times(1);
     drawing_buffer_ = DrawingBufferForTests::Create(
         std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve,
         kDisableMultisampling);
     CHECK(drawing_buffer_);
     SetAndSaveRestoreState(true);
-    testing::Mock::VerifyAndClearExpectations(gl_);
+    ::testing::Mock::VerifyAndClearExpectations(gl_);
   }
 
   void TearDown() override {
     RuntimeEnabledFeatures::SetWebGLImageChromiumEnabled(false);
     platform_.reset();
   }
 
   GLuint image_id0_;
   std::unique_ptr<ScopedTestingPlatformSupport<FakePlatformSupport>> platform_;
 };
 
 TEST_F(DrawingBufferImageChromiumTest, verifyResizingReallocatesImages) {
   GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   IntSize initial_size(kInitialWidth, kInitialHeight);
   IntSize alternate_size(kInitialWidth, kAlternateHeight);
 
   GLuint image_id1 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id1)).Times(1);
   // Produce one mailbox at size 100x100.
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
   VerifyStateWasRestored();
 
   GLuint image_id2 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id2)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id0_)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id0_)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id1)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id1)).Times(1);
   // Resize to 100x50.
   drawing_buffer_->Resize(alternate_size);
   VerifyStateWasRestored();
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   VerifyStateWasRestored();
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
 
   GLuint image_id3 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id3)).Times(1);
   // Produce a mailbox at this size.
   EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(alternate_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
 
   GLuint image_id4 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id4)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id2)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id2)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id3)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id3)).Times(1);
   // Reset to initial size.
   drawing_buffer_->Resize(initial_size);
   VerifyStateWasRestored();
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   VerifyStateWasRestored();
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
 
   GLuint image_id5 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id5)).Times(1);
   // Prepare another mailbox and verify that it's the correct size.
   EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
 
   // Prepare one final mailbox and verify that it's the correct size.
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
 
   EXPECT_CALL(*gl_, DestroyImageMock(image_id5)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id5)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id4)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id4)).Times(1);
   drawing_buffer_->BeginDestruction();
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
 }
 
 TEST_F(DrawingBufferImageChromiumTest, allocationFailure) {
   GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   cc::TextureMailbox texture_mailbox1;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback1;
   cc::TextureMailbox texture_mailbox2;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback2;
   cc::TextureMailbox texture_mailbox3;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback3;
 
   // Request a mailbox. An image should already be created. Everything works
   // as expected.
   EXPECT_CALL(*gl_, BindTexImage2DMock(_)).Times(1);
   IntSize initial_size(kInitialWidth, kInitialHeight);
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox1,
                                                      &release_callback1));
   EXPECT_TRUE(texture_mailbox1.is_overlay_candidate());
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
   VerifyStateWasRestored();
 
   // Force image CHROMIUM creation failure. Request another mailbox. It should
   // still be provided, but this time with allowOverlay = false.
   gl_->SetCreateImageChromiumFail(true);
   EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox2,
                                                      &release_callback2));
   EXPECT_FALSE(texture_mailbox2.is_overlay_candidate());
   VerifyStateWasRestored();
 
   // Check that if image CHROMIUM starts working again, mailboxes are
   // correctly created with allowOverlay = true.
   EXPECT_CALL(*gl_, BindTexImage2DMock(_)).Times(1);
   gl_->SetCreateImageChromiumFail(false);
   EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox3,
                                                      &release_callback3));
   EXPECT_TRUE(texture_mailbox3.is_overlay_candidate());
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
   VerifyStateWasRestored();
 
   release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
   release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
   release_callback3->Run(gpu::SyncToken(), false /* lostResource */);
 
   EXPECT_CALL(*gl_, DestroyImageMock(_)).Times(3);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(_)).Times(3);
   drawing_buffer_->BeginDestruction();
-  testing::Mock::VerifyAndClearExpectations(gl_);
+  ::testing::Mock::VerifyAndClearExpectations(gl_);
 }
 
 class DepthStencilTrackingGLES2Interface
     : public gpu::gles2::GLES2InterfaceStub {
  public:
   void FramebufferRenderbuffer(GLenum target,
                                GLenum attachment,
                                GLenum renderbuffertarget,
                                GLuint renderbuffer) override {
     switch (attachment) {
@@ skipping 154 matching lines @@
   drawing_buffer_->SetIsHidden(true);
   release_callback->Run(wait_sync_token, false /* lostResource */);
   // m_drawingBuffer deletes mailbox immediately when hidden.
 
   EXPECT_EQ(wait_sync_token, gl_->MostRecentlyWaitedSyncToken());
 
   drawing_buffer_->BeginDestruction();
 }
 
 }  // namespace blink