Convert chrome/common to std::unique_ptr

chrome/common/extensions/api/networking_private/networking_private_crypto.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 "chrome/common/extensions/api/networking_private/networking_private_crypto.h"
 
 #include <openssl/digest.h>
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "crypto/openssl_util.h"
 #include "crypto/rsa_private_key.h"
 #include "crypto/scoped_openssl_types.h"
 #include "extensions/common/cast/cast_cert_validator.h"
 #include "net/cert/pem_tokenizer.h"
 
 namespace {
 
 namespace cast_crypto = ::extensions::api::cast_crypto;
@@ skipping 62 matching lines @@
       certs.push_back(ica_pem_tokenizer.data());
     } else {
       LOG(WARNING) << "Failed to parse intermediate certificates.";
     }
   }
 
   // Note that the device certificate's policy is not enforced here. The goal
   // is simply to verify that the device belongs to the Cast ecosystem.
   cast_crypto::CastDeviceCertPolicy unused_policy;
 
-  scoped_ptr<cast_crypto::CertVerificationContext> verification_context;
+  std::unique_ptr<cast_crypto::CertVerificationContext> verification_context;
   if (!cast_crypto::VerifyDeviceCert(certs, time, &verification_context,
                                      &unused_policy)) {
     LOG(ERROR) << kErrorPrefix << "Failed verifying cast device cert";
     return false;
   }
 
   // Check that the device listed in the certificate is correct.
   // Something like evt_e161 001a11ffacdf
   std::string common_name = verification_context->GetCommonName();
   std::string translated_mac;
@@ skipping 43 matching lines @@
                        const std::vector<uint8_t>& encrypted_data,
                        std::string* decrypted_output) {
   crypto::EnsureOpenSSLInit();
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   std::vector<uint8_t> private_key_data;
   if (!GetDERFromPEM(private_key_pem, "PRIVATE KEY", &private_key_data)) {
     LOG(ERROR) << "Failed to parse private key PEM.";
     return false;
   }
-  scoped_ptr<crypto::RSAPrivateKey> private_key(
+  std::unique_ptr<crypto::RSAPrivateKey> private_key(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(private_key_data));
   if (!private_key || !private_key->key()) {
     LOG(ERROR) << "Failed to parse private key DER.";
     return false;
   }
 
   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(private_key->key()));
   if (!rsa || RSA_size(rsa.get()) == 0) {
     LOG(ERROR) << "Failed to get RSA key.";
     return false;
   }
 
   uint8_t* output = reinterpret_cast<uint8_t*>(
       base::WriteInto(decrypted_output, RSA_size(rsa.get()) + 1));
   int output_length =
       RSA_private_decrypt(encrypted_data.size(), &encrypted_data[0], output,
                           rsa.get(), RSA_PKCS1_PADDING);
   if (output_length < 0) {
     LOG(ERROR) << "Error during decryption.";
     return false;
   }
   decrypted_output->resize(output_length);
   return true;
 }
 
 }  // namespace networking_private_crypto