Refactor TestClient to use std::unique_ptr, and fix VirtualSocketServerTest leaks.

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 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 <math.h>
 #include <time.h>
 #if defined(WEBRTC_POSIX)
 #include <netinet/in.h>
 #endif
 
 #include <memory>
 
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/gunit.h"
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using 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;
 
 // Sends at a constant rate but with random packet sizes.
 struct Sender : public MessageHandler {
   Sender(Thread* th, AsyncSocket* s, uint32_t rt)
       : thread(th),
-        socket(new AsyncUDPSocket(s)),
+        socket(MakeUnique<AsyncUDPSocket>(s)),
         done(false),
         rate(rt),
         count(0) {
     last_send = rtc::TimeMillis();
     thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
   }
 
   uint32_t NextDelay() {
     uint32_t size = (rand() % 4096) + 1;
     return 1000 * size / rate;
@@ skipping 25 matching lines @@
   bool done;
   uint32_t rate;  // bytes per second
   uint32_t count;
   int64_t last_send;
   char dummy[4096];
 };
 
 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
   Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
       : thread(th),
-        socket(new AsyncUDPSocket(s)),
+        socket(MakeUnique<AsyncUDPSocket>(s)),
         bandwidth(bw),
         done(false),
         count(0),
         sec_count(0),
         sum(0),
         sum_sq(0),
         samples(0) {
     socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
     thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
   }
@@ skipping 40 matching lines @@
   size_t count;
   size_t sec_count;
   double sum;
   double sum_sq;
   uint32_t samples;
 };
 
 class VirtualSocketServerTest : public testing::Test {
  public:
   VirtualSocketServerTest()
-      : ss_(new VirtualSocketServer(nullptr)),
+      : ss_(nullptr),
         kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
         kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
 
   void CheckPortIncrementalization(const SocketAddress& post,
                                    const SocketAddress& pre) {
     EXPECT_EQ(post.port(), pre.port() + 1);
     IPAddress post_ip = post.ipaddr();
     IPAddress pre_ip = pre.ipaddr();
     EXPECT_EQ(pre_ip.family(), post_ip.family());
     if (post_ip.family() == AF_INET) {
       in_addr pre_ipv4 = pre_ip.ipv4_address();
       in_addr post_ipv4 = post_ip.ipv4_address();
       EXPECT_EQ(post_ipv4.s_addr, pre_ipv4.s_addr);
     } else if (post_ip.family() == AF_INET6) {
       in6_addr post_ip6 = post_ip.ipv6_address();
       in6_addr pre_ip6 = pre_ip.ipv6_address();
       uint32_t* post_as_ints = reinterpret_cast<uint32_t*>(&post_ip6.s6_addr);
       uint32_t* pre_as_ints = reinterpret_cast<uint32_t*>(&pre_ip6.s6_addr);
       EXPECT_EQ(post_as_ints[3], pre_as_ints[3]);
     }
   }
 
   // Test a client can bind to the any address, and all sent packets will have
   // the default route as the source address. Also, it can receive packets sent
   // to the default route.
   void TestDefaultRoute(const IPAddress& default_route) {
-    ss_->SetDefaultRoute(default_route);
+    ss_.SetDefaultRoute(default_route);
 
     // Create client1 bound to the any address.
     AsyncSocket* socket =
-        ss_->CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
+        ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
     socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
     SocketAddress client1_any_addr = socket->GetLocalAddress();
     EXPECT_TRUE(client1_any_addr.IsAnyIP());
-    TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
 
     // Create client2 bound to the default route.
     AsyncSocket* socket2 =
-        ss_->CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
+        ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
     socket2->Bind(SocketAddress(default_route, 0));
     SocketAddress client2_addr = socket2->GetLocalAddress();
     EXPECT_FALSE(client2_addr.IsAnyIP());
-    TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
 
     // Client1 sends to client2, client2 should see the default route as
     // client1's address.
     SocketAddress client1_addr;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
     EXPECT_EQ(client1_addr,
               SocketAddress(default_route, client1_any_addr.port()));
 
     // Client2 can send back to client1's default route address.
     EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
   }
 
   void BasicTest(const SocketAddress& initial_addr) {
-    AsyncSocket* socket = ss_->CreateAsyncSocket(initial_addr.family(),
-                                                 SOCK_DGRAM);
+    AsyncSocket* socket =
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     socket->Bind(initial_addr);
     SocketAddress server_addr = socket->GetLocalAddress();
     // Make sure VSS didn't switch families on us.
     EXPECT_EQ(server_addr.family(), initial_addr.family());
 
-    TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
     AsyncSocket* socket2 =
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
-    TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
 
     SocketAddress client2_addr;
     EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
 
     SocketAddress client1_addr;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
     EXPECT_EQ(client1_addr, server_addr);
 
     SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
     for (int i = 0; i < 10; i++) {
-      client2 = new TestClient(AsyncUDPSocket::Create(ss_, empty));
+      client2 = MakeUnique<TestClient>(
+          WrapUnique(AsyncUDPSocket::Create(&ss_, empty)));
 
       SocketAddress next_client2_addr;
       EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
       CheckPortIncrementalization(next_client2_addr, client2_addr);
       // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
 
       SocketAddress server_addr2;
       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
       EXPECT_EQ(server_addr2, server_addr);
 
       client2_addr = next_client2_addr;
     }
   }
 
   // initial_addr should be made from either INADDR_ANY or in6addr_any.
   void ConnectTest(const SocketAddress& initial_addr) {
     StreamSink sink;
     SocketAddress accept_addr;
     const SocketAddress kEmptyAddr =
         EmptySocketAddressWithFamily(initial_addr.family());
 
     // Create client
-    AsyncSocket* client = ss_->CreateAsyncSocket(initial_addr.family(),
-                                                 SOCK_STREAM);
+    AsyncSocket* client =
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(client);
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_TRUE(client->GetLocalAddress().IsNil());
 
     // Create server
-    AsyncSocket* server = ss_->CreateAsyncSocket(initial_addr.family(),
-                                                 SOCK_STREAM);
+    AsyncSocket* server =
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(server);
     EXPECT_NE(0, server->Listen(5));  // Bind required
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
 
     // No pending server connections
     EXPECT_FALSE(sink.Check(server, SSE_READ));
     EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
     EXPECT_EQ(AF_UNSPEC, accept_addr.family());
 
     // Attempt connect to listening socket
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
     EXPECT_NE(client->GetLocalAddress(), kEmptyAddr);  // Implicit Bind
     EXPECT_NE(AF_UNSPEC, client->GetLocalAddress().family());  // Implicit Bind
     EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
 
     // Client is connecting
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     EXPECT_FALSE(sink.Check(client, SSE_OPEN));
     EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Client still connecting
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     EXPECT_FALSE(sink.Check(client, SSE_OPEN));
     EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
 
     // Server has pending connection
     EXPECT_TRUE(sink.Check(server, SSE_READ));
     Socket* accepted = server->Accept(&accept_addr);
     EXPECT_TRUE(nullptr != accepted);
     EXPECT_NE(accept_addr, kEmptyAddr);
     EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
 
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
     EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
     EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Client has connected
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
     EXPECT_TRUE(sink.Check(client, SSE_OPEN));
     EXPECT_FALSE(sink.Check(client, SSE_CLOSE));
     EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
     EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   }
 
   void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
     StreamSink sink;
     SocketAddress accept_addr;
     const SocketAddress nil_addr;
     const SocketAddress empty_addr =
         EmptySocketAddressWithFamily(initial_addr.family());
 
     // Create client
-    AsyncSocket* client = ss_->CreateAsyncSocket(initial_addr.family(),
-                                                 SOCK_STREAM);
+    AsyncSocket* client =
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(client);
 
     // Create server
-    AsyncSocket* server = ss_->CreateAsyncSocket(initial_addr.family(),
-                                                 SOCK_STREAM);
+    AsyncSocket* server =
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(server);
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
     // Attempt connect to non-listening socket
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // No pending server connections
     EXPECT_FALSE(sink.Check(server, SSE_READ));
     EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
     EXPECT_EQ(accept_addr, nil_addr);
 
     // Connection failed
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_FALSE(sink.Check(client, SSE_OPEN));
     EXPECT_TRUE(sink.Check(client, SSE_ERROR));
     EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
   }
 
   void CloseDuringConnectTest(const SocketAddress& initial_addr) {
     StreamSink sink;
     SocketAddress accept_addr;
     const SocketAddress empty_addr =
         EmptySocketAddressWithFamily(initial_addr.family());
 
     // Create client and server
     std::unique_ptr<AsyncSocket> client(
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(client.get());
     std::unique_ptr<AsyncSocket> server(
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(server.get());
 
     // Initiate connect
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
     // Server close before socket enters accept queue
     EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
     server->Close();
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Result: connection failed
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
 
-    server.reset(ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+    server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(server.get());
 
     // Initiate connect
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Server close while socket is in accept queue
     EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
     server->Close();
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Result: connection failed
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
 
     // New server
-    server.reset(ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+    server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(server.get());
 
     // Initiate connect
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Server accepts connection
     EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
     std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
     ASSERT_TRUE(nullptr != accepted.get());
     sink.Monitor(accepted.get());
 
     // Client closes before connection complets
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
 
     // Connected message has not been processed yet.
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     client->Close();
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // Result: accepted socket closes
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
     EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
   }
 
   void CloseTest(const SocketAddress& initial_addr) {
     StreamSink sink;
     const SocketAddress kEmptyAddr;
 
     // Create clients
-    AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+    AsyncSocket* a = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(a);
     a->Bind(initial_addr);
     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
 
     std::unique_ptr<AsyncSocket> b(
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
     sink.Monitor(b.get());
     b->Bind(initial_addr);
     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     EXPECT_TRUE(sink.Check(a, SSE_OPEN));
     EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
     EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
 
     EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN));
     EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
     EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
 
     EXPECT_EQ(1, a->Send("a", 1));
     b->Close();
     EXPECT_EQ(1, a->Send("b", 1));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     char buffer[10];
     EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
     EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
 
     EXPECT_TRUE(sink.Check(a, SSE_CLOSE));
     EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
 
     // No signal for Closer
     EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE));
     EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
   }
 
   void TcpSendTest(const SocketAddress& initial_addr) {
     StreamSink sink;
     const SocketAddress kEmptyAddr;
 
     // Connect two sockets
-    AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+    AsyncSocket* a = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(a);
     a->Bind(initial_addr);
     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
 
-    AsyncSocket* b = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+    AsyncSocket* b = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     sink.Monitor(b);
     b->Bind(initial_addr);
     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     const size_t kBufferSize = 2000;
-    ss_->set_send_buffer_capacity(kBufferSize);
-    ss_->set_recv_buffer_capacity(kBufferSize);
+    ss_.set_send_buffer_capacity(kBufferSize);
+    ss_.set_recv_buffer_capacity(kBufferSize);
 
     const size_t kDataSize = 5000;
     char send_buffer[kDataSize], recv_buffer[kDataSize];
     for (size_t i = 0; i < kDataSize; ++i)
       send_buffer[i] = static_cast<char>(i % 256);
     memset(recv_buffer, 0, sizeof(recv_buffer));
     size_t send_pos = 0, recv_pos = 0;
 
     // Can't send more than send buffer in one write
     int result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(static_cast<int>(kBufferSize), result);
     send_pos += result;
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
     EXPECT_FALSE(sink.Check(a, SSE_WRITE));
     EXPECT_TRUE(sink.Check(b, SSE_READ));
 
     // Receive buffer is already filled, fill send buffer again
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(static_cast<int>(kBufferSize), result);
     send_pos += result;
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
     EXPECT_FALSE(sink.Check(a, SSE_WRITE));
     EXPECT_FALSE(sink.Check(b, SSE_READ));
 
     // No more room in send or receive buffer
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(-1, result);
     EXPECT_TRUE(a->IsBlocking());
 
     // Read a subset of the data
     result = b->Recv(recv_buffer + recv_pos, 500, nullptr);
     EXPECT_EQ(500, result);
     recv_pos += result;
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
     EXPECT_TRUE(sink.Check(a, SSE_WRITE));
     EXPECT_TRUE(sink.Check(b, SSE_READ));
 
     // Room for more on the sending side
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(500, result);
     send_pos += result;
 
     // Empty the recv buffer
     while (true) {
       result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
       if (result < 0) {
         EXPECT_EQ(-1, result);
         EXPECT_TRUE(b->IsBlocking());
         break;
       }
       recv_pos += result;
     }
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
     EXPECT_TRUE(sink.Check(b, SSE_READ));
 
     // Continue to empty the recv buffer
     while (true) {
       result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
       if (result < 0) {
         EXPECT_EQ(-1, result);
         EXPECT_TRUE(b->IsBlocking());
         break;
       }
       recv_pos += result;
     }
 
     // Send last of the data
     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
     EXPECT_EQ(500, result);
     send_pos += result;
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
     EXPECT_TRUE(sink.Check(b, SSE_READ));
 
     // Receive the last of the data
     while (true) {
       result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
       if (result < 0) {
         EXPECT_EQ(-1, result);
         EXPECT_TRUE(b->IsBlocking());
         break;
       }
       recv_pos += result;
     }
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
     EXPECT_FALSE(sink.Check(b, SSE_READ));
 
     // The received data matches the sent data
     EXPECT_EQ(kDataSize, send_pos);
     EXPECT_EQ(kDataSize, recv_pos);
     EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
   }
 
   void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
     const SocketAddress kEmptyAddr;
 
     // Connect two sockets
-    AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(),
-                                            SOCK_STREAM);
-    AsyncSocket* b = ss_->CreateAsyncSocket(initial_addr.family(),
-                                            SOCK_STREAM);
+    AsyncSocket* a = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
+    AsyncSocket* b = ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM);
     a->Bind(initial_addr);
     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
 
     b->Bind(initial_addr);
     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     // First, deliver all packets in 0 ms.
     char buffer[2] = { 0, 0 };
     const char cNumPackets = 10;
     for (char i = 0; i < cNumPackets; ++i) {
       buffer[0] = '0' + i;
       EXPECT_EQ(1, a->Send(buffer, 1));
     }
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     for (char i = 0; i < cNumPackets; ++i) {
       EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
       EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
     }
 
     // Next, deliver packets at random intervals
     const uint32_t mean = 50;
     const uint32_t stddev = 50;
 
-    ss_->set_delay_mean(mean);
-    ss_->set_delay_stddev(stddev);
-    ss_->UpdateDelayDistribution();
+    ss_.set_delay_mean(mean);
+    ss_.set_delay_stddev(stddev);
+    ss_.UpdateDelayDistribution();
 
     for (char i = 0; i < cNumPackets; ++i) {
       buffer[0] = 'A' + i;
       EXPECT_EQ(1, a->Send(buffer, 1));
     }
 
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     for (char i = 0; i < cNumPackets; ++i) {
       EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
       EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
     }
   }
 
   // It is important that initial_addr's port has to be 0 such that the
   // incremental port behavior could ensure the 2 Binds result in different
   // address.
   void BandwidthTest(const SocketAddress& initial_addr) {
     AsyncSocket* send_socket =
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     AsyncSocket* recv_socket =
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     ASSERT_EQ(0, send_socket->Bind(initial_addr));
     ASSERT_EQ(0, recv_socket->Bind(initial_addr));
     EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
 
     uint32_t bandwidth = 64 * 1024;
-    ss_->set_bandwidth(bandwidth);
+    ss_.set_bandwidth(bandwidth);
 
     Thread* pthMain = Thread::Current();
     Sender sender(pthMain, send_socket, 80 * 1024);
     Receiver receiver(pthMain, recv_socket, bandwidth);
 
     pthMain->ProcessMessages(5000);
     sender.done = true;
     pthMain->ProcessMessages(5000);
 
     ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
     ASSERT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
 
-    ss_->set_bandwidth(0);
+    ss_.set_bandwidth(0);
   }
 
   // It is important that initial_addr's port has to be 0 such that the
   // incremental port behavior could ensure the 2 Binds result in different
   // address.
   void DelayTest(const SocketAddress& initial_addr) {
     time_t seed = ::time(nullptr);
     LOG(LS_VERBOSE) << "seed = " << seed;
     srand(static_cast<unsigned int>(seed));
 
     const uint32_t mean = 2000;
     const uint32_t stddev = 500;
 
-    ss_->set_delay_mean(mean);
-    ss_->set_delay_stddev(stddev);
-    ss_->UpdateDelayDistribution();
+    ss_.set_delay_mean(mean);
+    ss_.set_delay_stddev(stddev);
+    ss_.UpdateDelayDistribution();
 
     AsyncSocket* send_socket =
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     AsyncSocket* recv_socket =
-        ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
+        ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     ASSERT_EQ(0, send_socket->Bind(initial_addr));
     ASSERT_EQ(0, recv_socket->Bind(initial_addr));
     EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
 
     Thread* pthMain = Thread::Current();
     // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
     // 1000 packets, which is necessary to get a good distribution.
     Sender sender(pthMain, send_socket, 100 * 2 * 1024);
     Receiver receiver(pthMain, recv_socket, 0);
 
     pthMain->ProcessMessages(10000);
     sender.done = receiver.done = true;
-    ss_->ProcessMessagesUntilIdle();
+    ss_.ProcessMessagesUntilIdle();
 
     const double sample_mean = receiver.sum / receiver.samples;
     double num =
         receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
     double den = receiver.samples * (receiver.samples - 1);
     const double sample_stddev = sqrt(num / den);
     LOG(LS_VERBOSE) << "mean=" << sample_mean << " stddev=" << sample_stddev;
 
     EXPECT_LE(500u, receiver.samples);
     // We initially used a 0.1 fudge factor, but on the build machine, we
     // have seen the value differ by as much as 0.13.
     EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
     EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
 
-    ss_->set_delay_mean(0);
-    ss_->set_delay_stddev(0);
-    ss_->UpdateDelayDistribution();
+    ss_.set_delay_mean(0);
+    ss_.set_delay_stddev(0);
+    ss_.UpdateDelayDistribution();
   }
 
   // Test cross-family communication between a client bound to client_addr and a
   // server bound to server_addr. shouldSucceed indicates if communication is
   // expected to work or not.
   void CrossFamilyConnectionTest(const SocketAddress& client_addr,
                                  const SocketAddress& server_addr,
                                  bool shouldSucceed) {
     StreamSink sink;
     SocketAddress accept_address;
     const SocketAddress kEmptyAddr;
 
     // Client gets a IPv4 address
-    AsyncSocket* client = ss_->CreateAsyncSocket(client_addr.family(),
-                                                 SOCK_STREAM);
+    AsyncSocket* client =
+        ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM);
     sink.Monitor(client);
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
     client->Bind(client_addr);
 
     // Server gets a non-mapped non-any IPv6 address.
     // IPv4 sockets should not be able to connect to this.
-    AsyncSocket* server = ss_->CreateAsyncSocket(server_addr.family(),
-                                                 SOCK_STREAM);
+    AsyncSocket* server =
+        ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM);
     sink.Monitor(server);
     server->Bind(server_addr);
     server->Listen(5);
 
     if (shouldSucceed) {
       EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-      ss_->ProcessMessagesUntilIdle();
+      ss_.ProcessMessagesUntilIdle();
       EXPECT_TRUE(sink.Check(server, SSE_READ));
       Socket* accepted = server->Accept(&accept_address);
       EXPECT_TRUE(nullptr != accepted);
       EXPECT_NE(kEmptyAddr, accept_address);
-      ss_->ProcessMessagesUntilIdle();
+      ss_.ProcessMessagesUntilIdle();
       EXPECT_TRUE(sink.Check(client, SSE_OPEN));
       EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
     } else {
       // Check that the connection failed.
       EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
-      ss_->ProcessMessagesUntilIdle();
+      ss_.ProcessMessagesUntilIdle();
 
       EXPECT_FALSE(sink.Check(server, SSE_READ));
       EXPECT_TRUE(nullptr == server->Accept(&accept_address));
       EXPECT_EQ(accept_address, kEmptyAddr);
       EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
       EXPECT_FALSE(sink.Check(client, SSE_OPEN));
       EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
     }
   }
 
   // Test cross-family datagram sending between a client bound to client_addr
   // and a server bound to server_addr. shouldSucceed indicates if sending is
   // expected to succeed or not.
   void CrossFamilyDatagramTest(const SocketAddress& client_addr,
                                const SocketAddress& server_addr,
                                bool shouldSucceed) {
-    AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    AsyncSocket* socket = ss_.CreateAsyncSocket(SOCK_DGRAM);
     socket->Bind(server_addr);
     SocketAddress bound_server_addr = socket->GetLocalAddress();
-    TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
 
-    AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    AsyncSocket* socket2 = ss_.CreateAsyncSocket(SOCK_DGRAM);
     socket2->Bind(client_addr);
-    TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
     SocketAddress client2_addr;
 
     if (shouldSucceed) {
       EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
       SocketAddress client1_addr;
       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
       EXPECT_EQ(client1_addr, bound_server_addr);
     } else {
       EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
       EXPECT_TRUE(client1->CheckNoPacket());
     }
   }
 
  protected:
-  virtual void SetUp() {
-    Thread::Current()->set_socketserver(ss_);
-  }
+  virtual void SetUp() { Thread::Current()->set_socketserver(&ss_); }
   virtual void TearDown() { Thread::Current()->set_socketserver(nullptr); }
 
-  VirtualSocketServer* ss_;
+  VirtualSocketServer ss_;
   const SocketAddress kIPv4AnyAddress;
   const SocketAddress kIPv6AnyAddress;
 };
 
 TEST_F(VirtualSocketServerTest, basic_v4) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
   BasicTest(ipv4_test_addr);
 }
 
 TEST_F(VirtualSocketServerTest, basic_v6) {
@@ skipping 177 matching lines @@
 }
 
 TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
   CrossFamilyDatagramTest(SocketAddress("::", 0),
                           SocketAddress("0.0.0.0", 5000),
                           true);
 }
 
 TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
   AsyncSocket* socket1 =
-      ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+      ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
   AsyncSocket* socket2 =
-      ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+      ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
   socket1->Bind(kIPv4AnyAddress);
   socket2->Bind(kIPv4AnyAddress);
-  TestClient* client1 = new TestClient(new AsyncUDPSocket(socket1));
+  auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1));
 
-  ss_->SetSendingBlocked(true);
+  ss_.SetSendingBlocked(true);
   EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
   EXPECT_TRUE(socket1->IsBlocking());
   EXPECT_EQ(0, client1->ready_to_send_count());
 
-  ss_->SetSendingBlocked(false);
+  ss_.SetSendingBlocked(false);
   EXPECT_EQ(1, client1->ready_to_send_count());
   EXPECT_EQ(3, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
 }
 
 TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
   constexpr size_t kBufferSize = 1024;
-  ss_->set_send_buffer_capacity(kBufferSize);
-  ss_->set_recv_buffer_capacity(kBufferSize);
+  ss_.set_send_buffer_capacity(kBufferSize);
+  ss_.set_recv_buffer_capacity(kBufferSize);
 
   StreamSink sink;
   AsyncSocket* socket1 =
-      ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
+      ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
   AsyncSocket* socket2 =
-      ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
+      ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM);
   sink.Monitor(socket1);
   sink.Monitor(socket2);
   socket1->Bind(kIPv4AnyAddress);
   socket2->Bind(kIPv4AnyAddress);
 
   // Connect sockets.
   EXPECT_EQ(0, socket1->Connect(socket2->GetLocalAddress()));
   EXPECT_EQ(0, socket2->Connect(socket1->GetLocalAddress()));
-  ss_->ProcessMessagesUntilIdle();
+  ss_.ProcessMessagesUntilIdle();
 
   char data[kBufferSize] = {};
 
   // First Send call will fill the send buffer but not send anything.
-  ss_->SetSendingBlocked(true);
+  ss_.SetSendingBlocked(true);
   EXPECT_EQ(static_cast<int>(kBufferSize), socket1->Send(data, kBufferSize));
-  ss_->ProcessMessagesUntilIdle();
+  ss_.ProcessMessagesUntilIdle();
   EXPECT_FALSE(sink.Check(socket1, SSE_WRITE));
   EXPECT_FALSE(sink.Check(socket2, SSE_READ));
   EXPECT_FALSE(socket1->IsBlocking());
 
   // Since the send buffer is full, next Send will result in EWOULDBLOCK.
   EXPECT_EQ(-1, socket1->Send(data, kBufferSize));
   EXPECT_FALSE(sink.Check(socket1, SSE_WRITE));
   EXPECT_FALSE(sink.Check(socket2, SSE_READ));
   EXPECT_TRUE(socket1->IsBlocking());
 
   // When sending is unblocked, the buffered data should be sent and
   // SignalWriteEvent should fire.
-  ss_->SetSendingBlocked(false);
-  ss_->ProcessMessagesUntilIdle();
+  ss_.SetSendingBlocked(false);
+  ss_.ProcessMessagesUntilIdle();
   EXPECT_TRUE(sink.Check(socket1, SSE_WRITE));
   EXPECT_TRUE(sink.Check(socket2, SSE_READ));
 }
 
 TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
   const uint32_t kTestMean[] = {10, 100, 333, 1000};
   const double kTestDev[] = { 0.25, 0.1, 0.01 };
   // TODO(deadbeef): The current code only works for 1000 data points or more.
   const uint32_t kTestSamples[] = {/*10, 100,*/ 1000};
   for (size_t midx = 0; midx < arraysize(kTestMean); ++midx) {
@@ skipping 25 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }