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

net/socket/tcp_socket_posix.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 <errno.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 
@@ skipping 121 matching lines @@
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(/*task_is_slow=*/false).get(),
       FROM_HERE,
       base::Bind(SystemSupportsTCPFastOpen),
       base::Bind(RegisterTCPFastOpenIntentAndSupport, user_enabled));
 #endif
 }
 
 TCPSocketPosix::TCPSocketPosix(
-    scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
+    std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     NetLog* net_log,
     const NetLog::Source& source)
     : socket_performance_watcher_(std::move(socket_performance_watcher)),
       tick_clock_(new base::DefaultTickClock()),
       rtt_notifications_minimum_interval_(base::TimeDelta::FromSeconds(1)),
       use_tcp_fastopen_(false),
       tcp_fastopen_write_attempted_(false),
       tcp_fastopen_connected_(false),
       tcp_fastopen_status_(TCP_FASTOPEN_STATUS_UNKNOWN),
       logging_multiple_connect_attempts_(false),
@@ skipping 42 matching lines @@
     return ERR_ADDRESS_INVALID;
 
   return socket_->Bind(storage);
 }
 
 int TCPSocketPosix::Listen(int backlog) {
   DCHECK(socket_);
   return socket_->Listen(backlog);
 }
 
-int TCPSocketPosix::Accept(scoped_ptr<TCPSocketPosix>* tcp_socket,
+int TCPSocketPosix::Accept(std::unique_ptr<TCPSocketPosix>* tcp_socket,
                            IPEndPoint* address,
                            const CompletionCallback& callback) {
   DCHECK(tcp_socket);
   DCHECK(!callback.is_null());
   DCHECK(socket_);
   DCHECK(!accept_socket_);
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT);
 
   int rv = socket_->Accept(
@@ skipping 260 matching lines @@
 void TCPSocketPosix::EndLoggingMultipleConnectAttempts(int net_error) {
   if (logging_multiple_connect_attempts_) {
     LogConnectEnd(net_error);
     logging_multiple_connect_attempts_ = false;
   } else {
     NOTREACHED();
   }
 }
 
 void TCPSocketPosix::SetTickClockForTesting(
-    scoped_ptr<base::TickClock> tick_clock) {
+    std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
 }
 
-void TCPSocketPosix::AcceptCompleted(scoped_ptr<TCPSocketPosix>* tcp_socket,
-                                     IPEndPoint* address,
-                                     const CompletionCallback& callback,
-                                     int rv) {
+void TCPSocketPosix::AcceptCompleted(
+    std::unique_ptr<TCPSocketPosix>* tcp_socket,
+    IPEndPoint* address,
+    const CompletionCallback& callback,
+    int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   callback.Run(HandleAcceptCompleted(tcp_socket, address, rv));
 }
 
 int TCPSocketPosix::HandleAcceptCompleted(
-    scoped_ptr<TCPSocketPosix>* tcp_socket,
+    std::unique_ptr<TCPSocketPosix>* tcp_socket,
     IPEndPoint* address,
     int rv) {
   if (rv == OK)
     rv = BuildTcpSocketPosix(tcp_socket, address);
 
   if (rv == OK) {
     net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
                       CreateNetLogIPEndPointCallback(address));
   } else {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, rv);
   }
 
   return rv;
 }
 
-int TCPSocketPosix::BuildTcpSocketPosix(scoped_ptr<TCPSocketPosix>* tcp_socket,
-                                        IPEndPoint* address) {
+int TCPSocketPosix::BuildTcpSocketPosix(
+    std::unique_ptr<TCPSocketPosix>* tcp_socket,
+    IPEndPoint* address) {
   DCHECK(accept_socket_);
 
   SockaddrStorage storage;
   if (accept_socket_->GetPeerAddress(&storage) != OK ||
       !address->FromSockAddr(storage.addr, storage.addr_len)) {
     accept_socket_.reset();
     return ERR_ADDRESS_INVALID;
   }
 
   tcp_socket->reset(
@@ skipping 286 matching lines @@
     if (info.tcpi_rtt > 0) {
       *out_rtt = base::TimeDelta::FromMicroseconds(info.tcpi_rtt);
       return true;
     }
   }
 #endif  // defined(TCP_INFO)
   return false;
 }
 
 }  // namespace net