From 32f25051853fcf483f0a6f145c278eabcc112fc7 Mon Sep 17 00:00:00 2001 From: nisse Date: Mon, 8 May 2017 01:57:18 -0700 Subject: [PATCH] Refactor TestClient to use std::unique_ptr, and fix VirtualSocketServerTest leaks. BUG=None Review-Url: https://codereview.webrtc.org/2859373003 Cr-Commit-Position: refs/heads/master@{#18043} --- webrtc/base/nat_unittest.cc | 10 +- webrtc/base/proxy_unittest.cc | 7 +- webrtc/base/socket_unittest.cc | 12 +- webrtc/base/testclient.cc | 36 +-- webrtc/base/testclient.h | 14 +- webrtc/base/testclient_unittest.cc | 11 +- webrtc/base/virtualsocket_unittest.cc | 306 ++++++++++++------------ webrtc/p2p/base/relayserver_unittest.cc | 13 +- webrtc/p2p/base/stunserver_unittest.cc | 8 +- 9 files changed, 207 insertions(+), 210 deletions(-) diff --git a/webrtc/base/nat_unittest.cc b/webrtc/base/nat_unittest.cc index f585effdd9..1295a34637 100644 --- a/webrtc/base/nat_unittest.cc +++ b/webrtc/base/nat_unittest.cc @@ -12,6 +12,7 @@ #include #include +#include "webrtc/base/asynctcpsocket.h" #include "webrtc/base/gunit.h" #include "webrtc/base/logging.h" #include "webrtc/base/natserver.h" @@ -19,8 +20,8 @@ #include "webrtc/base/nethelpers.h" #include "webrtc/base/network.h" #include "webrtc/base/physicalsocketserver.h" +#include "webrtc/base/ptr_util.h" #include "webrtc/base/testclient.h" -#include "webrtc/base/asynctcpsocket.h" #include "webrtc/base/virtualsocketserver.h" using namespace rtc; @@ -34,13 +35,12 @@ bool CheckReceive( TestClient* CreateTestClient( SocketFactory* factory, const SocketAddress& local_addr) { - AsyncUDPSocket* socket = AsyncUDPSocket::Create(factory, local_addr); - return new TestClient(socket); + return new TestClient( + WrapUnique(AsyncUDPSocket::Create(factory, local_addr))); } TestClient* CreateTCPTestClient(AsyncSocket* socket) { - AsyncTCPSocket* packet_socket = new AsyncTCPSocket(socket, false); - return new TestClient(packet_socket); + return new TestClient(MakeUnique(socket, false)); } // Tests that when sending from internal_addr to external_addrs through the diff --git a/webrtc/base/proxy_unittest.cc b/webrtc/base/proxy_unittest.cc index b72d228ea0..631d91b605 100644 --- a/webrtc/base/proxy_unittest.cc +++ b/webrtc/base/proxy_unittest.cc @@ -61,10 +61,11 @@ TEST_F(ProxyTest, TestSocks5Connect) { rtc::TestEchoServer server(Thread::Current(), SocketAddress(INADDR_ANY, 0)); - rtc::AsyncTCPSocket* packet_socket = rtc::AsyncTCPSocket::Create( - proxy_socket, SocketAddress(INADDR_ANY, 0), server.address()); + std::unique_ptr packet_socket( + rtc::AsyncTCPSocket::Create(proxy_socket, SocketAddress(INADDR_ANY, 0), + server.address())); EXPECT_TRUE(packet_socket != nullptr); - rtc::TestClient client(packet_socket); + rtc::TestClient client(std::move(packet_socket)); EXPECT_EQ(Socket::CS_CONNECTING, proxy_socket->GetState()); EXPECT_TRUE(client.CheckConnected()); diff --git a/webrtc/base/socket_unittest.cc b/webrtc/base/socket_unittest.cc index 762a88a42a..f1a8ecb184 100644 --- a/webrtc/base/socket_unittest.cc +++ b/webrtc/base/socket_unittest.cc @@ -13,10 +13,11 @@ #include "webrtc/base/socket_unittest.h" #include "webrtc/base/arraysize.h" -#include "webrtc/base/buffer.h" #include "webrtc/base/asyncudpsocket.h" +#include "webrtc/base/buffer.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" @@ -903,9 +904,9 @@ void SocketTest::UdpInternal(const IPAddress& loopback) { // Test send/receive behavior. std::unique_ptr client1( - new TestClient(AsyncUDPSocket::Create(ss_, addr1))); + new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, addr1)))); std::unique_ptr client2( - new TestClient(AsyncUDPSocket::Create(ss_, empty))); + new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty)))); SocketAddress addr2; EXPECT_EQ(3, client2->SendTo("foo", 3, addr1)); @@ -917,7 +918,8 @@ void SocketTest::UdpInternal(const IPAddress& loopback) { 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)); @@ -944,7 +946,7 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) { // Test send std::unique_ptr client( - new TestClient(AsyncUDPSocket::Create(ss_, empty))); + new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty)))); int test_packet_size = 1200; std::unique_ptr test_packet(new char[test_packet_size]); // Init the test packet just to avoid memcheck warning. diff --git a/webrtc/base/testclient.cc b/webrtc/base/testclient.cc index e797c6fa59..7ec70f40d1 100644 --- a/webrtc/base/testclient.cc +++ b/webrtc/base/testclient.cc @@ -9,6 +9,7 @@ */ #include "webrtc/base/testclient.h" +#include "webrtc/base/ptr_util.h" #include "webrtc/base/thread.h" #include "webrtc/base/timeutils.h" @@ -18,19 +19,13 @@ namespace rtc { // Callers can retrieve received packets from any thread by calling // NextPacket. -TestClient::TestClient(AsyncPacketSocket* socket) - : socket_(socket), prev_packet_timestamp_(-1) { - packets_ = new std::vector(); +TestClient::TestClient(std::unique_ptr socket) + : socket_(std::move(socket)), prev_packet_timestamp_(-1) { socket_->SignalReadPacket.connect(this, &TestClient::OnPacket); socket_->SignalReadyToSend.connect(this, &TestClient::OnReadyToSend); } -TestClient::~TestClient() { - delete socket_; - for (unsigned i = 0; i < packets_->size(); i++) - delete (*packets_)[i]; - delete packets_; -} +TestClient::~TestClient() {} bool TestClient::CheckConnState(AsyncPacketSocket::State state) { // Wait for our timeout value until the socket reaches the desired state. @@ -52,7 +47,7 @@ int TestClient::SendTo(const char* buf, size_t size, return socket_->SendTo(buf, size, dest, options); } -TestClient::Packet* TestClient::NextPacket(int timeout_ms) { +std::unique_ptr TestClient::NextPacket(int timeout_ms) { // If no packets are currently available, we go into a get/dispatch loop for // at most timeout_ms. If, during the loop, a packet arrives, then we can // stop early and return it. @@ -68,7 +63,7 @@ TestClient::Packet* TestClient::NextPacket(int timeout_ms) { while (TimeUntil(end) > 0) { { CritScope cs(&crit_); - if (packets_->size() != 0) { + if (packets_.size() != 0) { break; } } @@ -76,11 +71,11 @@ TestClient::Packet* TestClient::NextPacket(int timeout_ms) { } // Return the first packet placed in the queue. - Packet* packet = nullptr; + std::unique_ptr packet; CritScope cs(&crit_); - if (packets_->size() > 0) { - packet = packets_->front(); - packets_->erase(packets_->begin()); + if (packets_.size() > 0) { + packet = std::move(packets_.front()); + packets_.erase(packets_.begin()); } return packet; @@ -89,13 +84,12 @@ TestClient::Packet* TestClient::NextPacket(int timeout_ms) { bool TestClient::CheckNextPacket(const char* buf, size_t size, SocketAddress* addr) { bool res = false; - Packet* packet = NextPacket(kTimeoutMs); + std::unique_ptr packet = NextPacket(kTimeoutMs); if (packet) { res = (packet->size == size && memcmp(packet->buf, buf, size) == 0 && CheckTimestamp(packet->packet_time.timestamp)); if (addr) *addr = packet->addr; - delete packet; } return res; } @@ -115,11 +109,7 @@ bool TestClient::CheckTimestamp(int64_t packet_timestamp) { } bool TestClient::CheckNoPacket() { - bool res; - Packet* packet = NextPacket(kNoPacketTimeoutMs); - res = (packet == nullptr); - delete packet; - return res; + return NextPacket(kNoPacketTimeoutMs) == nullptr; } int TestClient::GetError() { @@ -134,7 +124,7 @@ void TestClient::OnPacket(AsyncPacketSocket* socket, const char* buf, size_t size, const SocketAddress& remote_addr, const PacketTime& packet_time) { CritScope cs(&crit_); - packets_->push_back(new Packet(remote_addr, buf, size, packet_time)); + packets_.push_back(MakeUnique(remote_addr, buf, size, packet_time)); } void TestClient::OnReadyToSend(AsyncPacketSocket* socket) { diff --git a/webrtc/base/testclient.h b/webrtc/base/testclient.h index 74ef8cc376..b4703828eb 100644 --- a/webrtc/base/testclient.h +++ b/webrtc/base/testclient.h @@ -11,6 +11,7 @@ #ifndef WEBRTC_BASE_TESTCLIENT_H_ #define WEBRTC_BASE_TESTCLIENT_H_ +#include #include #include "webrtc/base/asyncudpsocket.h" #include "webrtc/base/constructormagic.h" @@ -42,7 +43,7 @@ class TestClient : public sigslot::has_slots<> { // Creates a client that will send and receive with the given socket and // will post itself messages with the given thread. - explicit TestClient(AsyncPacketSocket* socket); + explicit TestClient(std::unique_ptr socket); ~TestClient() override; SocketAddress address() const { return socket_->GetLocalAddress(); } @@ -62,10 +63,9 @@ class TestClient : public sigslot::has_slots<> { // Sends using the clients socket to the given destination. int SendTo(const char* buf, size_t size, const SocketAddress& dest); - // Returns the next packet received by the client or 0 if none is received - // within the specified timeout. The caller must delete the packet - // when done with it. - Packet* NextPacket(int timeout_ms); + // Returns the next packet received by the client or null if none is received + // within the specified timeout. + std::unique_ptr NextPacket(int timeout_ms); // Checks that the next packet has the given contents. Returns the remote // address that the packet was sent from. @@ -95,8 +95,8 @@ class TestClient : public sigslot::has_slots<> { bool CheckTimestamp(int64_t packet_timestamp); CriticalSection crit_; - AsyncPacketSocket* socket_; - std::vector* packets_; + std::unique_ptr socket_; + std::vector> packets_; int ready_to_send_count_ = 0; int64_t prev_packet_timestamp_; RTC_DISALLOW_COPY_AND_ASSIGN(TestClient); diff --git a/webrtc/base/testclient_unittest.cc b/webrtc/base/testclient_unittest.cc index 55078134c3..685499448f 100644 --- a/webrtc/base/testclient_unittest.cc +++ b/webrtc/base/testclient_unittest.cc @@ -8,10 +8,11 @@ * be found in the AUTHORS file in the root of the source tree. */ +#include "webrtc/base/testclient.h" #include "webrtc/base/gunit.h" #include "webrtc/base/nethelpers.h" #include "webrtc/base/physicalsocketserver.h" -#include "webrtc/base/testclient.h" +#include "webrtc/base/ptr_util.h" #include "webrtc/base/testechoserver.h" #include "webrtc/base/thread.h" @@ -23,7 +24,7 @@ void TestUdpInternal(const SocketAddress& loopback) { ->CreateAsyncSocket(loopback.family(), SOCK_DGRAM); socket->Bind(loopback); - TestClient client(new AsyncUDPSocket(socket)); + TestClient client(MakeUnique(socket)); SocketAddress addr = client.address(), from; EXPECT_EQ(3, client.SendTo("foo", 3, addr)); EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from)); @@ -37,11 +38,11 @@ void TestTcpInternal(const SocketAddress& loopback) { AsyncSocket* socket = main->socketserver() ->CreateAsyncSocket(loopback.family(), SOCK_STREAM); - AsyncTCPSocket* tcp_socket = AsyncTCPSocket::Create( - socket, loopback, server.address()); + std::unique_ptr tcp_socket = + WrapUnique(AsyncTCPSocket::Create(socket, loopback, server.address())); ASSERT_TRUE(tcp_socket != nullptr); - TestClient client(tcp_socket); + TestClient client(std::move(tcp_socket)); SocketAddress addr = client.address(), from; EXPECT_TRUE(client.CheckConnected()); EXPECT_EQ(3, client.Send("foo", 3)); diff --git a/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc index e2f1d05f16..488cada386 100644 --- a/webrtc/base/virtualsocket_unittest.cc +++ b/webrtc/base/virtualsocket_unittest.cc @@ -17,8 +17,9 @@ #include #include "webrtc/base/arraysize.h" -#include "webrtc/base/logging.h" #include "webrtc/base/gunit.h" +#include "webrtc/base/logging.h" +#include "webrtc/base/ptr_util.h" #include "webrtc/base/testclient.h" #include "webrtc/base/testutils.h" #include "webrtc/base/thread.h" @@ -38,7 +39,7 @@ using webrtc::testing::StreamSink; struct Sender : public MessageHandler { Sender(Thread* th, AsyncSocket* s, uint32_t rt) : thread(th), - socket(new AsyncUDPSocket(s)), + socket(MakeUnique(s)), done(false), rate(rt), count(0) { @@ -84,7 +85,7 @@ struct Sender : public MessageHandler { struct Receiver : public MessageHandler, public sigslot::has_slots<> { Receiver(Thread* th, AsyncSocket* s, uint32_t bw) : thread(th), - socket(new AsyncUDPSocket(s)), + socket(MakeUnique(s)), bandwidth(bw), done(false), count(0), @@ -145,7 +146,7 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> { class VirtualSocketServerTest : public testing::Test { public: VirtualSocketServerTest() - : ss_(new VirtualSocketServer(nullptr)), + : ss_(nullptr), kIPv4AnyAddress(IPAddress(INADDR_ANY), 0), kIPv6AnyAddress(IPAddress(in6addr_any), 0) {} @@ -172,23 +173,23 @@ class VirtualSocketServerTest : public testing::Test { // 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(MakeUnique(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(MakeUnique(socket2)); // Client1 sends to client2, client2 should see the default route as // client1's address. @@ -204,17 +205,17 @@ class VirtualSocketServerTest : public testing::Test { } 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(MakeUnique(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(MakeUnique(socket2)); SocketAddress client2_addr; EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr)); @@ -227,7 +228,8 @@ class VirtualSocketServerTest : public testing::Test { SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family()); for (int i = 0; i < 10; i++) { - client2 = new TestClient(AsyncUDPSocket::Create(ss_, empty)); + client2 = MakeUnique( + WrapUnique(AsyncUDPSocket::Create(&ss_, empty))); SocketAddress next_client2_addr; EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr)); @@ -252,16 +254,16 @@ class VirtualSocketServerTest : public testing::Test { EmptySocketAddressWithFamily(initial_addr.family()); // Create client - AsyncSocket* client = ss_->CreateAsyncSocket(initial_addr.family(), - SOCK_STREAM); - sink.Monitor(client); + std::unique_ptr client = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + sink.Monitor(client.get()); EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); EXPECT_TRUE(client->GetLocalAddress().IsNil()); // Create server - AsyncSocket* server = ss_->CreateAsyncSocket(initial_addr.family(), - SOCK_STREAM); - sink.Monitor(server); + std::unique_ptr server = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + sink.Monitor(server.get()); EXPECT_NE(0, server->Listen(5)); // Bind required EXPECT_EQ(0, server->Bind(initial_addr)); EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family()); @@ -269,7 +271,7 @@ class VirtualSocketServerTest : public testing::Test { EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING); // No pending server connections - EXPECT_FALSE(sink.Check(server, SSE_READ)); + EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); EXPECT_TRUE(nullptr == server->Accept(&accept_addr)); EXPECT_EQ(AF_UNSPEC, accept_addr.family()); @@ -281,19 +283,19 @@ class VirtualSocketServerTest : public testing::Test { // Client is connecting EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING); - EXPECT_FALSE(sink.Check(client, SSE_OPEN)); - EXPECT_FALSE(sink.Check(client, SSE_CLOSE)); + EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); + EXPECT_FALSE(sink.Check(client.get(), 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)); + EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); + EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); // Server has pending connection - EXPECT_TRUE(sink.Check(server, SSE_READ)); - Socket* accepted = server->Accept(&accept_addr); + EXPECT_TRUE(sink.Check(server.get(), SSE_READ)); + std::unique_ptr accepted = WrapUnique(server->Accept(&accept_addr)); EXPECT_TRUE(nullptr != accepted); EXPECT_NE(accept_addr, kEmptyAddr); EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); @@ -302,12 +304,12 @@ class VirtualSocketServerTest : public testing::Test { 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_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()); } @@ -320,30 +322,30 @@ class VirtualSocketServerTest : public testing::Test { EmptySocketAddressWithFamily(initial_addr.family()); // Create client - AsyncSocket* client = ss_->CreateAsyncSocket(initial_addr.family(), - SOCK_STREAM); - sink.Monitor(client); + std::unique_ptr client = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + sink.Monitor(client.get()); // Create server - AsyncSocket* server = ss_->CreateAsyncSocket(initial_addr.family(), - SOCK_STREAM); - sink.Monitor(server); + std::unique_ptr server = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + sink.Monitor(server.get()); 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_FALSE(sink.Check(server.get(), 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_FALSE(sink.Check(client.get(), SSE_OPEN)); + EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_EQ(client->GetRemoteAddress(), nil_addr); } @@ -355,10 +357,10 @@ class VirtualSocketServerTest : public testing::Test { // Create client and server std::unique_ptr client( - ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(client.get()); std::unique_ptr server( - ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(server.get()); // Initiate connect @@ -372,13 +374,13 @@ class VirtualSocketServerTest : public testing::Test { 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 @@ -388,20 +390,20 @@ class VirtualSocketServerTest : public testing::Test { 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 @@ -411,7 +413,7 @@ class VirtualSocketServerTest : public testing::Test { 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)); @@ -426,7 +428,7 @@ class VirtualSocketServerTest : public testing::Test { EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING); client->Close(); - ss_->ProcessMessagesUntilIdle(); + ss_.ProcessMessagesUntilIdle(); // Result: accepted socket closes EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED); @@ -439,13 +441,14 @@ class VirtualSocketServerTest : public testing::Test { const SocketAddress kEmptyAddr; // Create clients - AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM); - sink.Monitor(a); + std::unique_ptr a = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + sink.Monitor(a.get()); a->Bind(initial_addr); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); - std::unique_ptr b( - ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr b = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(b.get()); b->Bind(initial_addr); EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family()); @@ -453,9 +456,9 @@ class VirtualSocketServerTest : public testing::Test { 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_TRUE(sink.Check(a.get(), SSE_OPEN)); EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED); EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress()); @@ -467,13 +470,13 @@ class VirtualSocketServerTest : public testing::Test { 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_TRUE(sink.Check(a.get(), SSE_CLOSE)); EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED); EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr); @@ -488,24 +491,26 @@ class VirtualSocketServerTest : public testing::Test { const SocketAddress kEmptyAddr; // Connect two sockets - AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM); - sink.Monitor(a); + std::unique_ptr a = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + sink.Monitor(a.get()); a->Bind(initial_addr); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); - AsyncSocket* b = ss_->CreateAsyncSocket(initial_addr.family(), SOCK_STREAM); - sink.Monitor(b); + std::unique_ptr b = + WrapUnique(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(); 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]; @@ -519,18 +524,18 @@ class VirtualSocketServerTest : public testing::Test { EXPECT_EQ(static_cast(kBufferSize), result); send_pos += result; - ss_->ProcessMessagesUntilIdle(); - EXPECT_FALSE(sink.Check(a, SSE_WRITE)); - EXPECT_TRUE(sink.Check(b, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_FALSE(sink.Check(a.get(), SSE_WRITE)); + EXPECT_TRUE(sink.Check(b.get(), 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(kBufferSize), result); send_pos += result; - ss_->ProcessMessagesUntilIdle(); - EXPECT_FALSE(sink.Check(a, SSE_WRITE)); - EXPECT_FALSE(sink.Check(b, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_FALSE(sink.Check(a.get(), SSE_WRITE)); + EXPECT_FALSE(sink.Check(b.get(), SSE_READ)); // No more room in send or receive buffer result = a->Send(send_buffer + send_pos, kDataSize - send_pos); @@ -542,9 +547,9 @@ class VirtualSocketServerTest : public testing::Test { EXPECT_EQ(500, result); recv_pos += result; - ss_->ProcessMessagesUntilIdle(); - EXPECT_TRUE(sink.Check(a, SSE_WRITE)); - EXPECT_TRUE(sink.Check(b, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_TRUE(sink.Check(a.get(), SSE_WRITE)); + EXPECT_TRUE(sink.Check(b.get(), SSE_READ)); // Room for more on the sending side result = a->Send(send_buffer + send_pos, kDataSize - send_pos); @@ -562,8 +567,8 @@ class VirtualSocketServerTest : public testing::Test { recv_pos += result; } - ss_->ProcessMessagesUntilIdle(); - EXPECT_TRUE(sink.Check(b, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_TRUE(sink.Check(b.get(), SSE_READ)); // Continue to empty the recv buffer while (true) { @@ -581,8 +586,8 @@ class VirtualSocketServerTest : public testing::Test { EXPECT_EQ(500, result); send_pos += result; - ss_->ProcessMessagesUntilIdle(); - EXPECT_TRUE(sink.Check(b, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_TRUE(sink.Check(b.get(), SSE_READ)); // Receive the last of the data while (true) { @@ -595,8 +600,8 @@ class VirtualSocketServerTest : public testing::Test { recv_pos += result; } - ss_->ProcessMessagesUntilIdle(); - EXPECT_FALSE(sink.Check(b, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_FALSE(sink.Check(b.get(), SSE_READ)); // The received data matches the sent data EXPECT_EQ(kDataSize, send_pos); @@ -608,10 +613,10 @@ class VirtualSocketServerTest : public testing::Test { const SocketAddress kEmptyAddr; // Connect two sockets - AsyncSocket* a = ss_->CreateAsyncSocket(initial_addr.family(), - SOCK_STREAM); - AsyncSocket* b = ss_->CreateAsyncSocket(initial_addr.family(), - SOCK_STREAM); + std::unique_ptr a = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr b = + WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); a->Bind(initial_addr); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); @@ -620,7 +625,7 @@ class VirtualSocketServerTest : public testing::Test { 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 }; @@ -630,7 +635,7 @@ class VirtualSocketServerTest : public testing::Test { 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)); @@ -641,16 +646,16 @@ class VirtualSocketServerTest : public testing::Test { 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)); @@ -663,9 +668,9 @@ class VirtualSocketServerTest : public testing::Test { // 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()); @@ -673,7 +678,7 @@ class VirtualSocketServerTest : public testing::Test { 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); @@ -686,7 +691,7 @@ class VirtualSocketServerTest : public testing::Test { 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 @@ -700,14 +705,14 @@ class VirtualSocketServerTest : public testing::Test { 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()); @@ -722,7 +727,7 @@ class VirtualSocketServerTest : public testing::Test { pthMain->ProcessMessages(10000); sender.done = receiver.done = true; - ss_->ProcessMessagesUntilIdle(); + ss_.ProcessMessagesUntilIdle(); const double sample_mean = receiver.sum / receiver.samples; double num = @@ -737,9 +742,9 @@ class VirtualSocketServerTest : public testing::Test { 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 @@ -753,41 +758,42 @@ class VirtualSocketServerTest : public testing::Test { const SocketAddress kEmptyAddr; // Client gets a IPv4 address - AsyncSocket* client = ss_->CreateAsyncSocket(client_addr.family(), - SOCK_STREAM); - sink.Monitor(client); + std::unique_ptr client = + WrapUnique(ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM)); + sink.Monitor(client.get()); 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); - sink.Monitor(server); + std::unique_ptr server = + WrapUnique(ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM)); + sink.Monitor(server.get()); server->Bind(server_addr); server->Listen(5); if (shouldSucceed) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); - ss_->ProcessMessagesUntilIdle(); - EXPECT_TRUE(sink.Check(server, SSE_READ)); - Socket* accepted = server->Accept(&accept_address); + ss_.ProcessMessagesUntilIdle(); + EXPECT_TRUE(sink.Check(server.get(), SSE_READ)); + std::unique_ptr accepted = + WrapUnique(server->Accept(&accept_address)); EXPECT_TRUE(nullptr != accepted); EXPECT_NE(kEmptyAddr, accept_address); - ss_->ProcessMessagesUntilIdle(); - EXPECT_TRUE(sink.Check(client, SSE_OPEN)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_TRUE(sink.Check(client.get(), 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_FALSE(sink.Check(server.get(), 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_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr); } } @@ -798,14 +804,14 @@ class VirtualSocketServerTest : public testing::Test { 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(MakeUnique(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(MakeUnique(socket2)); SocketAddress client2_addr; if (shouldSucceed) { @@ -822,12 +828,10 @@ class VirtualSocketServerTest : public testing::Test { } 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; }; @@ -1025,65 +1029,65 @@ TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) { TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) { AsyncSocket* socket1 = - ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM); - AsyncSocket* socket2 = - ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM); + ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM); + std::unique_ptr socket2 = + WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM)); socket1->Bind(kIPv4AnyAddress); socket2->Bind(kIPv4AnyAddress); - TestClient* client1 = new TestClient(new AsyncUDPSocket(socket1)); + auto client1 = MakeUnique(MakeUnique(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); - AsyncSocket* socket2 = - ss_->CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM); - sink.Monitor(socket1); - sink.Monitor(socket2); + std::unique_ptr socket1 = + WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); + std::unique_ptr socket2 = + WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); + sink.Monitor(socket1.get()); + sink.Monitor(socket2.get()); 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(kBufferSize), socket1->Send(data, kBufferSize)); - ss_->ProcessMessagesUntilIdle(); - EXPECT_FALSE(sink.Check(socket1, SSE_WRITE)); - EXPECT_FALSE(sink.Check(socket2, SSE_READ)); + ss_.ProcessMessagesUntilIdle(); + EXPECT_FALSE(sink.Check(socket1.get(), SSE_WRITE)); + EXPECT_FALSE(sink.Check(socket2.get(), 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_FALSE(sink.Check(socket1.get(), SSE_WRITE)); + EXPECT_FALSE(sink.Check(socket2.get(), 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(); - EXPECT_TRUE(sink.Check(socket1, SSE_WRITE)); - EXPECT_TRUE(sink.Check(socket2, SSE_READ)); + ss_.SetSendingBlocked(false); + ss_.ProcessMessagesUntilIdle(); + EXPECT_TRUE(sink.Check(socket1.get(), SSE_WRITE)); + EXPECT_TRUE(sink.Check(socket2.get(), SSE_READ)); } TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) { diff --git a/webrtc/p2p/base/relayserver_unittest.cc b/webrtc/p2p/base/relayserver_unittest.cc index 0c98286af9..a53a66668a 100644 --- a/webrtc/p2p/base/relayserver_unittest.cc +++ b/webrtc/p2p/base/relayserver_unittest.cc @@ -11,16 +11,17 @@ #include #include -#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; @@ -55,9 +56,9 @@ class RelayServerTest : public testing::Test { 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() { @@ -116,24 +117,22 @@ class RelayServerTest : public testing::Test { } StunMessage* Receive(rtc::TestClient* client) { StunMessage* msg = NULL; - rtc::TestClient::Packet* packet = + std::unique_ptr 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 packet = client->NextPacket(rtc::TestClient::kTimeoutMs); if (packet) { raw = std::string(packet->buf, packet->size); - delete packet; } return raw; } diff --git a/webrtc/p2p/base/stunserver_unittest.cc b/webrtc/p2p/base/stunserver_unittest.cc index 553ad8a0a7..c72a881218 100644 --- a/webrtc/p2p/base/stunserver_unittest.cc +++ b/webrtc/p2p/base/stunserver_unittest.cc @@ -11,13 +11,14 @@ #include #include -#include "webrtc/p2p/base/stunserver.h" #include "webrtc/base/gunit.h" #include "webrtc/base/logging.h" #include "webrtc/base/physicalsocketserver.h" +#include "webrtc/base/ptr_util.h" #include "webrtc/base/testclient.h" #include "webrtc/base/thread.h" #include "webrtc/base/virtualsocketserver.h" +#include "webrtc/p2p/base/stunserver.h" using namespace cricket; @@ -35,7 +36,7 @@ class StunServerTest : public testing::Test { server_.reset(new StunServer( rtc::AsyncUDPSocket::Create(ss_.get(), server_addr))); client_.reset(new rtc::TestClient( - rtc::AsyncUDPSocket::Create(ss_.get(), client_addr))); + WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client_addr)))); network_.Start(); } @@ -52,13 +53,12 @@ class StunServerTest : public testing::Test { } StunMessage* Receive() { StunMessage* msg = NULL; - rtc::TestClient::Packet* packet = + std::unique_ptr packet = client_->NextPacket(rtc::TestClient::kTimeoutMs); if (packet) { rtc::ByteBufferReader buf(packet->buf, packet->size); msg = new StunMessage(); msg->Read(&buf); - delete packet; } return msg; }