Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/nat_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 <algorithm>
+#include <memory>
 #include <string>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/natserver.h"
 #include "webrtc/base/natsocketfactory.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/testclient.h"
@@ skipping 149 matching lines @@
   TestRecv(internal, internal_addr, external, external_addrs,
            NAT_PORT_RESTRICTED, true, true);
   TestRecv(internal, internal_addr, external, external_addrs,
            NAT_SYMMETRIC, true, true);
 }
 
 bool TestConnectivity(const SocketAddress& src, const IPAddress& dst) {
   // The physical NAT tests require connectivity to the selected ip from the
   // internal address used for the NAT. Things like firewalls can break that, so
   // check to see if it's worth even trying with this ip.
-  scoped_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
-  scoped_ptr<AsyncSocket> client(pss->CreateAsyncSocket(src.family(),
-                                                        SOCK_DGRAM));
-  scoped_ptr<AsyncSocket> server(pss->CreateAsyncSocket(src.family(),
-                                                        SOCK_DGRAM));
+  std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
+  std::unique_ptr<AsyncSocket> client(
+      pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
+  std::unique_ptr<AsyncSocket> server(
+      pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
   if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 ||
       server->Bind(SocketAddress(dst, 0)) != 0) {
     return false;
   }
   const char* buf = "hello other socket";
   size_t len = strlen(buf);
   int sent = client->SendTo(buf, len, server->GetLocalAddress());
   SocketAddress addr;
   const size_t kRecvBufSize = 64;
   char recvbuf[kRecvBufSize];
@@ skipping 41 matching lines @@
 
   LOG(LS_INFO) << "selected ip " << ext_addr2.ipaddr();
 
   SocketAddress ext_addrs[4] = {
       SocketAddress(ext_addr1),
       SocketAddress(ext_addr2),
       SocketAddress(ext_addr1),
       SocketAddress(ext_addr2)
   };
 
-  scoped_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
-  scoped_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
+  std::unique_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
+  std::unique_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
 
   TestBindings(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
   TestFilters(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
 }
 
 TEST(NatTest, TestPhysicalIPv4) {
   TestPhysicalInternal(SocketAddress("127.0.0.1", 0));
 }
 
 TEST(NatTest, TestPhysicalIPv6) {
   if (HasIPv6Enabled()) {
     TestPhysicalInternal(SocketAddress("::1", 0));
   } else {
     LOG(LS_WARNING) << "No IPv6, skipping";
   }
 }
 
 namespace {
 
 class TestVirtualSocketServer : public VirtualSocketServer {
  public:
   explicit TestVirtualSocketServer(SocketServer* ss)
       : VirtualSocketServer(ss),
         ss_(ss) {}
   // Expose this publicly
   IPAddress GetNextIP(int af) { return VirtualSocketServer::GetNextIP(af); }
 
  private:
-  scoped_ptr<SocketServer> ss_;
+  std::unique_ptr<SocketServer> ss_;
 };
 
 }  // namespace
 
 void TestVirtualInternal(int family) {
-  scoped_ptr<TestVirtualSocketServer> int_vss(new TestVirtualSocketServer(
-      new PhysicalSocketServer()));
-  scoped_ptr<TestVirtualSocketServer> ext_vss(new TestVirtualSocketServer(
-      new PhysicalSocketServer()));
+  std::unique_ptr<TestVirtualSocketServer> int_vss(
+      new TestVirtualSocketServer(new PhysicalSocketServer()));
+  std::unique_ptr<TestVirtualSocketServer> ext_vss(
+      new TestVirtualSocketServer(new PhysicalSocketServer()));
 
   SocketAddress int_addr;
   SocketAddress ext_addrs[4];
   int_addr.SetIP(int_vss->GetNextIP(family));
   ext_addrs[0].SetIP(ext_vss->GetNextIP(int_addr.family()));
   ext_addrs[1].SetIP(ext_vss->GetNextIP(int_addr.family()));
   ext_addrs[2].SetIP(ext_addrs[0].ipaddr());
   ext_addrs[3].SetIP(ext_addrs[1].ipaddr());
 
   TestBindings(int_vss.get(), int_addr, ext_vss.get(), ext_addrs);
@@ skipping 47 matching lines @@
   void ConnectEvents() {
     server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent);
     client_->SignalConnectEvent.connect(this, &NatTcpTest::OnConnectEvent);
   }
 
   SocketAddress int_addr_;
   SocketAddress ext_addr_;
   bool connected_;
   PhysicalSocketServer* int_pss_;
   PhysicalSocketServer* ext_pss_;
-  rtc::scoped_ptr<TestVirtualSocketServer> int_vss_;
-  rtc::scoped_ptr<TestVirtualSocketServer> ext_vss_;
-  rtc::scoped_ptr<Thread> int_thread_;
-  rtc::scoped_ptr<Thread> ext_thread_;
-  rtc::scoped_ptr<NATServer> nat_;
-  rtc::scoped_ptr<NATSocketFactory> natsf_;
-  rtc::scoped_ptr<AsyncSocket> client_;
-  rtc::scoped_ptr<AsyncSocket> server_;
-  rtc::scoped_ptr<AsyncSocket> accepted_;
+  std::unique_ptr<TestVirtualSocketServer> int_vss_;
+  std::unique_ptr<TestVirtualSocketServer> ext_vss_;
+  std::unique_ptr<Thread> int_thread_;
+  std::unique_ptr<Thread> ext_thread_;
+  std::unique_ptr<NATServer> nat_;
+  std::unique_ptr<NATSocketFactory> natsf_;
+  std::unique_ptr<AsyncSocket> client_;
+  std::unique_ptr<AsyncSocket> server_;
+  std::unique_ptr<AsyncSocket> accepted_;
 };
 
 TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
   server_.reset(ext_vss_->CreateAsyncSocket(SOCK_STREAM));
   server_->Bind(ext_addr_);
   server_->Listen(5);
 
   client_.reset(natsf_->CreateAsyncSocket(SOCK_STREAM));
   EXPECT_GE(0, client_->Bind(int_addr_));
   EXPECT_GE(0, client_->Connect(server_->GetLocalAddress()));
 
   ConnectEvents();
 
   EXPECT_TRUE_WAIT(connected_, 1000);
   EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress());
   EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr());
 
-  rtc::scoped_ptr<rtc::TestClient> in(CreateTCPTestClient(client_.release()));
-  rtc::scoped_ptr<rtc::TestClient> out(
+  std::unique_ptr<rtc::TestClient> in(CreateTCPTestClient(client_.release()));
+  std::unique_ptr<rtc::TestClient> out(
       CreateTCPTestClient(accepted_.release()));
 
   const char* buf = "test_packet";
   size_t len = strlen(buf);
 
   in->Send(buf, len);
   SocketAddress trans_addr;
   EXPECT_TRUE(out->CheckNextPacket(buf, len, &trans_addr));
 
   out->Send(buf, len);
   EXPECT_TRUE(in->CheckNextPacket(buf, len, &trans_addr));
 }
 // #endif