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

components/webcrypto/algorithms/rsa.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/rsa.h"
 
 #include <openssl/evp.h>
+#include <utility>
 
 #include "base/logging.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"
 #include "crypto/openssl_util.h"
@@ skipping 122 matching lines @@
     const blink::WebCryptoAlgorithm& hash,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) {
   blink::WebCryptoKeyAlgorithm key_algorithm;
   Status status = CreateRsaHashedKeyAlgorithm(
       rsa_algorithm_id, hash.id(), private_key.get(), &key_algorithm);
   if (status.IsError())
     return status;
 
-  return CreateWebCryptoPrivateKey(private_key.Pass(), key_algorithm,
+  return CreateWebCryptoPrivateKey(std::move(private_key), key_algorithm,
                                    extractable, usages, key);
 }
 
 // Creates a WebCryptoKey that wraps |public_key|.
 Status CreateWebCryptoRsaPublicKey(
     crypto::ScopedEVP_PKEY public_key,
     const blink::WebCryptoAlgorithmId rsa_algorithm_id,
     const blink::WebCryptoAlgorithm& hash,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) {
   blink::WebCryptoKeyAlgorithm key_algorithm;
   Status status = CreateRsaHashedKeyAlgorithm(rsa_algorithm_id, hash.id(),
                                               public_key.get(), &key_algorithm);
   if (status.IsError())
     return status;
 
-  return CreateWebCryptoPublicKey(public_key.Pass(), key_algorithm, extractable,
-                                  usages, key);
+  return CreateWebCryptoPublicKey(std::move(public_key), key_algorithm,
+                                  extractable, usages, key);
 }
 
 Status ImportRsaPrivateKey(const blink::WebCryptoAlgorithm& algorithm,
                            bool extractable,
                            blink::WebCryptoKeyUsageMask usages,
                            const JwkRsaInfo& params,
                            blink::WebCryptoKey* key) {
   crypto::ScopedRSA rsa(RSA_new());
 
   rsa->n = CreateBIGNUM(params.n);
@@ skipping 12 matching lines @@
 
   // TODO(eroman): This should be a DataError.
   if (!RSA_check_key(rsa.get()))
     return Status::OperationError();
 
   // Create a corresponding EVP_PKEY.
   crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get()))
     return Status::OperationError();
 
-  return CreateWebCryptoRsaPrivateKey(pkey.Pass(), algorithm.id(),
+  return CreateWebCryptoRsaPrivateKey(std::move(pkey), algorithm.id(),
                                       algorithm.rsaHashedImportParams()->hash(),
                                       extractable, usages, key);
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usages,
                           const CryptoData& n,
                           const CryptoData& e,
                           blink::WebCryptoKey* key) {
   crypto::ScopedRSA rsa(RSA_new());
 
   rsa->n = BN_bin2bn(n.bytes(), n.byte_length(), NULL);
   rsa->e = BN_bin2bn(e.bytes(), e.byte_length(), NULL);
 
   if (!rsa->n || !rsa->e)
     return Status::OperationError();
 
   // Create a corresponding EVP_PKEY.
   crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get()))
     return Status::OperationError();
 
-  return CreateWebCryptoRsaPublicKey(pkey.Pass(), algorithm.id(),
+  return CreateWebCryptoRsaPublicKey(std::move(pkey), algorithm.id(),
                                      algorithm.rsaHashedImportParams()->hash(),
                                      extractable, usages, key);
 }
 
 // Converts a BIGNUM to a big endian byte array.
 std::vector<uint8_t> BIGNUMToVector(const BIGNUM* n) {
   std::vector<uint8_t> v(BN_num_bytes(n));
   BN_bn2bin(n, v.data());
   return v;
 }
@@ skipping 76 matching lines @@
   if (!public_pkey ||
       !EVP_PKEY_set1_RSA(public_pkey.get(), rsa_public_key.get())) {
     return Status::OperationError();
   }
 
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey private_key;
 
   // Note that extractable is unconditionally set to true. This is because per
   // the WebCrypto spec generated public keys are always extractable.
-  status = CreateWebCryptoRsaPublicKey(public_pkey.Pass(), algorithm.id(),
+  status = CreateWebCryptoRsaPublicKey(std::move(public_pkey), algorithm.id(),
                                        params->hash(), true, public_usages,
                                        &public_key);
   if (status.IsError())
     return status;
 
-  status = CreateWebCryptoRsaPrivateKey(private_pkey.Pass(), algorithm.id(),
+  status = CreateWebCryptoRsaPrivateKey(std::move(private_pkey), algorithm.id(),
                                         params->hash(), extractable,
                                         private_usages, &private_key);
   if (status.IsError())
     return status;
 
   result->AssignKeyPair(public_key, private_key);
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::VerifyKeyUsagesBeforeImportKey(
@@ skipping 18 matching lines @@
   // Verify the parameters of the key.
   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(private_key.get()));
   if (!rsa.get())
     return Status::ErrorUnexpected();
   if (!RSA_check_key(rsa.get()))
     return Status::DataError();
 
   // TODO(eroman): Validate the algorithm OID against the webcrypto provided
   // hash. http://crbug.com/389400
 
-  return CreateWebCryptoRsaPrivateKey(private_key.Pass(), algorithm.id(),
+  return CreateWebCryptoRsaPrivateKey(std::move(private_key), algorithm.id(),
                                       algorithm.rsaHashedImportParams()->hash(),
                                       extractable, usages, key);
 }
 
 Status RsaHashedAlgorithm::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_RSA, &public_key);
   if (status.IsError())
     return status;
 
   // TODO(eroman): Validate the algorithm OID against the webcrypto provided
   // hash. http://crbug.com/389400
 
-  return CreateWebCryptoRsaPublicKey(public_key.Pass(), algorithm.id(),
+  return CreateWebCryptoRsaPublicKey(std::move(public_key), algorithm.id(),
                                      algorithm.rsaHashedImportParams()->hash(),
                                      extractable, usages, key);
 }
 
 Status RsaHashedAlgorithm::ImportKeyJwk(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
@@ skipping 141 matching lines @@
           memcmp(algorithm.rsaHashedParams()->publicExponent().data(),
                  key->algorithm().rsaHashedParams()->publicExponent().data(),
                  key->algorithm().rsaHashedParams()->publicExponent().size())) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto