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

net/socket/nss_ssl_util.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.
 
 #include "net/socket/nss_ssl_util.h"
 
 #include <nss.h>
 #include <secerr.h>
 #include <ssl.h>
 #include <sslerr.h>
@@ skipping 62 matching lines @@
 // CiphersCopy copies the zero-terminated array |in| to |out|. It returns the
 // number of cipher suite ids copied.
 size_t CiphersCopy(const uint16_t* in, uint16_t* out) {
   for (size_t i = 0; ; i++) {
     if (in[i] == 0)
       return i;
     out[i] = in[i];
   }
 }
 
-scoped_ptr<base::Value> NetLogSSLErrorCallback(
+std::unique_ptr<base::Value> NetLogSSLErrorCallback(
     int net_error,
     int ssl_lib_error,
     NetLogCaptureMode /* capture_mode */) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("net_error", net_error);
   if (ssl_lib_error)
     dict->SetInteger("ssl_lib_error", ssl_lib_error);
   return std::move(dict);
 }
 
 class NSSSSLInitSingleton {
  public:
   NSSSSLInitSingleton() : model_fd_(NULL) {
     crypto::EnsureNSSInit();
@@ skipping 52 matching lines @@
     static const uint16_t chacha_ciphers[] = {
         TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
         TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
         TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256, 0,
     };
     static const uint16_t aes_gcm_ciphers[] = {
         TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
         TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
         TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, 0,
     };
-    scoped_ptr<uint16_t[]> ciphers(new uint16_t[num_ciphers]);
+    std::unique_ptr<uint16_t[]> ciphers(new uint16_t[num_ciphers]);
     memcpy(ciphers.get(), ssl_ciphers, sizeof(uint16_t) * num_ciphers);
 
     if (CiphersRemove(chacha_ciphers, ciphers.get(), num_ciphers) &&
         CiphersRemove(aes_gcm_ciphers, ciphers.get(), num_ciphers)) {
       CiphersCompact(ciphers.get(), num_ciphers);
 
       const uint16_t* preference_ciphers = chacha_ciphers;
       const uint16_t* other_ciphers = aes_gcm_ciphers;
       base::CPU cpu;
 
@@ skipping 202 matching lines @@
       LOG(WARNING) << "Unknown error " << err << " (" << err_name << ")"
                    << " mapped to net::ERR_FAILED";
       return ERR_FAILED;
     }
   }
 }
 
 // Returns parameters to attach to the NetLog when we receive an error in
 // response to a call to an NSS function.  Used instead of
 // NetLogSSLErrorCallback with events of type TYPE_SSL_NSS_ERROR.
-scoped_ptr<base::Value> NetLogSSLFailedNSSFunctionCallback(
+std::unique_ptr<base::Value> NetLogSSLFailedNSSFunctionCallback(
     const char* function,
     const char* param,
     int ssl_lib_error,
     NetLogCaptureMode /* capture_mode */) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("function", function);
   if (param[0] != '\0')
     dict->SetString("param", param);
   dict->SetInteger("ssl_lib_error", ssl_lib_error);
   return std::move(dict);
 }
 
 void LogFailedNSSFunction(const BoundNetLog& net_log,
                           const char* function,
                           const char* param) {
   DCHECK(function);
   DCHECK(param);
   net_log.AddEvent(
       NetLog::TYPE_SSL_NSS_ERROR,
       base::Bind(&NetLogSSLFailedNSSFunctionCallback,
                  function, param, PR_GetError()));
 }
 
 NetLog::ParametersCallback CreateNetLogSSLErrorCallback(int net_error,
                                                         int ssl_lib_error) {
   return base::Bind(&NetLogSSLErrorCallback, net_error, ssl_lib_error);
 }
 
 }  // namespace net