Convert Pass()→std::move() in //components/[n-z]*

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 <openssl/pkcs12.h>
 #include <stddef.h>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "components/webcrypto/algorithms/asymmetric_key_util.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/generate_key_result.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
@@ skipping 247 matching lines @@
 
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey private_key;
 
   blink::WebCryptoKeyAlgorithm key_algorithm =
       blink::WebCryptoKeyAlgorithm::createEc(algorithm.id(),
                                              params->namedCurve());
 
   // Note that extractable is unconditionally set to true. This is because per
   // the WebCrypto spec generated public keys are always extractable.
-  status = CreateWebCryptoPublicKey(public_pkey.Pass(), key_algorithm, true,
+  status = CreateWebCryptoPublicKey(std::move(public_pkey), key_algorithm, true,
                                     public_usages, &public_key);
   if (status.IsError())
     return status;
 
-  status = CreateWebCryptoPrivateKey(private_pkey.Pass(), key_algorithm,
+  status = CreateWebCryptoPrivateKey(std::move(private_pkey), key_algorithm,
                                      extractable, private_usages, &private_key);
   if (status.IsError())
     return status;
 
   result->AssignKeyPair(public_key, private_key);
   return Status::Success();
 }
 
 Status EcAlgorithm::VerifyKeyUsagesBeforeImportKey(
     blink::WebCryptoKeyFormat format,
@@ skipping 14 matching lines @@
     return status;
 
   const blink::WebCryptoEcKeyImportParams* params =
       algorithm.ecKeyImportParams();
 
   status = VerifyEcKeyAfterSpkiOrPkcs8Import(private_key.get(),
                                              params->namedCurve());
   if (status.IsError())
     return status;
 
-  return CreateWebCryptoPrivateKey(private_key.Pass(),
+  return CreateWebCryptoPrivateKey(std::move(private_key),
                                    blink::WebCryptoKeyAlgorithm::createEc(
                                        algorithm.id(), params->namedCurve()),
                                    extractable, usages, key);
 }
 
 Status EcAlgorithm::ImportKeySpki(const CryptoData& key_data,
                                   const blink::WebCryptoAlgorithm& algorithm,
                                   bool extractable,
                                   blink::WebCryptoKeyUsageMask usages,
                                   blink::WebCryptoKey* key) const {
   crypto::ScopedEVP_PKEY public_key;
   Status status =
       ImportUnverifiedPkeyFromSpki(key_data, EVP_PKEY_EC, &public_key);
   if (status.IsError())
     return status;
 
   const blink::WebCryptoEcKeyImportParams* params =
       algorithm.ecKeyImportParams();
 
   status =
       VerifyEcKeyAfterSpkiOrPkcs8Import(public_key.get(), params->namedCurve());
   if (status.IsError())
     return status;
 
-  return CreateWebCryptoPublicKey(public_key.Pass(),
+  return CreateWebCryptoPublicKey(std::move(public_key),
                                   blink::WebCryptoKeyAlgorithm::createEc(
                                       algorithm.id(), params->namedCurve()),
                                   extractable, usages, key);
 }
 
 // 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::ImportKeyJwk(const CryptoData& key_data,
                                  const blink::WebCryptoAlgorithm& algorithm,
                                  bool extractable,
@@ skipping 86 matching lines @@
   crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_EC_KEY(pkey.get(), ec.get()))
     return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm =
       blink::WebCryptoKeyAlgorithm::createEc(algorithm.id(),
                                              params->namedCurve());
 
   // Wrap the EVP_PKEY into a WebCryptoKey
   if (is_private_key) {
-    return CreateWebCryptoPrivateKey(pkey.Pass(), key_algorithm, extractable,
-                                     usages, key);
+    return CreateWebCryptoPrivateKey(std::move(pkey), key_algorithm,
+                                     extractable, usages, key);
   }
-  return CreateWebCryptoPublicKey(pkey.Pass(), key_algorithm, extractable,
+  return CreateWebCryptoPublicKey(std::move(pkey), key_algorithm, extractable,
                                   usages, key);
 }
 
 Status EcAlgorithm::ExportKeyPkcs8(const blink::WebCryptoKey& key,
                                    std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
   // This relies on the fact that PKCS8 formatted data was already
   // associated with the key during its creation (used by
   // structured clone).
@@ skipping 103 matching lines @@
 
   if (algorithm.ecParams()->namedCurve() !=
       key->algorithm().ecParams()->namedCurve()) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto