Change scoped_ptr to std::unique_ptr in //net.

net/udp/udp_socket_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/udp/udp_socket.h"
 
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/bind.h"
@@ skipping 141 matching lines @@
 }
 
 void UDPSocketTest::ConnectTest(bool use_nonblocking_io) {
   const uint16_t kPort = 9999;
   std::string simple_message("hello world!");
 
   // Setup the server to listen.
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", kPort, &bind_address);
   TestNetLog server_log;
-  scoped_ptr<UDPServerSocket> server(
+  std::unique_ptr<UDPServerSocket> server(
       new UDPServerSocket(&server_log, NetLog::Source()));
 #if defined(OS_WIN)
   if (use_nonblocking_io)
     server->UseNonBlockingIO();
 #endif
   server->AllowAddressReuse();
   int rv = server->Listen(bind_address);
   ASSERT_EQ(OK, rv);
 
   // Setup the client.
   IPEndPoint server_address;
   CreateUDPAddress("127.0.0.1", kPort, &server_address);
   TestNetLog client_log;
-  scoped_ptr<UDPClientSocket> client(
+  std::unique_ptr<UDPClientSocket> client(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
                           &client_log, NetLog::Source()));
 #if defined(OS_WIN)
   if (use_nonblocking_io)
     client->UseNonBlockingIO();
 #endif
 
   rv = client->Connect(server_address);
   EXPECT_EQ(OK, rv);
 
@@ skipping 93 matching lines @@
 #endif
   const uint16_t kPort = 9999;
   std::string first_message("first message"), second_message("second message");
 
   IPEndPoint broadcast_address;
   CreateUDPAddress("255.255.255.255", kPort, &broadcast_address);
   IPEndPoint listen_address;
   CreateUDPAddress("0.0.0.0", kPort, &listen_address);
 
   TestNetLog server1_log, server2_log;
-  scoped_ptr<UDPServerSocket> server1(
+  std::unique_ptr<UDPServerSocket> server1(
       new UDPServerSocket(&server1_log, NetLog::Source()));
-  scoped_ptr<UDPServerSocket> server2(
+  std::unique_ptr<UDPServerSocket> server2(
       new UDPServerSocket(&server2_log, NetLog::Source()));
   server1->AllowAddressReuse();
   server1->AllowBroadcast();
   server2->AllowAddressReuse();
   server2->AllowBroadcast();
 
   int rv = server1->Listen(listen_address);
   EXPECT_EQ(OK, rv);
   rv = server2->Listen(listen_address);
   EXPECT_EQ(OK, rv);
@@ skipping 70 matching lines @@
 
   // Free the last socket, its local port is still in |used_ports|.
   delete sockets.back();
   sockets.pop_back();
 
   TestPrng test_prng(used_ports);
   RandIntCallback rand_int_cb =
       base::Bind(&TestPrng::GetNext, base::Unretained(&test_prng));
 
   // Create a socket with random binding policy and connect.
-  scoped_ptr<UDPClientSocket> test_socket(
-      new UDPClientSocket(DatagramSocket::RANDOM_BIND,
-                          rand_int_cb,
-                          NULL,
-                          NetLog::Source()));
+  std::unique_ptr<UDPClientSocket> test_socket(new UDPClientSocket(
+      DatagramSocket::RANDOM_BIND, rand_int_cb, NULL, NetLog::Source()));
   EXPECT_EQ(OK, test_socket->Connect(peer_address));
 
   // Make sure that the last port number in the |used_ports| was used.
   IPEndPoint client_address;
   EXPECT_EQ(OK, test_socket->GetLocalAddress(&client_address));
   EXPECT_EQ(used_ports.back(), client_address.port());
 
   STLDeleteElements(&sockets);
 }
 
 // Return a privileged port (under 1024) so binding will fail.
 int PrivilegedRand(int min, int max) {
   // Chosen by fair dice roll.  Guaranteed to be random.
   return 4;
 }
 
 #if defined(OS_IOS) && !TARGET_IPHONE_SIMULATOR
 // TODO(droger): On iOS this test fails on device (but passes on simulator).
 // See http://crbug.com/227760.
 #define MAYBE_ConnectFail DISABLED_ConnectFail
 #else
 #define MAYBE_ConnectFail ConnectFail
 #endif
 TEST_F(UDPSocketTest, MAYBE_ConnectFail) {
   IPEndPoint peer_address;
   CreateUDPAddress("0.0.0.0", 53, &peer_address);
 
-  scoped_ptr<UDPSocket> socket(
-      new UDPSocket(DatagramSocket::RANDOM_BIND,
-                    base::Bind(&PrivilegedRand),
-                    NULL,
-                    NetLog::Source()));
+  std::unique_ptr<UDPSocket> socket(new UDPSocket(DatagramSocket::RANDOM_BIND,
+                                                  base::Bind(&PrivilegedRand),
+                                                  NULL, NetLog::Source()));
   int rv = socket->Open(peer_address.GetFamily());
   EXPECT_EQ(OK, rv);
   rv = socket->Connect(peer_address);
   // Connect should have failed since we couldn't bind to that port,
   EXPECT_NE(OK, rv);
   // Make sure that UDPSocket actually closed the socket.
   EXPECT_FALSE(socket->is_connected());
 }
 
 // In this test, we verify that connect() on a socket will have the effect
@@ skipping 378 matching lines @@
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_NO_CHANGE));
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_DEFAULT));
   client.Close();
 }
 #endif
 
 }  // namespace net