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

extensions/browser/api/cast_channel/cast_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/cast_channel/cast_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/cast_transport.h"
@@ skipping 51 matching lines @@
   FakeCertVerifier() {}
   ~FakeCertVerifier() override {}
 
   int Verify(net::X509Certificate* cert,
              const std::string&,
              const std::string&,
              int,
              net::CRLSet*,
              net::CertVerifyResult* verify_result,
              const net::CompletionCallback&,
-             scoped_ptr<net::CertVerifier::Request>*,
+             std::unique_ptr<net::CertVerifier::Request>*,
              const net::BoundNetLog&) override {
     verify_result->Reset();
     verify_result->verified_cert = cert;
     return net::OK;
   }
 };
 
 }  // namespace
 
 CastSocket::CastSocket(const std::string& owner_extension_id)
@@ skipping 67 matching lines @@
 }
 
 bool CastSocketImpl::keep_alive() const {
   return keep_alive_;
 }
 
 bool CastSocketImpl::audio_only() const {
   return audio_only_;
 }
 
-scoped_ptr<net::TCPClientSocket> CastSocketImpl::CreateTcpSocket() {
+std::unique_ptr<net::TCPClientSocket> CastSocketImpl::CreateTcpSocket() {
   net::AddressList addresses(ip_endpoint_);
-  return scoped_ptr<net::TCPClientSocket>(
+  return std::unique_ptr<net::TCPClientSocket>(
       new net::TCPClientSocket(addresses, nullptr, net_log_, net_log_source_));
   // Options cannot be set on the TCPClientSocket yet, because the
   // underlying platform socket will not be created until Bind()
   // or Connect() is called.
 }
 
-scoped_ptr<net::SSLClientSocket> CastSocketImpl::CreateSslSocket(
-    scoped_ptr<net::StreamSocket> socket) {
+std::unique_ptr<net::SSLClientSocket> CastSocketImpl::CreateSslSocket(
+    std::unique_ptr<net::StreamSocket> socket) {
   net::SSLConfig ssl_config;
-  cert_verifier_ = make_scoped_ptr(new FakeCertVerifier);
+  cert_verifier_ = base::WrapUnique(new FakeCertVerifier);
   transport_security_state_.reset(new net::TransportSecurityState);
   net::SSLClientSocketContext context;
   // CertVerifier and TransportSecurityState are owned by us, not the
   // context object.
   context.cert_verifier = cert_verifier_.get();
   context.transport_security_state = transport_security_state_.get();
 
-  scoped_ptr<net::ClientSocketHandle> connection(new net::ClientSocketHandle);
+  std::unique_ptr<net::ClientSocketHandle> connection(
+      new net::ClientSocketHandle);
   connection->SetSocket(std::move(socket));
   net::HostPortPair host_and_port = net::HostPortPair::FromIPEndPoint(
       ip_endpoint_);
 
   return net::ClientSocketFactory::GetDefaultFactory()->CreateSSLClientSocket(
       std::move(connection), host_and_port, ssl_config, context);
 }
 
 scoped_refptr<net::X509Certificate> CastSocketImpl::ExtractPeerCert() {
   net::SSLInfo ssl_info;
@@ skipping 27 matching lines @@
   if (result.success()) {
     VLOG(1) << result.error_message;
     if (!VerifyChannelPolicy(result)) {
       return false;
     }
   }
   return result.success();
 }
 
 void CastSocketImpl::SetTransportForTesting(
-    scoped_ptr<CastTransport> transport) {
+    std::unique_ptr<CastTransport> transport) {
   transport_ = std::move(transport);
 }
 
-void CastSocketImpl::Connect(scoped_ptr<CastTransport::Delegate> delegate,
+void CastSocketImpl::Connect(std::unique_ptr<CastTransport::Delegate> delegate,
                              base::Callback<void(ChannelError)> callback) {
   DCHECK(CalledOnValidThread());
   VLOG_WITH_CONNECTION(1) << "Connect readyState = " << ready_state_;
   DCHECK_EQ(proto::CONN_STATE_START_CONNECT, connect_state_);
 
   delegate_ = std::move(delegate);
 
   if (ready_state_ != READY_STATE_NONE) {
     logger_->LogSocketEventWithDetails(
         channel_id_, proto::CONNECT_FAILED, "ReadyState not NONE");
@@ skipping 161 matching lines @@
 
     // SSL connection succeeded.
     if (!transport_.get()) {
       // Create a channel transport if one wasn't already set (e.g. by test
       // code).
       transport_.reset(new CastTransportImpl(this->socket_.get(), channel_id_,
                                              ip_endpoint_, channel_auth_,
                                              logger_));
     }
     auth_delegate_ = new AuthTransportDelegate(this);
-    transport_->SetReadDelegate(make_scoped_ptr(auth_delegate_));
+    transport_->SetReadDelegate(base::WrapUnique(auth_delegate_));
     if (channel_auth_ == CHANNEL_AUTH_TYPE_SSL_VERIFIED) {
       // Additionally verify the connection with a handshake.
       SetConnectState(proto::CONN_STATE_AUTH_CHALLENGE_SEND);
     } else {
       SetConnectState(proto::CONN_STATE_FINISHED);
       transport_->Start();
     }
   } else if (result == net::ERR_CONNECTION_TIMED_OUT) {
     SetConnectState(proto::CONN_STATE_FINISHED);
     SetErrorState(CHANNEL_ERROR_CONNECT_TIMEOUT);
@@ skipping 174 matching lines @@
   VLOG_WITH_CONNECTION(1) << "SetErrorState " << error_state;
   DCHECK_EQ(CHANNEL_ERROR_NONE, error_state_);
   error_state_ = error_state;
   logger_->LogSocketErrorState(channel_id_, ErrorStateToProto(error_state_));
   delegate_->OnError(error_state_);
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 #undef VLOG_WITH_CONNECTION