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

net/socket/tcp_socket_unittest.cc

 // Copyright 2013 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/socket/tcp_socket.h"
 
 #include <stddef.h>
 #include <string.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/sockaddr_storage.h"
 #include "net/base/socket_performance_watcher.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 57 matching lines @@
       LOG(ERROR) << "Failed to listen on ::1 - probably because IPv6 is "
           "disabled. Skipping the test";
       return;
     }
     ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
     *success = true;
   }
 
   void TestAcceptAsync() {
     TestCompletionCallback accept_callback;
-    scoped_ptr<TCPSocket> accepted_socket;
+    std::unique_ptr<TCPSocket> accepted_socket;
     IPEndPoint accepted_address;
     ASSERT_EQ(ERR_IO_PENDING,
               socket_.Accept(&accepted_socket, &accepted_address,
                              accept_callback.callback()));
 
     TestCompletionCallback connect_callback;
     TCPClientSocket connecting_socket(local_address_list(), NULL, NULL,
                                       NetLog::Source());
     connecting_socket.Connect(connect_callback.callback());
 
@@ skipping 17 matching lines @@
   // is the expected number of RTT notifications received by the SPW.
   // This test works by writing |num_messages| to the socket. A different
   // socket (with a SPW attached to it) reads the messages.
   void TestSPWNotifications(const base::TimeDelta& advance_ticks,
                             bool should_notify_updated_rtt,
                             size_t num_messages,
                             size_t expect_connection_changed_count,
                             size_t expect_rtt_notification_count) {
     ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
 
-    scoped_ptr<base::SimpleTestTickClock> tick_clock(
+    std::unique_ptr<base::SimpleTestTickClock> tick_clock(
         new base::SimpleTestTickClock());
     base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
     tick_clock_ptr->SetNowTicks(base::TimeTicks::Now());
 
     TestCompletionCallback connect_callback;
 
-    scoped_ptr<TestSocketPerformanceWatcher> watcher(
+    std::unique_ptr<TestSocketPerformanceWatcher> watcher(
         new TestSocketPerformanceWatcher(should_notify_updated_rtt));
     TestSocketPerformanceWatcher* watcher_ptr = watcher.get();
 
     TCPSocket connecting_socket(std::move(watcher), NULL, NetLog::Source());
     connecting_socket.SetTickClockForTesting(std::move(tick_clock));
 
     int result = connecting_socket.Open(ADDRESS_FAMILY_IPV4);
     ASSERT_EQ(OK, result);
     connecting_socket.Connect(local_address_, connect_callback.callback());
 
     TestCompletionCallback accept_callback;
-    scoped_ptr<TCPSocket> accepted_socket;
+    std::unique_ptr<TCPSocket> accepted_socket;
     IPEndPoint accepted_address;
     result = socket_.Accept(&accepted_socket, &accepted_address,
                             accept_callback.callback());
     ASSERT_EQ(OK, accept_callback.GetResult(result));
 
     ASSERT_TRUE(accepted_socket.get());
 
     // Both sockets should be on the loopback network interface.
     EXPECT_EQ(accepted_address.address(), local_address_.address());
 
@@ skipping 43 matching lines @@
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
 
   TestCompletionCallback connect_callback;
   // TODO(yzshen): Switch to use TCPSocket when it supports client socket
   // operations.
   TCPClientSocket connecting_socket(local_address_list(), NULL, NULL,
                                     NetLog::Source());
   connecting_socket.Connect(connect_callback.callback());
 
   TestCompletionCallback accept_callback;
-  scoped_ptr<TCPSocket> accepted_socket;
+  std::unique_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
   int result = socket_.Accept(&accepted_socket, &accepted_address,
                               accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_TRUE(accepted_socket.get());
 
   // Both sockets should be on the loopback network interface.
@@ skipping 25 matching lines @@
 
   TestAcceptAsync();
 }
 #endif
 
 // Accept two connections simultaneously.
 TEST_F(TCPSocketTest, Accept2Connections) {
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
 
   TestCompletionCallback accept_callback;
-  scoped_ptr<TCPSocket> accepted_socket;
+  std::unique_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
 
   ASSERT_EQ(ERR_IO_PENDING,
             socket_.Accept(&accepted_socket, &accepted_address,
                            accept_callback.callback()));
 
   TestCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(local_address_list(), NULL, NULL,
                                     NetLog::Source());
   connecting_socket.Connect(connect_callback.callback());
 
   TestCompletionCallback connect_callback2;
   TCPClientSocket connecting_socket2(local_address_list(), NULL, NULL,
                                      NetLog::Source());
   connecting_socket2.Connect(connect_callback2.callback());
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
 
   TestCompletionCallback accept_callback2;
-  scoped_ptr<TCPSocket> accepted_socket2;
+  std::unique_ptr<TCPSocket> accepted_socket2;
   IPEndPoint accepted_address2;
 
   int result = socket_.Accept(&accepted_socket2, &accepted_address2,
                               accept_callback2.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback2.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
   EXPECT_EQ(OK, connect_callback2.WaitForResult());
@@ skipping 12 matching lines @@
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv6(&initialized));
   if (!initialized)
     return;
 
   TestCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(local_address_list(), NULL, NULL,
                                     NetLog::Source());
   connecting_socket.Connect(connect_callback.callback());
 
   TestCompletionCallback accept_callback;
-  scoped_ptr<TCPSocket> accepted_socket;
+  std::unique_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
   int result = socket_.Accept(&accepted_socket, &accepted_address,
                               accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_TRUE(accepted_socket.get());
 
   // Both sockets should be on the loopback network interface.
   EXPECT_EQ(accepted_address.address(), local_address_.address());
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
 }
 
 TEST_F(TCPSocketTest, ReadWrite) {
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
 
   TestCompletionCallback connect_callback;
   TCPSocket connecting_socket(NULL, NULL, NetLog::Source());
   int result = connecting_socket.Open(ADDRESS_FAMILY_IPV4);
   ASSERT_EQ(OK, result);
   connecting_socket.Connect(local_address_, connect_callback.callback());
 
   TestCompletionCallback accept_callback;
-  scoped_ptr<TCPSocket> accepted_socket;
+  std::unique_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
   result = socket_.Accept(&accepted_socket, &accepted_address,
                           accept_callback.callback());
   ASSERT_EQ(OK, accept_callback.GetResult(result));
 
   ASSERT_TRUE(accepted_socket.get());
 
   // Both sockets should be on the loopback network interface.
   EXPECT_EQ(accepted_address.address(), local_address_.address());
 
@@ skipping 56 matching lines @@
 // additional notification should be received for each message read since this
 // test advances clock by 2 seconds (which is longer than the minimum interval
 // between consecutive notifications) before every read.
 TEST_F(TCPSocketTest, SPWAdvance) {
   TestSPWNotifications(base::TimeDelta::FromSeconds(2), true, 2u, 0u, 3u);
 }
 #endif  // defined(TCP_INFO) || defined(OS_LINUX)
 
 }  // namespace
 }  // namespace net