Use BoringSSL scopers in //net.

net/ssl/ssl_platform_key_win.cc

 // Copyright 2015 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 "net/ssl/ssl_platform_key.h"
 
 #include <windows.h>
 #include <NCrypt.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include <openssl/bn.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_capi_types.h"
 #include "crypto/wincrypt_shim.h"
 #include "net/base/net_errors.h"
 #include "net/cert/x509_certificate.h"
-#include "net/ssl/scoped_openssl_types.h"
 #include "net/ssl/ssl_platform_key_task_runner.h"
 #include "net/ssl/ssl_private_key.h"
 #include "net/ssl/threaded_ssl_private_key.h"
 
 namespace net {
 
 namespace {
 
 class SSLPlatformKeyCAPI : public ThreadedSSLPrivateKey::Delegate {
  public:
@@ skipping 174 matching lines @@
     // CNG emits raw ECDSA signatures, but BoringSSL expects a DER-encoded
     // ECDSA-Sig-Value.
     if (type_ == SSLPrivateKey::Type::ECDSA) {
       if (signature->size() % 2 != 0) {
         LOG(ERROR) << "Bad signature length";
         return ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED;
       }
       size_t order_len = signature->size() / 2;
 
       // Convert the RAW ECDSA signature to a DER-encoded ECDSA-Sig-Value.
-      crypto::ScopedECDSA_SIG sig(ECDSA_SIG_new());
+      bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_SIG_new());
       if (!sig || !BN_bin2bn(signature->data(), order_len, sig->r) ||
           !BN_bin2bn(signature->data() + order_len, order_len, sig->s)) {
         return ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED;
       }
 
       int len = i2d_ECDSA_SIG(sig.get(), nullptr);
       if (len <= 0)
         return ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED;
       signature->resize(len);
       uint8_t* ptr = signature->data();
@@ skipping 19 matching lines @@
 bool GetKeyInfo(const X509Certificate* certificate,
                 SSLPrivateKey::Type* out_type,
                 size_t* out_max_length) {
   crypto::OpenSSLErrStackTracer tracker(FROM_HERE);
 
   std::string der_encoded;
   if (!X509Certificate::GetDEREncoded(certificate->os_cert_handle(),
                                       &der_encoded))
     return false;
   const uint8_t* bytes = reinterpret_cast<const uint8_t*>(der_encoded.data());
-  ScopedX509 x509(d2i_X509(nullptr, &bytes, der_encoded.size()));
+  bssl::UniquePtr<X509> x509(d2i_X509(nullptr, &bytes, der_encoded.size()));
   if (!x509)
     return false;
-  crypto::ScopedEVP_PKEY key(X509_get_pubkey(x509.get()));
+  bssl::UniquePtr<EVP_PKEY> key(X509_get_pubkey(x509.get()));
   if (!key)
     return false;
   switch (EVP_PKEY_id(key.get())) {
     case EVP_PKEY_RSA:
       *out_type = SSLPrivateKey::Type::RSA;
       break;
     case EVP_PKEY_EC:
       *out_type = SSLPrivateKey::Type::ECDSA;
       break;
     default:
@@ skipping 37 matching lines @@
     delegate.reset(new SSLPlatformKeyCNG(prov_or_key, key_type, max_length));
   } else {
     DCHECK(SSLPrivateKey::Type::RSA == key_type);
     delegate.reset(new SSLPlatformKeyCAPI(prov_or_key, key_spec, max_length));
   }
   return make_scoped_refptr(new ThreadedSSLPrivateKey(
       std::move(delegate), GetSSLPlatformKeyTaskRunner()));
 }
 
 }  // namespace net