base/testutils.h: Use namespace webrtc::testing instead of plain testing

webrtc/base/socket_unittest.cc

 /*
  *  Copyright 2007 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
 #include "webrtc/base/socket_unittest.h"
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/asyncudpsocket.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/socketserver.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
+using webrtc::testing::SSE_CLOSE;
+using webrtc::testing::SSE_ERROR;
+using webrtc::testing::SSE_OPEN;
+using webrtc::testing::SSE_READ;
+using webrtc::testing::SSE_WRITE;
+using webrtc::testing::StreamSink;
+
 #define MAYBE_SKIP_IPV6                             \
   if (!HasIPv6Enabled()) {                          \
     LOG(LS_INFO) << "No IPv6... skipping";          \
     return;                                         \
   }
 
 // Data size to be used in TcpInternal tests.
 static const size_t kTcpInternalDataSize = 1024 * 1024;  // bytes
 
 void SocketTest::TestConnectIPv4() {
@@ skipping 160 matching lines @@
 // values on Windows, but an empty address of the same family on Linux/MacOS X.
 bool IsUnspecOrEmptyIP(const IPAddress& address) {
 #if !defined(WEBRTC_WIN)
   return IPIsAny(address);
 #else
   return address.family() == AF_UNSPEC;
 #endif
 }
 
 void SocketTest::ConnectInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
   EXPECT_PRED1(IsUnspecOrEmptyIP, client->GetLocalAddress().ipaddr());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, server->GetState());
 
   // Ensure no pending server connections, since we haven't done anything yet.
-  EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 
   // Attempt connect to listening socket.
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
   EXPECT_FALSE(client->GetLocalAddress().IsNil());
   EXPECT_NE(server->GetLocalAddress(), client->GetLocalAddress());
 
   // Client is connecting, outcome not yet determined.
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
 
   // Server has pending connection, accept it.
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
 
   // Connected from server perspective, check the addresses are correct.
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
 
   // Connected from client perspective, check the addresses are correct.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 }
 
 void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
                                               const std::string& host) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connect to listening socket.
   SocketAddress dns_addr(server->GetLocalAddress());
   dns_addr.SetIP(host);
   EXPECT_EQ(0, client->Connect(dns_addr));
   // TODO: Bind when doing DNS lookup.
   //EXPECT_NE(kEmptyAddr, client->GetLocalAddress());  // Implicit Bind
 
   // Client is connecting, outcome not yet determined.
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
 
   // Server has pending connection, accept it.
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   EXPECT_FALSE(accept_addr.IsNil());
   EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
 
   // Connected from server perspective, check the addresses are correct.
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
 
   // Connected from client perspective, check the addresses are correct.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 }
 
 void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
 
   // Attempt connect to a non-existent socket.
   // We don't connect to the server socket created above, since on
   // MacOS it takes about 75 seconds to get back an error!
   SocketAddress bogus_addr(loopback, 65535);
   EXPECT_EQ(0, client->Connect(bogus_addr));
 
   // Wait for connection to fail (ECONNREFUSED).
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
 
   // Should be no pending server connections.
-  EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
 }
 
 void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
@@ skipping 10 matching lines @@
   bool dns_lookup_finished = false;
   WAIT_(client->GetState() == AsyncSocket::CS_CLOSED, kTimeout,
         dns_lookup_finished);
   if (!dns_lookup_finished) {
     LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 "
                     << "seconds.";
     return;
   }
 
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
   // Should be no pending server connections.
-  EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 }
 
 void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Create a client and put in to CS_CLOSED state.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, client->Close());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
 
   // Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
   EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
 }
 
 void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
   // Create server and listen.
-  testing::StreamSink sink;
+  StreamSink sink;
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
   // Create client, connect.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
   EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState());
   // Try to connect again. Should fail, but not interfere with original attempt.
   EXPECT_EQ(SOCKET_ERROR,
             client->Connect(SocketAddress(server->GetLocalAddress())));
 
   // Accept the original connection.
   SocketAddress accept_addr;
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   EXPECT_FALSE(accept_addr.IsNil());
 
   // Check the states and addresses.
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 
   // Try to connect again, to an unresolved hostname.
   // Shouldn't break anything.
   EXPECT_EQ(SOCKET_ERROR,
             client->Connect(SocketAddress("localhost",
                                           server->GetLocalAddress().port())));
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 }
 
 void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connect to listening socket.
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
   // Close down the server while the socket is in the accept queue.
-  EXPECT_TRUE_WAIT(sink.Check(server.get(), testing::SSE_READ), kTimeout);
+  EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout);
   server->Close();
 
   // This should fail the connection for the client. Clean up.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
   client->Close();
 }
 
 void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connect to listening socket.
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
   // Close down the client while the socket is in the accept queue.
-  EXPECT_TRUE_WAIT(sink.Check(server.get(), testing::SSE_READ), kTimeout);
+  EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout);
   client->Close();
 
   // The connection should still be able to be accepted.
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
 
   // The accepted socket should then close (possibly with err, timing-related)
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, accepted->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(accepted.get(), testing::SSE_CLOSE) ||
-              sink.Check(accepted.get(), testing::SSE_ERROR));
+  EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) ||
+              sink.Check(accepted.get(), SSE_ERROR));
 
   // The client should not get a close event.
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
 }
 
 void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connection.
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
   // Accept connection.
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
 
   // Both sides are now connected.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
   // Send data to the client, and then close the connection.
   EXPECT_EQ(1, accepted->Send("a", 1));
   accepted->Close();
   EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
 
   // Expect that the client is notified, and has not yet closed.
-  EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
 
   // Ensure the data can be read.
   char buffer[10];
   EXPECT_EQ(1, client->Recv(buffer, sizeof(buffer), nullptr));
   EXPECT_EQ('a', buffer[0]);
 
   // Now we should close, but the remote address will remain.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
 
   // The closer should not get a close signal.
-  EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(accepted.get(), SSE_CLOSE));
   EXPECT_TRUE(accepted->GetRemoteAddress().IsNil());
 
   // And the closee should only get a single signal.
   Thread::Current()->ProcessMessages(0);
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
 
   // Close down the client and ensure all is good.
   client->Close();
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
 }
 
 class SocketCloser : public sigslot::has_slots<> {
  public:
   void OnClose(AsyncSocket* socket, int error) {
     socket->Close();  // Deleting here would blow up the vector of handlers
                       // for the socket's signal.
   }
 };
 
 void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketCloser closer;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connection.
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
   // Accept connection.
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
 
   // Both sides are now connected.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
   // Send data to the client, and then close the connection.
   accepted->Close();
   EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState());
 
   // Expect that the client is notified, and has not yet closed.
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState());
 
   // Now we should be closed and invalidated
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
 }
 
 class Sleeper : public MessageHandler {
  public:
   Sleeper() {}
   void OnMessage(Message* msg) {
     Thread::Current()->SleepMs(500);
   }
 };
 
 void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create & connect server and client sockets.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
 
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState());
   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
 
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
+  EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 
   // Do an i/o operation, triggering an eventual callback.
-  EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
   char buf[1024] = {0};
 
   EXPECT_EQ(1024, client->Send(buf, 1024));
-  EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
 
   // Shouldn't signal when blocked in a thread Send, where process_io is false.
   std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   Sleeper sleeper;
   TypedMessageData<AsyncSocket*> data(client.get());
   thread->Send(RTC_FROM_HERE, &sleeper, 0, &data);
-  EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
+  EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
 
   // But should signal when process_io is true.
-  EXPECT_TRUE_WAIT((sink.Check(accepted.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(accepted.get(), SSE_READ)), kTimeout);
   EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
 }
 
 void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
     ptrdiff_t max_send_size) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create receiving client.
   std::unique_ptr<AsyncSocket> receiver(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(receiver.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connection.
   EXPECT_EQ(0, receiver->Connect(server->GetLocalAddress()));
 
   // Accept connection which will be used for sending.
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> sender(server->Accept(&accept_addr));
   ASSERT_TRUE(sender);
   sink.Monitor(sender.get());
 
   // Both sides are now connected.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, receiver->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(receiver.get(), testing::SSE_OPEN));
+  EXPECT_TRUE(sink.Check(receiver.get(), SSE_OPEN));
   EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
   EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
 
   // Create test data.
   rtc::Buffer send_buffer(0, data_size);
   rtc::Buffer recv_buffer(0, data_size);
   for (size_t i = 0; i < data_size; ++i) {
     char ch = static_cast<char>(i % 256);
     send_buffer.AppendData(&ch, sizeof(ch));
   }
@@ skipping 31 matching lines @@
       } else {
         ASSERT_TRUE(sender->IsBlocking());
         writable = false;
       }
     }
 
     // Read all the sent data.
     while (recv_buffer.size() < sent_size) {
       if (!readable) {
         // Wait until data is available.
-        EXPECT_TRUE_WAIT(sink.Check(receiver.get(), testing::SSE_READ),
-            kTimeout);
+        EXPECT_TRUE_WAIT(sink.Check(receiver.get(), SSE_READ), kTimeout);
         readable = true;
         recv_called = false;
       }
 
       // Receive as much as we can get in a single recv call.
       int recved_size = receiver->Recv(recved_data.data(), data_size, nullptr);
 
       if (!recv_called) {
         // The first Recv() after getting readability should succeed and receive
         // some data.
         // TODO: The following line is disabled due to flakey pulse
         //     builds.  Re-enable if/when possible.
         // EXPECT_GT(recved_size, 0);
         recv_called = true;
       }
       if (recved_size >= 0) {
         EXPECT_LE(static_cast<size_t>(recved_size),
             sent_size - recv_buffer.size());
         recv_buffer.AppendData(recved_data.data(), recved_size);
       } else {
         ASSERT_TRUE(receiver->IsBlocking());
         readable = false;
       }
     }
 
     // Once all that we've sent has been received, expect to be able to send
     // again.
     if (!writable) {
-      ASSERT_TRUE_WAIT(sink.Check(sender.get(), testing::SSE_WRITE),
-                       kTimeout);
+      ASSERT_TRUE_WAIT(sink.Check(sender.get(), SSE_WRITE), kTimeout);
       writable = true;
       send_called = false;
     }
   }
 
   // The received data matches the sent data.
   EXPECT_EQ(data_size, sent_size);
   EXPECT_EQ(data_size, recv_buffer.size());
   EXPECT_EQ(recv_buffer, send_buffer);
 
   // Close down.
   sender->Close();
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, receiver->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(receiver.get(), testing::SSE_CLOSE));
+  EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE));
   receiver->Close();
 }
 
 void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
-  testing::StreamSink sink;
+  StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
   std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
 
   // Attempt connection.
   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
   // Accept connection.
-  EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
+  EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
   std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
   ASSERT_TRUE(accepted);
   sink.Monitor(accepted.get());
 
   // Both sides are now connected.
   EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout);
-  EXPECT_TRUE(sink.Check(client.get(), testing::SSE_OPEN));
+  EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
   // Expect a writable callback from the connect.
-  EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE), kTimeout);
+  EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout);
 
   // Fill the socket buffer.
   char buf[1024 * 16] = {0};
   int sends = 0;
   while (++sends && accepted->Send(&buf, arraysize(buf)) != -1) {}
   EXPECT_TRUE(accepted->IsBlocking());
 
   // Wait until data is available.
-  EXPECT_TRUE_WAIT(sink.Check(client.get(), testing::SSE_READ), kTimeout);
+  EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
 
   // Pull data.
   for (int i = 0; i < sends; ++i) {
     client->Recv(buf, arraysize(buf), nullptr);
   }
 
   // Expect at least one additional writable callback.
-  EXPECT_TRUE_WAIT(sink.Check(accepted.get(), testing::SSE_WRITE), kTimeout);
+  EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout);
 
   // Adding data in response to the writeable callback shouldn't cause infinite
   // callbacks.
   int extras = 0;
   for (int i = 0; i < 100; ++i) {
     accepted->Send(&buf, arraysize(buf));
     rtc::Thread::Current()->ProcessMessages(1);
-    if (sink.Check(accepted.get(), testing::SSE_WRITE)) {
+    if (sink.Check(accepted.get(), SSE_WRITE)) {
       extras++;
     }
   }
   EXPECT_LT(extras, 2);
 
   // Close down.
   accepted->Close();
   client->Close();
 }
 
@@ skipping 169 matching lines @@
   socket->RecvFrom(buffer, 3, nullptr, &recv_timestamp_2);
 
   int64_t system_time_diff = send_time_2 - send_time_1;
   int64_t recv_timestamp_diff = recv_timestamp_2 - recv_timestamp_1;
   // Compare against the system time at the point of sending, because
   // SleepMs may not sleep for exactly the requested time.
   EXPECT_NEAR(system_time_diff, recv_timestamp_diff, 10000);
 }
 
 }  // namespace rtc