Use new BoringSSL scopers in //crypto

crypto/signature_verifier.cc

 // Copyright (c) 2011 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/signature_verifier.h"
 
 #include <openssl/bytestring.h>
 #include <openssl/digest.h>
 #include <openssl/evp.h>
+#include <openssl/rsa.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
 #include "crypto/openssl_util.h"
-#include "crypto/scoped_openssl_types.h"
 
 namespace crypto {
 
 namespace {
 
 const EVP_MD* ToOpenSSLDigest(SignatureVerifier::HashAlgorithm hash_alg) {
   switch (hash_alg) {
     case SignatureVerifier::SHA1:
       return EVP_sha1();
     case SignatureVerifier::SHA256:
       return EVP_sha256();
   }
   return nullptr;
 }
 
 }  // namespace
 
 struct SignatureVerifier::VerifyContext {
-  ScopedEVP_MD_CTX ctx;
+  bssl::ScopedEVP_MD_CTX ctx;
 };
 
-SignatureVerifier::SignatureVerifier() : verify_context_(nullptr) {}
+SignatureVerifier::SignatureVerifier() {}
 
-SignatureVerifier::~SignatureVerifier() {
-  Reset();
-}
+SignatureVerifier::~SignatureVerifier() {}
 
 bool SignatureVerifier::VerifyInit(SignatureAlgorithm signature_algorithm,
                                    const uint8_t* signature,
                                    int signature_len,
                                    const uint8_t* public_key_info,
                                    int public_key_info_len) {
   int pkey_type = EVP_PKEY_NONE;
   const EVP_MD* digest = nullptr;
   switch (signature_algorithm) {
     case RSA_PKCS1_SHA1:
@@ skipping 70 matching lines @@
 bool SignatureVerifier::CommonInit(int pkey_type,
                                    const EVP_MD* digest,
                                    const uint8_t* signature,
                                    int signature_len,
                                    const uint8_t* public_key_info,
                                    int public_key_info_len,
                                    EVP_PKEY_CTX** pkey_ctx) {
   if (verify_context_)
     return false;
 
-  verify_context_ = new VerifyContext;
+  verify_context_.reset(new VerifyContext);
 
   signature_.assign(signature, signature + signature_len);
 
   CBS cbs;
   CBS_init(&cbs, public_key_info, public_key_info_len);
-  ScopedEVP_PKEY public_key(EVP_parse_public_key(&cbs));
+  bssl::UniquePtr<EVP_PKEY> public_key(EVP_parse_public_key(&cbs));
   if (!public_key || CBS_len(&cbs) != 0 ||
       EVP_PKEY_id(public_key.get()) != pkey_type) {
     return false;
   }
 
-  verify_context_->ctx.reset(EVP_MD_CTX_create());
   int rv = EVP_DigestVerifyInit(verify_context_->ctx.get(), pkey_ctx,
                                 digest, nullptr, public_key.get());
   return rv == 1;
 }
 
 void SignatureVerifier::Reset() {
-  delete verify_context_;
-  verify_context_ = nullptr;
+  verify_context_.reset();
   signature_.clear();
 }
 
 }  // namespace crypto