Convert crypto to std::unique_ptr

crypto/symmetric_key_win.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/symmetric_key.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 // TODO(wtc): replace scoped_array by std::vector.
-#include "base/memory/scoped_ptr.h"
 #include "base/sys_byteorder.h"
 
 namespace crypto {
 
 namespace {
 
 // The following is a non-public Microsoft header documented in MSDN under
 // CryptImportKey / CryptExportKey. Following the header is the byte array of
 // the actual plaintext key.
 struct PlaintextBlobHeader {
@@ skipping 140 matching lines @@
 
 // Attempts to generate a random, |key_size_in_bits|-long HMAC key, for use
 // with the hash function |alg|.
 // |key_size_in_bits| must be >= 1/2 the hash size of |alg| for security.
 // Returns true if generation is successful, storing the generated key in
 // |*key| and the key provider (CSP) in |*provider|.
 bool GenerateHMACKey(size_t key_size_in_bits,
                      ALG_ID alg,
                      ScopedHCRYPTPROV* provider,
                      ScopedHCRYPTKEY* key,
-                     scoped_ptr<BYTE[]>* raw_key) {
+                     std::unique_ptr<BYTE[]>* raw_key) {
   DCHECK(provider);
   DCHECK(key);
   DCHECK(raw_key);
 
   if (!CheckHMACKeySize(key_size_in_bits, alg))
     return false;
 
   ScopedHCRYPTPROV safe_provider;
   // See comment in GenerateAESKey as to why NULL is acceptable for the
   // container name.
   BOOL ok = CryptAcquireContext(safe_provider.receive(), NULL, NULL,
                                 PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
   if (!ok)
     return false;
 
   DWORD key_size_in_bytes = static_cast<DWORD>(key_size_in_bits / 8);
-  scoped_ptr<BYTE[]> random(new BYTE[key_size_in_bytes]);
+  std::unique_ptr<BYTE[]> random(new BYTE[key_size_in_bytes]);
   ok = CryptGenRandom(safe_provider, key_size_in_bytes, random.get());
   if (!ok)
     return false;
 
   ScopedHCRYPTKEY safe_key;
   bool rv = ImportRawKey(safe_provider, CALG_HMAC, random.get(),
                          key_size_in_bytes, &safe_key);
   if (rv) {
     key->swap(safe_key);
     provider->swap(safe_provider);
@@ skipping 114 matching lines @@
 
 // static
 SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm,
                                               size_t key_size_in_bits) {
   DCHECK_GE(key_size_in_bits, 8u);
 
   ScopedHCRYPTPROV provider;
   ScopedHCRYPTKEY key;
 
   bool ok = false;
-  scoped_ptr<BYTE[]> raw_key;
+  std::unique_ptr<BYTE[]> raw_key;
 
   switch (algorithm) {
     case AES:
       ok = GenerateAESKey(key_size_in_bits, &provider, &key);
       break;
     case HMAC_SHA1:
       ok = GenerateHMACKey(key_size_in_bits, CALG_SHA1, &provider,
                            &key, &raw_key);
       break;
   }
@@ skipping 193 matching lines @@
                            HCRYPTKEY key,
                            const void* key_data, size_t key_size_in_bytes)
     : provider_(provider), key_(key) {
   if (key_data) {
     raw_key_.assign(reinterpret_cast<const char*>(key_data),
                     key_size_in_bytes);
   }
 }
 
 }  // namespace crypto