Use new BoringSSL scopers in //components.

components/gcm_driver/crypto/p256_key_util.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 "components/gcm_driver/crypto/p256_key_util.h"
 
 #include <openssl/ec.h>
 #include <openssl/ecdh.h>
 #include <openssl/evp.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "crypto/ec_private_key.h"
-#include "crypto/scoped_openssl_types.h"
 
 namespace gcm {
 
 namespace {
 
 // The first byte in an uncompressed P-256 point per SEC1 2.3.3.
 const char kUncompressedPointForm = 0x04;
 
 // A P-256 field element consists of 32 bytes.
 const size_t kFieldBytes = 32;
@@ skipping 76 matching lines @@
                                private_key.data() + private_key.size()),
           std::vector<uint8_t>(
               public_key_x509.data(),
               public_key_x509.data() + public_key_x509.size())));
 
   if (!local_key_pair) {
     DLOG(ERROR) << "Unable to create the local key pair.";
     return false;
   }
 
-  crypto::ScopedEC_KEY ec_private_key(
-      EVP_PKEY_get1_EC_KEY(local_key_pair->key()));
-
-  if (!ec_private_key || !EC_KEY_check_key(ec_private_key.get())) {
+  EC_KEY* ec_private_key = EVP_PKEY_get0_EC_KEY(local_key_pair->key());
+  if (!ec_private_key || !EC_KEY_check_key(ec_private_key)) {
     DLOG(ERROR) << "The private key is invalid.";
     return false;
   }
 
-  crypto::ScopedEC_POINT point(
-      EC_POINT_new(EC_KEY_get0_group(ec_private_key.get())));
+  bssl::UniquePtr<EC_POINT> point(
+      EC_POINT_new(EC_KEY_get0_group(ec_private_key)));
 
   if (!point ||
-      !EC_POINT_oct2point(EC_KEY_get0_group(ec_private_key.get()), point.get(),
-                                            reinterpret_cast<const uint8_t*>(
-                                                peer_public_key.data()),
-                                            peer_public_key.size(), nullptr)) {
+      !EC_POINT_oct2point(
+          EC_KEY_get0_group(ec_private_key), point.get(),
+          reinterpret_cast<const uint8_t*>(peer_public_key.data()),
+          peer_public_key.size(), nullptr)) {
     DLOG(ERROR) << "Can't convert peer public value to curve point.";
     return false;
   }
 
   uint8_t result[kFieldBytes];
-  if (ECDH_compute_key(result, sizeof(result), point.get(),
-                       ec_private_key.get(), nullptr) != sizeof(result)) {
+  if (ECDH_compute_key(result, sizeof(result), point.get(), ec_private_key,
+                       nullptr) != sizeof(result)) {
     DLOG(ERROR) << "Unable to compute the ECDH shared secret.";
     return false;
   }
 
   out_shared_secret->assign(reinterpret_cast<char*>(result), sizeof(result));
   return true;
 }
 
 }  // namespace gcm