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

net/socket/ssl_client_socket_openssl.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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <errno.h>
@@ skipping 100 matching lines @@
       *hash = SSLPrivateKey::Hash::SHA384;
       return true;
     case NID_sha512:
       *hash = SSLPrivateKey::Hash::SHA512;
       return true;
     default:
       return false;
   }
 }
 
-scoped_ptr<base::Value> NetLogPrivateKeyOperationCallback(
+std::unique_ptr<base::Value> NetLogPrivateKeyOperationCallback(
     SSLPrivateKey::Type type,
     SSLPrivateKey::Hash hash,
     NetLogCaptureMode mode) {
   std::string type_str;
   switch (type) {
     case SSLPrivateKey::Type::RSA:
       type_str = "RSA";
       break;
     case SSLPrivateKey::Type::ECDSA:
       type_str = "ECDSA";
@@ skipping 12 matching lines @@
       hash_str = "SHA256";
       break;
     case SSLPrivateKey::Hash::SHA384:
       hash_str = "SHA384";
       break;
     case SSLPrivateKey::Hash::SHA512:
       hash_str = "SHA512";
       break;
   }
 
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetString("type", type_str);
   value->SetString("hash", hash_str);
   return std::move(value);
 }
 
-scoped_ptr<base::Value> NetLogChannelIDLookupCallback(
+std::unique_ptr<base::Value> NetLogChannelIDLookupCallback(
     ChannelIDService* channel_id_service,
     NetLogCaptureMode capture_mode) {
   ChannelIDStore* store = channel_id_service->GetChannelIDStore();
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetBoolean("ephemeral", store->IsEphemeral());
   dict->SetString("service", base::HexEncode(&channel_id_service,
                                              sizeof(channel_id_service)));
   dict->SetString("store", base::HexEncode(&store, sizeof(store)));
   return std::move(dict);
 }
 
-scoped_ptr<base::Value> NetLogChannelIDLookupCompleteCallback(
+std::unique_ptr<base::Value> NetLogChannelIDLookupCompleteCallback(
     crypto::ECPrivateKey* key,
     int result,
     NetLogCaptureMode capture_mode) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("net_error", result);
   std::string raw_key;
   if (result == OK && key && key->ExportRawPublicKey(&raw_key)) {
     std::string key_to_log = "redacted";
     if (capture_mode.include_cookies_and_credentials()) {
       key_to_log = base::HexEncode(raw_key.data(), raw_key.length());
     }
     dict->SetString("key", key_to_log);
   }
   return std::move(dict);
@@ skipping 166 matching lines @@
   }
 #endif
 
   // This is the index used with SSL_get_ex_data to retrieve the owner
   // SSLClientSocketOpenSSL object from an SSL instance.
   int ssl_socket_data_index_;
 
   ScopedSSL_CTX ssl_ctx_;
 
 #if !defined(OS_NACL)
-  scoped_ptr<SSLKeyLogger> ssl_key_logger_;
+  std::unique_ptr<SSLKeyLogger> ssl_key_logger_;
 #endif
 
   // TODO(davidben): Use a separate cache per URLRequestContext.
   // https://crbug.com/458365
   //
   // TODO(davidben): Sessions should be invalidated on fatal
   // alerts. https://crbug.com/466352
   SSLClientSessionCacheOpenSSL session_cache_;
 };
 
@@ skipping 87 matching lines @@
 }
 
 // static
 void SSLClientSocket::ClearSessionCache() {
   SSLClientSocketOpenSSL::SSLContext* context =
       SSLClientSocketOpenSSL::SSLContext::GetInstance();
   context->session_cache()->Flush();
 }
 
 SSLClientSocketOpenSSL::SSLClientSocketOpenSSL(
-    scoped_ptr<ClientSocketHandle> transport_socket,
+    std::unique_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     const SSLClientSocketContext& context)
     : transport_send_busy_(false),
       transport_recv_busy_(false),
       pending_read_error_(kNoPendingResult),
       pending_read_ssl_error_(SSL_ERROR_NONE),
       transport_read_error_(OK),
       transport_write_error_(OK),
       server_cert_chain_(new PeerCertificateChain(NULL)),
@@ skipping 1823 matching lines @@
       tb_was_negotiated_ = true;
       return 1;
     }
   }
 
   *out_alert_value = SSL_AD_ILLEGAL_PARAMETER;
   return 0;
 }
 
 }  // namespace net