Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/socket/tls_socket.cc

 // Copyright 2014 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 "extensions/browser/api/socket/tls_socket.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
   if (version_str == "tls1") {
     version = net::SSL_PROTOCOL_VERSION_TLS1;
   } else if (version_str == "tls1.1") {
     version = net::SSL_PROTOCOL_VERSION_TLS1_1;
   } else if (version_str == "tls1.2") {
     version = net::SSL_PROTOCOL_VERSION_TLS1_2;
   }
   return version;
 }
 
-void TlsConnectDone(scoped_ptr<net::SSLClientSocket> ssl_socket,
+void TlsConnectDone(std::unique_ptr<net::SSLClientSocket> ssl_socket,
                     const std::string& extension_id,
                     const extensions::TLSSocket::SecureCallback& callback,
                     int result) {
   DVLOG(1) << "Got back result " << result << " " << net::ErrorToString(result);
 
   // No matter how the TLS connection attempt went, the underlying socket's
   // no longer bound to the original TCPSocket. It belongs to |ssl_socket|,
   // which is promoted here to a new API-accessible socket (via a TLSSocket
   // wrapper), or deleted.
   if (result != net::OK) {
-    callback.Run(scoped_ptr<extensions::TLSSocket>(), result);
+    callback.Run(std::unique_ptr<extensions::TLSSocket>(), result);
     return;
   };
 
   // Wrap the StreamSocket in a TLSSocket, which matches the extension socket
   // API. Set the handle of the socket to the new value, so that it can be
   // used for read/write/close/etc.
-  scoped_ptr<extensions::TLSSocket> wrapper(
+  std::unique_ptr<extensions::TLSSocket> wrapper(
       new extensions::TLSSocket(std::move(ssl_socket), extension_id));
 
   // Caller will end up deleting the prior TCPSocket, once it calls
   // SetSocket(..,wrapper).
   callback.Run(std::move(wrapper), result);
 }
 
 }  // namespace
 
 namespace extensions {
 
 const char kTLSSocketTypeInvalidError[] =
     "Cannot listen on a socket that is already connected.";
 
-TLSSocket::TLSSocket(scoped_ptr<net::StreamSocket> tls_socket,
+TLSSocket::TLSSocket(std::unique_ptr<net::StreamSocket> tls_socket,
                      const std::string& owner_extension_id)
     : ResumableTCPSocket(owner_extension_id),
       tls_socket_(std::move(tls_socket)) {}
 
 TLSSocket::~TLSSocket() {
   Disconnect();
 }
 
 void TLSSocket::Connect(const net::AddressList& address,
                         const CompletionCallback& callback) {
@@ skipping 96 matching lines @@
 void TLSSocket::UpgradeSocketToTLS(
     Socket* socket,
     scoped_refptr<net::SSLConfigService> ssl_config_service,
     net::CertVerifier* cert_verifier,
     net::TransportSecurityState* transport_security_state,
     const std::string& extension_id,
     api::socket::SecureOptions* options,
     const TLSSocket::SecureCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   TCPSocket* tcp_socket = static_cast<TCPSocket*>(socket);
-  scoped_ptr<net::SSLClientSocket> null_sock;
+  std::unique_ptr<net::SSLClientSocket> null_sock;
 
   if (!tcp_socket || tcp_socket->GetSocketType() != Socket::TYPE_TCP ||
       !tcp_socket->ClientStream() || !tcp_socket->IsConnected() ||
       tcp_socket->HasPendingRead()) {
     DVLOG(1) << "Failing before trying. socket is " << tcp_socket;
     if (tcp_socket) {
       DVLOG(1) << "type: " << tcp_socket->GetSocketType()
                << ", ClientStream is " << tcp_socket->ClientStream()
                << ", IsConnected: " << tcp_socket->IsConnected()
                << ", HasPendingRead: " << tcp_socket->HasPendingRead();
@@ skipping 20 matching lines @@
   // host, using this hostname.
   if (host_info.family == url::CanonHostInfo::BROKEN) {
     DVLOG(1) << "Could not canonicalize hostname";
     TlsConnectDone(std::move(null_sock), extension_id, callback,
                    net::ERR_INVALID_ARGUMENT);
     return;
   }
 
   net::HostPortPair host_and_port(canon_host, dest_host_port_pair.port());
 
-  scoped_ptr<net::ClientSocketHandle> socket_handle(
+  std::unique_ptr<net::ClientSocketHandle> socket_handle(
       new net::ClientSocketHandle());
 
   // Set the socket handle to the socket's client stream (that should be the
   // only one active here). Then have the old socket release ownership on
   // that client stream.
   socket_handle->SetSocket(
-      scoped_ptr<net::StreamSocket>(tcp_socket->ClientStream()));
+      std::unique_ptr<net::StreamSocket>(tcp_socket->ClientStream()));
   tcp_socket->Release();
 
   DCHECK(transport_security_state);
   net::SSLClientSocketContext context;
   context.cert_verifier = cert_verifier;
   context.transport_security_state = transport_security_state;
 
   // Fill in the SSL socket params.
   net::SSLConfig ssl_config;
   ssl_config_service->GetSSLConfig(&ssl_config);
@@ skipping 11 matching lines @@
     }
     if (version_max) {
       ssl_config.version_max = version_max;
     }
   }
 
   net::ClientSocketFactory* socket_factory =
       net::ClientSocketFactory::GetDefaultFactory();
 
   // Create the socket.
-  scoped_ptr<net::SSLClientSocket> ssl_socket(
+  std::unique_ptr<net::SSLClientSocket> ssl_socket(
       socket_factory->CreateSSLClientSocket(
           std::move(socket_handle), host_and_port, ssl_config, context));
 
   DVLOG(1) << "Attempting to secure a connection to " << tcp_socket->hostname()
            << ":" << dest_host_port_pair.port();
 
   // We need the contents of |ssl_socket| in order to invoke its Connect()
   // method. It belongs to |ssl_socket|, and we own that until our internal
   // callback (|connect_cb|, below) is invoked.
   net::SSLClientSocket* saved_ssl_socket = ssl_socket.get();
@@ skipping 19 matching lines @@
     if (status != net::OK) {
       DVLOG(1) << "Status is not OK or IO-pending: "
                << net::ErrorToString(status);
     }
     connect_cb.Run(status);
   }
 }
 
 }  // namespace extensions