Convert crypto to std::unique_ptr

crypto/ec_private_key_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.
 
 #include "crypto/ec_private_key.h"
 
 #include <openssl/bytestring.h>
 #include <openssl/ec.h>
 #include <openssl/evp.h>
 #include <openssl/mem.h>
 #include <openssl/pkcs12.h>
 #include <openssl/x509.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "crypto/auto_cbb.h"
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_openssl_types.h"
 
 namespace crypto {
 
 namespace {
 
 // Function pointer definition, for injecting the required key export function
 // into ExportKeyWithBio, below. |bio| is a temporary memory BIO object, and
@@ skipping 30 matching lines @@
 }
 
 }  // namespace
 
 ECPrivateKey::~ECPrivateKey() {
   if (key_)
     EVP_PKEY_free(key_);
 }
 
 ECPrivateKey* ECPrivateKey::Copy() const {
-  scoped_ptr<ECPrivateKey> copy(new ECPrivateKey);
+  std::unique_ptr<ECPrivateKey> copy(new ECPrivateKey);
   if (key_)
     copy->key_ = EVP_PKEY_up_ref(key_);
   return copy.release();
 }
 
 // static
 ECPrivateKey* ECPrivateKey::Create() {
   OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   ScopedEC_KEY ec_key(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1));
   if (!ec_key.get() || !EC_KEY_generate_key(ec_key.get()))
     return NULL;
 
-  scoped_ptr<ECPrivateKey> result(new ECPrivateKey());
+  std::unique_ptr<ECPrivateKey> result(new ECPrivateKey());
   result->key_ = EVP_PKEY_new();
   if (!result->key_ || !EVP_PKEY_set1_EC_KEY(result->key_, ec_key.get()))
     return NULL;
 
   CHECK_EQ(EVP_PKEY_EC, EVP_PKEY_type(result->key_->type));
   return result.release();
 }
 
 // static
 ECPrivateKey* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
@@ skipping 28 matching lines @@
     p8_decrypted.reset(PKCS8_decrypt_pbe(
         p8_encrypted.get(),
         reinterpret_cast<const uint8_t*>(password.data()),
         password.size()));
   }
 
   if (!p8_decrypted)
     return NULL;
 
   // Create a new EVP_PKEY for it.
-  scoped_ptr<ECPrivateKey> result(new ECPrivateKey);
+  std::unique_ptr<ECPrivateKey> result(new ECPrivateKey);
   result->key_ = EVP_PKCS82PKEY(p8_decrypted.get());
   if (!result->key_ || EVP_PKEY_type(result->key_->type) != EVP_PKEY_EC)
     return NULL;
 
   return result.release();
 }
 
 bool ECPrivateKey::ExportEncryptedPrivateKey(const std::string& password,
                                              int iterations,
                                              std::vector<uint8_t>* output) {
@@ skipping 74 matching lines @@
     return false;
   }
   output->assign(der, der + der_len);
   OPENSSL_free(der);
   return true;
 }
 
 ECPrivateKey::ECPrivateKey() : key_(NULL) {}
 
 }  // namespace crypto