Eliminate ScopedOpenSSL in favour of scoped_ptr<> specializations.

content/child/webcrypto/platform_crypto_openssl.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 "content/child/webcrypto/platform_crypto.h"
 
 #include <vector>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
 #include <openssl/rand.h>
 #include <openssl/sha.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "crypto/openssl_util.h"
+#include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace platform {
 
@@ skipping 62 matching lines @@
       (mode == ENCRYPT) ? kDoEncrypt : kDoDecrypt;
 
   if (data.byte_length() >= INT_MAX - AES_BLOCK_SIZE) {
     // TODO(padolph): Handle this by chunking the input fed into OpenSSL. Right
     // now it doesn't make much difference since the one-shot API would end up
     // blowing out the memory and crashing anyway.
     return Status::ErrorDataTooLarge();
   }
 
   // Note: PKCS padding is enabled by default
-  crypto::ScopedOpenSSL<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> context(
-      EVP_CIPHER_CTX_new());
+  scoped_ptr<EVP_CIPHER_CTX,
+             crypto::OpenSSLDestroyer<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> >
+      context(EVP_CIPHER_CTX_new());
 
   if (!context.get())
     return Status::OperationError();
 
   const EVP_CIPHER* const cipher = GetAESCipherByKeyLength(key->key().size());
   DCHECK(cipher);
 
   if (!EVP_CipherInit_ex(context.get(),
                          cipher,
                          NULL,
@@ skipping 112 matching lines @@
     DCHECK_LE(hash_expected_size, EVP_MAX_MD_SIZE);
 
     if (!EVP_DigestFinal_ex(digest_context_.get(), result, result_size) ||
         static_cast<int>(*result_size) != hash_expected_size)
       return Status::OperationError();
 
     return Status::Success();
   }
 
   bool initialized_;
-  crypto::ScopedOpenSSL<EVP_MD_CTX, EVP_MD_CTX_destroy> digest_context_;
+  crypto::ScopedEVP_MD_CTX digest_context_;
   blink::WebCryptoAlgorithmId algorithm_id_;
   unsigned char result_[EVP_MAX_MD_SIZE];
 };
 
 Status ExportKeyRaw(SymKey* key, std::vector<uint8>* buffer) {
   *buffer = key->key();
   return Status::Success();
 }
 
 void Init() { crypto::EnsureOpenSSLInit(); }
@@ skipping 181 matching lines @@
 
   if (!EVP_AEAD_CTX_init(&ctx,
                          aead_alg,
                          Uint8VectorStart(key->key()),
                          key->key().size(),
                          tag_length_bytes,
                          NULL)) {
     return Status::OperationError();
   }
 
-  crypto::ScopedOpenSSL<EVP_AEAD_CTX, EVP_AEAD_CTX_cleanup> ctx_cleanup(&ctx);
+  scoped_ptr<EVP_AEAD_CTX,
+             crypto::OpenSSLDestroyer<EVP_AEAD_CTX, EVP_AEAD_CTX_cleanup> >
+      ctx_cleanup(&ctx);
 
   ssize_t len;
 
   if (mode == DECRYPT) {
     if (data.byte_length() < tag_length_bytes)
       return Status::ErrorDataTooSmall();
 
     buffer->resize(data.byte_length() - tag_length_bytes);
 
     len = EVP_AEAD_CTX_open(&ctx,
@@ skipping 130 matching lines @@
     blink::WebCryptoKey* key) {
   // TODO(eroman): http://crbug.com/267888
   return false;
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content