Replace scoped_ptr with unique_ptr in webrtc/base/

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"
@@ skipping 170 matching lines @@
 #else
   return address.family() == AF_UNSPEC;
 #endif
 }
 
 void SocketTest::ConnectInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(ss_->CreateAsyncSocket(loopback.family(),
-                                                        SOCK_STREAM));
+  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.
-  scoped_ptr<AsyncSocket> server(
+  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_TRUE(NULL == 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));
 
   // Server has pending connection, accept it.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 }
 
 void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
                                               const std::string& host) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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));
 
   // Server has pending connection, accept it.
   EXPECT_TRUE_WAIT((sink.Check(server.get(), testing::SSE_READ)), kTimeout);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
 }
 
 void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
-  scoped_ptr<AsyncSocket> server(
+  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_TRUE(client->GetRemoteAddress().IsNil());
 
   // Should be no pending server connections.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
   EXPECT_TRUE(NULL == server->Accept(&accept_addr));
   EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
 }
 
 void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
-  scoped_ptr<AsyncSocket> server(
+  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 host.
   // 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_dns_addr("not-a-real-hostname", 65535);
   EXPECT_EQ(0, client->Connect(bogus_dns_addr));
 
@@ skipping 12 matching lines @@
   EXPECT_TRUE(sink.Check(client.get(), testing::SSE_ERROR));
   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
   // Should be no pending server connections.
   EXPECT_FALSE(sink.Check(server.get(), testing::SSE_READ));
   EXPECT_TRUE(NULL == server->Accept(&accept_addr));
   EXPECT_TRUE(accept_addr.IsNil());
 }
 
 void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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.
-  scoped_ptr<AsyncSocket> client(
+  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;
-  scoped_ptr<AsyncSocket> server(
+  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.
-  scoped_ptr<AsyncSocket> client(
+  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);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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);
   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));
   client->Close();
 }
 
 void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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);
   client->Close();
 
   // The connection should still be able to be accepted.
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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));
 
   // The client should not get a close event.
   EXPECT_FALSE(sink.Check(client.get(), testing::SSE_CLOSE));
 }
 
 void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
   // Send data to the client, and then close the connection.
@@ skipping 37 matching lines @@
                       // for the socket's signal.
   }
 };
 
 void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketCloser closer;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> 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.
-  scoped_ptr<AsyncSocket> server(
+  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);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
   // Send data to the client, and then close the connection.
@@ skipping 16 matching lines @@
   void OnMessage(Message* msg) {
     Thread::Current()->SleepMs(500);
   }
 };
 
 void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create & connect server and client sockets.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
-  scoped_ptr<AsyncSocket> server(
+  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);
 
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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_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));
   char buf[1024] = {0};
 
   EXPECT_EQ(1024, client->Send(buf, 1024));
   EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
 
   // Shouldn't signal when blocked in a thread Send, where process_io is false.
-  scoped_ptr<Thread> thread(new Thread());
+  std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   Sleeper sleeper;
   TypedMessageData<AsyncSocket*> data(client.get());
   thread->Send(&sleeper, 0, &data);
   EXPECT_FALSE(sink.Check(accepted.get(), testing::SSE_READ));
 
   // But should signal when process_io is true.
   EXPECT_TRUE_WAIT((sink.Check(accepted.get(), testing::SSE_READ)), kTimeout);
   EXPECT_LT(0, accepted->Recv(buf, 1024));
 }
 
 void SocketTest::TcpInternal(const IPAddress& loopback, size_t data_size,
     ssize_t max_send_size) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create receiving client.
-  scoped_ptr<AsyncSocket> receiver(
+  std::unique_ptr<AsyncSocket> receiver(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(receiver.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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);
-  scoped_ptr<AsyncSocket> sender(server->Accept(&accept_addr));
+  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_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
   EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
 
   // Create test data.
@@ skipping 91 matching lines @@
   EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, receiver->GetState(), kTimeout);
   EXPECT_TRUE(sink.Check(receiver.get(), testing::SSE_CLOSE));
   receiver->Close();
 }
 
 void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
   testing::StreamSink sink;
   SocketAddress accept_addr;
 
   // Create client.
-  scoped_ptr<AsyncSocket> client(
+  std::unique_ptr<AsyncSocket> client(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
-  scoped_ptr<AsyncSocket> server(
+  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);
-  scoped_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+  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_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
   // Expect a writable callback from the connect.
@@ skipping 41 matching lines @@
   EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState());
   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.
-  scoped_ptr<TestClient> client1(
+  std::unique_ptr<TestClient> client1(
       new TestClient(AsyncUDPSocket::Create(ss_, addr1)));
-  scoped_ptr<TestClient> client2(
+  std::unique_ptr<TestClient> client2(
       new TestClient(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);
@@ skipping 18 matching lines @@
 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
-  scoped_ptr<TestClient> client(
+  std::unique_ptr<TestClient> client(
       new TestClient(AsyncUDPSocket::Create(ss_, empty)));
   int test_packet_size = 1200;
-  rtc::scoped_ptr<char[]> test_packet(new char[test_packet_size]);
+  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
   client->SetOption(rtc::Socket::OPT_SNDBUF, send_buffer_size);
 
@@ skipping 13 matching lines @@
       }
     }
   }
   EXPECT_EQ(expected_error, error);
   EXPECT_FALSE(client->ready_to_send());
   EXPECT_TRUE_WAIT(client->ready_to_send(), kTimeout);
   LOG(LS_INFO) << "Got SignalReadyToSend";
 }
 
 void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
-  rtc::scoped_ptr<AsyncSocket> socket(
+  std::unique_ptr<AsyncSocket> socket(
       ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
   socket->Bind(SocketAddress(loopback, 0));
 
   // Check SNDBUF/RCVBUF.
   const int desired_size = 12345;
 #if defined(WEBRTC_LINUX)
   // Yes, really.  It's in the kernel source.
   const int expected_size = desired_size * 2;
 #else   // !WEBRTC_LINUX
   const int expected_size = desired_size;
@@ skipping 14 matching lines @@
   ASSERT_EQ(expected_size, send_size);
 
   // Check that we can't set NODELAY on a UDP socket.
   int current_nd, desired_nd = 1;
   ASSERT_EQ(-1, socket->GetOption(Socket::OPT_NODELAY, &current_nd));
   ASSERT_EQ(-1, socket->SetOption(Socket::OPT_NODELAY, desired_nd));
 
   // Skip the esimate MTU test for IPv6 for now.
   if (loopback.family() != AF_INET6) {
     // Try estimating MTU.
-    rtc::scoped_ptr<AsyncSocket>
-        mtu_socket(
-            ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
+    std::unique_ptr<AsyncSocket> mtu_socket(
+        ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
     mtu_socket->Bind(SocketAddress(loopback, 0));
     uint16_t mtu;
     // should fail until we connect
     ASSERT_EQ(-1, mtu_socket->EstimateMTU(&mtu));
     mtu_socket->Connect(SocketAddress(loopback, 0));
 #if defined(WEBRTC_WIN)
     // now it should succeed
     ASSERT_NE(-1, mtu_socket->EstimateMTU(&mtu));
     ASSERT_GE(mtu, 1492);  // should be at least the 1492 "plateau" on localhost
 #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
     // except on WEBRTC_MAC && !WEBRTC_IOS, where it's not yet implemented
     ASSERT_EQ(-1, mtu_socket->EstimateMTU(&mtu));
 #else
     // and the behavior seems unpredictable on Linux,
     // failing on the build machine
     // but succeeding on my Ubiquity instance.
 #endif
   }
 }
 
 }  // namespace rtc