Remove some unnecessary refcount increments in WebCrypto's EC code.

components/webcrypto/algorithms/ec.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 "components/webcrypto/algorithms/ec.h"
 
 #include <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/evp.h>
 #include <stddef.h>
@@ skipping 93 matching lines @@
 }
 
 // Verifies that an EC key imported from PKCS8 or SPKI format is correct.
 // This involves verifying the key validity, and the NID for the named curve.
 // Also removes the EC_PKEY_NO_PUBKEY flag if present.
 Status VerifyEcKeyAfterSpkiOrPkcs8Import(
     EVP_PKEY* pkey,
     blink::WebCryptoNamedCurve expected_named_curve) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
-  crypto::ScopedEC_KEY ec(EVP_PKEY_get1_EC_KEY(pkey));
-  if (!ec.get())
+  EC_KEY* ec = EVP_PKEY_get0_EC_KEY(pkey);
+  if (!ec)
     return Status::ErrorUnexpected();
 
   // When importing an ECPrivateKey, the public key is optional. If it was
   // omitted then the public key will be calculated by BoringSSL and added into
   // the EC_KEY. However an encoding flag is set such that when exporting to
   // PKCS8 format the public key is once again omitted. Remove this flag.
-  unsigned int enc_flags = EC_KEY_get_enc_flags(ec.get());
+  unsigned int enc_flags = EC_KEY_get_enc_flags(ec);
   enc_flags &= ~EC_PKEY_NO_PUBKEY;
-  EC_KEY_set_enc_flags(ec.get(), enc_flags);
+  EC_KEY_set_enc_flags(ec, enc_flags);
 
-  if (!EC_KEY_check_key(ec.get()))
+  if (!EC_KEY_check_key(ec))
     return Status::ErrorEcKeyInvalid();
 
   // Make sure the curve matches the expected curve name.
-  int curve_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec.get()));
+  int curve_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
   blink::WebCryptoNamedCurve named_curve = blink::WebCryptoNamedCurveP256;
   Status status = NidToWebCryptoCurve(curve_nid, &named_curve);
   if (status.IsError())
     return status;
 
   if (named_curve != expected_named_curve)
     return Status::ErrorImportedEcKeyIncorrectCurve();
 
   return Status::Success();
 }
@@ skipping 456 matching lines @@
 }
 
 // The format for JWK EC keys is given by:
 // https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-36#section-6.2
 Status EcAlgorithm::ExportKeyJwk(const blink::WebCryptoKey& key,
                                  std::vector<uint8_t>* buffer) const {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   EVP_PKEY* pkey = GetEVP_PKEY(key);
 
-  crypto::ScopedEC_KEY ec(EVP_PKEY_get1_EC_KEY(pkey));
-  if (!ec.get())
+  EC_KEY* ec = EVP_PKEY_get0_EC_KEY(pkey);
+  if (!ec)
     return Status::ErrorUnexpected();
 
   // No "alg" is set for EC keys.
   JwkWriter jwk(std::string(), key.extractable(), key.usages(), "EC");
 
   // Set the crv
   std::string crv;
   Status status =
       WebCryptoCurveToJwkCrv(key.algorithm().ecParams()->namedCurve(), &crv);
   if (status.IsError())
     return status;
 
-  int degree_bytes = GetGroupDegreeInBytes(ec.get());
+  int degree_bytes = GetGroupDegreeInBytes(ec);
 
   jwk.SetString("crv", crv);
 
   crypto::ScopedBIGNUM x;
   crypto::ScopedBIGNUM y;
-  status = GetPublicKey(ec.get(), &x, &y);
+  status = GetPublicKey(ec, &x, &y);
   if (status.IsError())
     return status;
 
   status = WritePaddedBIGNUM("x", x.get(), degree_bytes, &jwk);
   if (status.IsError())
     return status;
 
   status = WritePaddedBIGNUM("y", y.get(), degree_bytes, &jwk);
   if (status.IsError())
     return status;
 
   if (key.type() == blink::WebCryptoKeyTypePrivate) {
-    const BIGNUM* d = EC_KEY_get0_private_key(ec.get());
+    const BIGNUM* d = EC_KEY_get0_private_key(ec);
     status = WritePaddedBIGNUM("d", d, degree_bytes, &jwk);
     if (status.IsError())
       return status;
   }
 
   jwk.ToJson(buffer);
   return Status::Success();
 }
 
 // TODO(eroman): Defer import to the crypto thread. http://crbug.com/430763
@@ skipping 36 matching lines @@
 
   if (algorithm.ecParams()->namedCurve() !=
       key->algorithm().ecParams()->namedCurve()) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto