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

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/asyncudpsocket.h"
 #include "webrtc/base/buffer.h"
-#include "webrtc/base/asyncudpsocket.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/nethelpers.h"
+#include "webrtc/base/ptr_util.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;
@@ skipping 866 matching lines @@
   EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
   SocketAddress addr1 = socket->GetLocalAddress();
   EXPECT_EQ(0, socket->Connect(addr1));
   EXPECT_EQ(AsyncSocket::CS_CONNECTED, socket->GetState());
   socket->Close();
   EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState());
   delete socket;
 
   // Test send/receive behavior.
   std::unique_ptr<TestClient> client1(
-      new TestClient(AsyncUDPSocket::Create(ss_, addr1)));
+      new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, addr1))));
   std::unique_ptr<TestClient> client2(
-      new TestClient(AsyncUDPSocket::Create(ss_, empty)));
+      new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
 
   SocketAddress addr2;
   EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
   EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
 
   SocketAddress addr3;
   EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
   EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
   EXPECT_EQ(addr3, addr1);
   // TODO: figure out what the intent is here
   for (int i = 0; i < 10; ++i) {
-    client2.reset(new TestClient(AsyncUDPSocket::Create(ss_, empty)));
+    client2.reset(
+        new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
 
     SocketAddress addr4;
     EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
     EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
 
     SocketAddress addr5;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
     EXPECT_EQ(addr5, addr1);
 
     addr2 = addr4;
   }
 }
 
 void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
   SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
   // RFC 5737 - The blocks 192.0.2.0/24 (TEST-NET-1) ... are provided for use in
   // documentation.
   // RFC 3849 - 2001:DB8::/32 as a documentation-only prefix.
   std::string dest = (loopback.family() == AF_INET6) ?
       "2001:db8::1" : "192.0.2.0";
   SocketAddress test_addr(dest, 2345);
 
   // Test send
   std::unique_ptr<TestClient> client(
-      new TestClient(AsyncUDPSocket::Create(ss_, empty)));
+      new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
   int test_packet_size = 1200;
   std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
   // Init the test packet just to avoid memcheck warning.
   memset(test_packet.get(), 0, test_packet_size);
   // Set the send buffer size to the same size as the test packet to have a
   // better chance to get EWOULDBLOCK.
   int send_buffer_size = test_packet_size;
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
   send_buffer_size /= 2;
 #endif
@@ skipping 101 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