Use BoringSSL scopers in //net.

net/base/keygen_handler_unittest.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 "net/base/keygen_handler.h"
 
 #include <openssl/bytestring.h>
 #include <openssl/evp.h>
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
-#include "crypto/scoped_openssl_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_NSS_CERTS)
 #include <private/pprthred.h>  // PR_DetachThread
 #include "crypto/nss_crypto_module_delegate.h"
 #include "crypto/scoped_test_nss_db.h"
 #endif
 
 namespace net {
 
@@ skipping 82 matching lines @@
   CBS public_key_and_challenge_raw;
   ASSERT_TRUE(CBS_get_asn1_element(&child, &public_key_and_challenge_raw,
                                    CBS_ASN1_SEQUENCE));
 
   // Parse out the PublicKeyAndChallenge.
   CBS copy = public_key_and_challenge_raw;
   CBS public_key_and_challenge;
   ASSERT_TRUE(
       CBS_get_asn1(&copy, &public_key_and_challenge, CBS_ASN1_SEQUENCE));
   ASSERT_EQ(0u, CBS_len(&copy));
-  crypto::ScopedEVP_PKEY key(EVP_parse_public_key(&public_key_and_challenge));
+  bssl::UniquePtr<EVP_PKEY> key(
+      EVP_parse_public_key(&public_key_and_challenge));
   ASSERT_TRUE(key);
   CBS challenge_spkac;
   ASSERT_TRUE(CBS_get_asn1(&public_key_and_challenge, &challenge_spkac,
                            CBS_ASN1_IA5STRING));
   ASSERT_EQ(0u, CBS_len(&public_key_and_challenge));
 
   // The challenge must match.
   ASSERT_EQ(challenge, StringPieceFromCBS(challenge_spkac));
 
   // The next element must be the AlgorithmIdentifier for MD5 with RSA.
@@ skipping 10 matching lines @@
 
   // Finally, parse the signature.
   CBS signature;
   ASSERT_TRUE(CBS_get_asn1(&child, &signature, CBS_ASN1_BITSTRING));
   ASSERT_EQ(0u, CBS_len(&child));
   uint8_t pad;
   ASSERT_TRUE(CBS_get_u8(&signature, &pad));
   ASSERT_EQ(0u, pad);
 
   // Check the signature.
-  crypto::ScopedEVP_MD_CTX ctx(EVP_MD_CTX_create());
+  bssl::ScopedEVP_MD_CTX ctx;
   ASSERT_TRUE(
       EVP_DigestVerifyInit(ctx.get(), nullptr, EVP_md5(), nullptr, key.get()));
   ASSERT_TRUE(EVP_DigestVerifyUpdate(ctx.get(),
                                      CBS_data(&public_key_and_challenge_raw),
                                      CBS_len(&public_key_and_challenge_raw)));
   ASSERT_TRUE(EVP_DigestVerifyFinal(ctx.get(), CBS_data(&signature),
                                     CBS_len(&signature)));
 }
 
 TEST_F(KeygenHandlerTest, SmokeTest) {
@@ skipping 53 matching lines @@
     events[i] = NULL;
 
     VLOG(1) << "KeygenHandler " << i << " produced: " << results[i];
     AssertValidSignedPublicKeyAndChallenge(results[i], "some challenge");
   }
 }
 
 }  // namespace
 
 }  // namespace net