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

components/webcrypto/algorithms/ecdh.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 <openssl/ec.h>
 #include <openssl/ecdh.h>
 #include <openssl/evp.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 61 matching lines @@
     if (public_key.algorithm().id() != blink::WebCryptoAlgorithmIdEcdh)
       return Status::ErrorEcdhPublicKeyWrongAlgorithm();
 
     // The public and private keys come from different key pairs, however their
     // curves must match.
     if (public_key.algorithm().ecParams()->namedCurve() !=
         base_key.algorithm().ecParams()->namedCurve()) {
       return Status::ErrorEcdhCurveMismatch();
     }
 
-    crypto::ScopedEC_KEY public_key_ec(
-        EVP_PKEY_get1_EC_KEY(GetEVP_PKEY(public_key)));
+    EC_KEY* public_key_ec = EVP_PKEY_get0_EC_KEY(GetEVP_PKEY(public_key));
 
-    const EC_POINT* public_key_point =
-        EC_KEY_get0_public_key(public_key_ec.get());
+    const EC_POINT* public_key_point = EC_KEY_get0_public_key(public_key_ec);
 
-    crypto::ScopedEC_KEY private_key_ec(
-        EVP_PKEY_get1_EC_KEY(GetEVP_PKEY(base_key)));
+    EC_KEY* private_key_ec = EVP_PKEY_get0_EC_KEY(GetEVP_PKEY(base_key));
 
     // The size of the shared secret is the field size in bytes (rounded up).
     // Note that, if rounding was required, the most significant bits of the
     // secret are zero. So for P-521, the maximum length is 528 bits, not 521.
-    int field_size_bytes = NumBitsToBytes(
-        EC_GROUP_get_degree(EC_KEY_get0_group(private_key_ec.get())));
+    int field_size_bytes =
+        NumBitsToBytes(EC_GROUP_get_degree(EC_KEY_get0_group(private_key_ec)));
 
     // If a desired key length was not specified, default to the field size
     // (rounded up to nearest byte).
     unsigned int length_bits =
         has_optional_length_bits ? optional_length_bits : field_size_bytes * 8;
 
     // Short-circuit when deriving an empty key.
     // TODO(eroman): ECDH_compute_key() is not happy when given a NULL output.
     //               http://crbug.com/464194.
     if (length_bits == 0) {
       derived_bytes->clear();
       return Status::Success();
     }
 
     if (length_bits > static_cast<unsigned int>(field_size_bytes * 8))
       return Status::ErrorEcdhLengthTooBig(field_size_bytes * 8);
 
     // Resize to target length in bytes (BoringSSL can operate on a shorter
     // buffer than field_size_bytes).
     derived_bytes->resize(NumBitsToBytes(length_bits));
 
     int result = ECDH_compute_key(derived_bytes->data(), derived_bytes->size(),
-                                  public_key_point, private_key_ec.get(), 0);
+                                  public_key_point, private_key_ec, 0);
     if (result < 0 || static_cast<size_t>(result) != derived_bytes->size())
       return Status::OperationError();
 
     TruncateToBitLength(length_bits, derived_bytes);
     return Status::Success();
   }
 };
 
 }  // namespace
 
 std::unique_ptr<AlgorithmImplementation> CreateEcdhImplementation() {
   return base::WrapUnique(new EcdhImplementation);
 }
 
 }  // namespace webcrypto