Use new BoringSSL scopers in //components.

components/webcrypto/algorithms/rsa_sign.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 <openssl/digest.h>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
 #include <stddef.h>
 
 #include "base/numerics/safe_math.h"
 #include "components/webcrypto/algorithms/rsa_sign.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/status.h"
 #include "crypto/openssl_util.h"
-#include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
 namespace {
 
 // Extracts the OpenSSL key and digest from a WebCrypto key. The returned
 // pointers will remain valid as long as |key| is alive.
 Status GetPKeyAndDigest(const blink::WebCryptoKey& key,
                         EVP_PKEY** pkey,
@@ skipping 42 matching lines @@
 }  // namespace
 
 Status RsaSign(const blink::WebCryptoKey& key,
                unsigned int pss_salt_length_bytes,
                const CryptoData& data,
                std::vector<uint8_t>* buffer) {
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-  crypto::ScopedEVP_MD_CTX ctx(EVP_MD_CTX_create());
+  bssl::ScopedEVP_MD_CTX ctx;
   EVP_PKEY_CTX* pctx = NULL;  // Owned by |ctx|.
 
   EVP_PKEY* private_key = NULL;
   const EVP_MD* digest = NULL;
   Status status = GetPKeyAndDigest(key, &private_key, &digest);
   if (status.IsError())
     return status;
 
   // NOTE: A call to EVP_DigestSignFinal() with a NULL second parameter
   // returns a maximum allocation size, while the call without a NULL returns
   // the real one, which may be smaller.
   size_t sig_len = 0;
-  if (!ctx.get() ||
-      !EVP_DigestSignInit(ctx.get(), &pctx, digest, NULL, private_key)) {
+  if (!EVP_DigestSignInit(ctx.get(), &pctx, digest, NULL, private_key)) {
     return Status::OperationError();
   }
 
   // Set PSS-specific options (if applicable).
   status = ApplyRsaPssOptions(key, digest, pss_salt_length_bytes, pctx);
   if (status.IsError())
     return status;
 
   if (!EVP_DigestSignUpdate(ctx.get(), data.bytes(), data.byte_length()) ||
       !EVP_DigestSignFinal(ctx.get(), NULL, &sig_len)) {
@@ skipping 10 matching lines @@
 
 Status RsaVerify(const blink::WebCryptoKey& key,
                  unsigned int pss_salt_length_bytes,
                  const CryptoData& signature,
                  const CryptoData& data,
                  bool* signature_match) {
   if (key.type() != blink::WebCryptoKeyTypePublic)
     return Status::ErrorUnexpectedKeyType();
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-  crypto::ScopedEVP_MD_CTX ctx(EVP_MD_CTX_create());
+  bssl::ScopedEVP_MD_CTX ctx;
   EVP_PKEY_CTX* pctx = NULL;  // Owned by |ctx|.
 
   EVP_PKEY* public_key = NULL;
   const EVP_MD* digest = NULL;
   Status status = GetPKeyAndDigest(key, &public_key, &digest);
   if (status.IsError())
     return status;
 
   if (!EVP_DigestVerifyInit(ctx.get(), &pctx, digest, NULL, public_key))
     return Status::OperationError();
 
   // Set PSS-specific options (if applicable).
   status = ApplyRsaPssOptions(key, digest, pss_salt_length_bytes, pctx);
   if (status.IsError())
     return status;
 
   if (!EVP_DigestVerifyUpdate(ctx.get(), data.bytes(), data.byte_length()))
     return Status::OperationError();
 
   *signature_match = 1 == EVP_DigestVerifyFinal(ctx.get(), signature.bytes(),
                                                 signature.byte_length());
   return Status::Success();
 }
 
 }  // namespace webcrypto