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

third_party/WebKit/Source/modules/websockets/DocumentWebSocketChannelTest.cpp

 // 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 "modules/websockets/DocumentWebSocketChannel.h"
 
 #include <stdint.h>
 #include <memory>
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #include "core/fileapi/Blob.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/websockets/WebSocketChannel.h"
 #include "modules/websockets/WebSocketChannelClient.h"
 #include "modules/websockets/WebSocketHandle.h"
 #include "modules/websockets/WebSocketHandleClient.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/WebCallbacks.h"
 #include "public/platform/WebSocketHandshakeThrottle.h"
 #include "public/platform/WebURL.h"
 #include "public/web/WebLocalFrame.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::_;
-using testing::InSequence;
-using testing::PrintToString;
-using testing::AnyNumber;
-using testing::SaveArg;
+using ::testing::_;
+using ::testing::InSequence;
+using ::testing::PrintToString;
+using ::testing::AnyNumber;
+using ::testing::SaveArg;
 
 namespace blink {
 
 namespace {
 
-typedef testing::StrictMock<testing::MockFunction<void(int)>> Checkpoint;
+typedef ::testing::StrictMock<::testing::MockFunction<void(int)>> Checkpoint;
 
 class MockWebSocketChannelClient
     : public GarbageCollectedFinalized<MockWebSocketChannelClient>,
       public WebSocketChannelClient {
   USING_GARBAGE_COLLECTED_MIXIN(MockWebSocketChannelClient);
 
  public:
   static MockWebSocketChannelClient* Create() {
-    return new testing::StrictMock<MockWebSocketChannelClient>();
+    return new ::testing::StrictMock<MockWebSocketChannelClient>();
   }
 
   MockWebSocketChannelClient() {}
 
   ~MockWebSocketChannelClient() override {}
 
   MOCK_METHOD2(DidConnect, void(const String&, const String&));
   MOCK_METHOD1(DidReceiveTextMessage, void(const String&));
   void DidReceiveBinaryMessage(std::unique_ptr<Vector<char>> payload) override {
     DidReceiveBinaryMessageMock(*payload);
   }
   MOCK_METHOD1(DidReceiveBinaryMessageMock, void(const Vector<char>&));
   MOCK_METHOD0(DidError, void());
   MOCK_METHOD1(DidConsumeBufferedAmount, void(uint64_t));
   MOCK_METHOD0(DidStartClosingHandshake, void());
   MOCK_METHOD3(DidClose,
                void(ClosingHandshakeCompletionStatus,
                     unsigned short,
                     const String&));
 
   DEFINE_INLINE_VIRTUAL_TRACE() { WebSocketChannelClient::Trace(visitor); }
 };
 
 class MockWebSocketHandle : public WebSocketHandle {
  public:
   static MockWebSocketHandle* Create() {
-    return new testing::StrictMock<MockWebSocketHandle>();
+    return new ::testing::StrictMock<MockWebSocketHandle>();
   }
 
   MockWebSocketHandle() {}
 
   ~MockWebSocketHandle() override {}
 
   MOCK_METHOD1(DoInitialize, void(mojom::blink::WebSocketPtr*));
   void Initialize(mojom::blink::WebSocketPtr websocket) override {
     DoInitialize(&websocket);
   }
 
   MOCK_METHOD6(Connect,
                void(const KURL&,
                     const Vector<String>&,
                     SecurityOrigin*,
                     const KURL&,
                     const String&,
                     WebSocketHandleClient*));
   MOCK_METHOD4(Send,
                void(bool, WebSocketHandle::MessageType, const char*, size_t));
   MOCK_METHOD1(FlowControl, void(int64_t));
   MOCK_METHOD2(Close, void(unsigned short, const String&));
 };
 
 class MockWebSocketHandshakeThrottle : public WebSocketHandshakeThrottle {
  public:
   static MockWebSocketHandshakeThrottle* Create() {
-    return new testing::StrictMock<MockWebSocketHandshakeThrottle>();
+    return new ::testing::StrictMock<MockWebSocketHandshakeThrottle>();
   }
   MockWebSocketHandshakeThrottle() {}
   ~MockWebSocketHandshakeThrottle() override { Destructor(); }
 
   MOCK_METHOD3(ThrottleHandshake,
                void(const WebURL&,
                     WebLocalFrame*,
                     WebCallbacks<void, const WebString&>*));
 
   // This method is used to allow us to require that the destructor is called at
@@ skipping 908 matching lines @@
   }
   Channel()->Connect(url(), "");
   HandleClient()->DidClose(Handle(), false,
                            WebSocketChannel::kCloseEventCodeProtocolError,
                            "connect error");
 }
 
 }  // namespace
 
 }  // namespace blink