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

webrtc/p2p/base/relayserver_unittest.cc

 /*
  *  Copyright 2004 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 <string>
 
-#include "webrtc/p2p/base/relayserver.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
+#include "webrtc/p2p/base/relayserver.h"
 
 using rtc::SocketAddress;
 using namespace cricket;
 
 static const uint32_t LIFETIME = 4;  // seconds
 static const SocketAddress server_int_addr("127.0.0.1", 5000);
 static const SocketAddress server_ext_addr("127.0.0.1", 5001);
 static const SocketAddress client1_addr("127.0.0.1", 6000 + (rand() % 1000));
 static const SocketAddress client2_addr("127.0.0.1", 7000 + (rand() % 1000));
 static const char* bad = "this is a completely nonsensical message whose only "
@@ skipping 14 matching lines @@
  protected:
   virtual void SetUp() {
     server_.reset(new RelayServer(rtc::Thread::Current()));
 
     server_->AddInternalSocket(
         rtc::AsyncUDPSocket::Create(ss_.get(), server_int_addr));
     server_->AddExternalSocket(
         rtc::AsyncUDPSocket::Create(ss_.get(), server_ext_addr));
 
     client1_.reset(new rtc::TestClient(
-        rtc::AsyncUDPSocket::Create(ss_.get(), client1_addr)));
+        WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client1_addr))));
     client2_.reset(new rtc::TestClient(
-        rtc::AsyncUDPSocket::Create(ss_.get(), client2_addr)));
+        WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client2_addr))));
   }
 
   void Allocate() {
     std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_ALLOCATE_REQUEST));
     AddUsernameAttr(req.get(), username_);
     AddLifetimeAttr(req.get(), LIFETIME);
     Send1(req.get());
     delete Receive1();
   }
   void Bind() {
@@ skipping 38 matching lines @@
     return Receive(client2_.get());
   }
   std::string ReceiveRaw1() {
     return ReceiveRaw(client1_.get());
   }
   std::string ReceiveRaw2() {
     return ReceiveRaw(client2_.get());
   }
   StunMessage* Receive(rtc::TestClient* client) {
     StunMessage* msg = NULL;
-    rtc::TestClient::Packet* packet =
+    std::unique_ptr<rtc::TestClient::Packet> packet =
         client->NextPacket(rtc::TestClient::kTimeoutMs);
     if (packet) {
       rtc::ByteBufferWriter buf(packet->buf, packet->size);
       rtc::ByteBufferReader read_buf(buf);
       msg = new RelayMessage();
       msg->Read(&read_buf);
-      delete packet;
     }
     return msg;
   }
   std::string ReceiveRaw(rtc::TestClient* client) {
     std::string raw;
-    rtc::TestClient::Packet* packet =
+    std::unique_ptr<rtc::TestClient::Packet> packet =
         client->NextPacket(rtc::TestClient::kTimeoutMs);
     if (packet) {
       raw = std::string(packet->buf, packet->size);
-      delete packet;
     }
     return raw;
   }
 
   static StunMessage* CreateStunMessage(int type) {
     StunMessage* msg = new RelayMessage();
     msg->SetType(type);
     msg->SetTransactionID(
         rtc::CreateRandomString(kStunTransactionIdLength));
     return msg;
@@ skipping 361 matching lines @@
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(6, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Operation Not Supported", err->reason());
 
   // Also verify that traffic from the external client is ignored.
   SendRaw2(msg2, static_cast<int>(strlen(msg2)));
   EXPECT_TRUE(ReceiveRaw1().empty());
 }