Cleanup: rename usage_mask --> usages.

content/child/webcrypto/nss/rsa_key_nss.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 "content/child/webcrypto/nss/rsa_key_nss.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/generate_key_result.h"
 #include "content/child/webcrypto/jwk.h"
@@ skipping 289 matching lines @@
 
   if (!encoded_key.get())
     return Status::OperationError();
 
   buffer->assign(encoded_key->data, encoded_key->data + encoded_key->len);
   return Status::Success();
 }
 
 Status ImportRsaPrivateKey(const blink::WebCryptoAlgorithm& algorithm,
                            bool extractable,
-                           blink::WebCryptoKeyUsageMask usage_mask,
+                           blink::WebCryptoKeyUsageMask usages,
                            const JwkRsaInfo& params,
                            blink::WebCryptoKey* key) {
   Status status = NssSupportsRsaPrivateKeyImport();
   if (status.IsError())
     return status;
 
   CK_OBJECT_CLASS obj_class = CKO_PRIVATE_KEY;
   CK_KEY_TYPE key_type = CKK_RSA;
   CK_BBOOL ck_false = CK_FALSE;
 
@@ skipping 81 matching lines @@
   if (status.IsError())
     return status;
 
   scoped_ptr<PrivateKeyNss> key_handle(
       new PrivateKeyNss(private_key.Pass(), CryptoData(pkcs8_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePrivate,
                                      extractable,
                                      key_algorithm,
-                                     usage_mask);
+                                     usages);
   return Status::Success();
 }
 
 Status ExportKeySpkiNss(SECKEYPublicKey* key, std::vector<uint8_t>* buffer) {
   const crypto::ScopedSECItem spki_der(
       SECKEY_EncodeDERSubjectPublicKeyInfo(key));
   if (!spki_der)
     return Status::OperationError();
 
   buffer->assign(spki_der->data, spki_der->data + spki_der->len);
   return Status::Success();
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
-                          blink::WebCryptoKeyUsageMask usage_mask,
+                          blink::WebCryptoKeyUsageMask usages,
                           const CryptoData& modulus_data,
                           const CryptoData& exponent_data,
                           blink::WebCryptoKey* key) {
   if (!modulus_data.byte_length())
     return Status::ErrorImportRsaEmptyModulus();
 
   if (!exponent_data.byte_length())
     return Status::ErrorImportRsaEmptyExponent();
 
   DCHECK(modulus_data.bytes());
@@ skipping 54 matching lines @@
   if (status.IsError())
     return status;
 
   scoped_ptr<PublicKeyNss> key_handle(
       new PublicKeyNss(pubkey.Pass(), CryptoData(spki_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
-                                     usage_mask);
+                                     usages);
   return Status::Success();
 }
 
 }  // namespace
 
 Status RsaHashedAlgorithm::GenerateKey(
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
-    blink::WebCryptoKeyUsageMask combined_usage_mask,
+    blink::WebCryptoKeyUsageMask combined_usages,
     GenerateKeyResult* result) const {
   Status status = CheckKeyCreationUsages(
-      all_public_key_usages_ | all_private_key_usages_, combined_usage_mask);
+      all_public_key_usages_ | all_private_key_usages_, combined_usages);
   if (status.IsError())
     return status;
 
-  const blink::WebCryptoKeyUsageMask public_usage_mask =
-      combined_usage_mask & all_public_key_usages_;
-  const blink::WebCryptoKeyUsageMask private_usage_mask =
-      combined_usage_mask & all_private_key_usages_;
+  const blink::WebCryptoKeyUsageMask public_usages =
+      combined_usages & all_public_key_usages_;
+  const blink::WebCryptoKeyUsageMask private_usages =
+      combined_usages & all_private_key_usages_;
 
   unsigned int public_exponent = 0;
   unsigned int modulus_length_bits = 0;
   status = GetRsaKeyGenParameters(algorithm.rsaHashedKeyGenParams(),
                                   &public_exponent,
                                   &modulus_length_bits);
   if (status.IsError())
     return status;
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
@@ skipping 50 matching lines @@
     return status;
 
   scoped_ptr<PrivateKeyNss> private_key_handle(
       new PrivateKeyNss(scoped_sec_private_key.Pass(), CryptoData(pkcs8_data)));
 
   blink::WebCryptoKey public_key =
       blink::WebCryptoKey::create(public_key_handle.release(),
                                   blink::WebCryptoKeyTypePublic,
                                   true,
                                   key_algorithm,
-                                  public_usage_mask);
+                                  public_usages);
 
   blink::WebCryptoKey private_key =
       blink::WebCryptoKey::create(private_key_handle.release(),
                                   blink::WebCryptoKeyTypePrivate,
                                   extractable,
                                   key_algorithm,
-                                  private_usage_mask);
+                                  private_usages);
 
   result->AssignKeyPair(public_key, private_key);
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::VerifyKeyUsagesBeforeImportKey(
     blink::WebCryptoKeyFormat format,
-    blink::WebCryptoKeyUsageMask usage_mask) const {
+    blink::WebCryptoKeyUsageMask usages) const {
   switch (format) {
     case blink::WebCryptoKeyFormatSpki:
-      return CheckKeyCreationUsages(all_public_key_usages_, usage_mask);
+      return CheckKeyCreationUsages(all_public_key_usages_, usages);
     case blink::WebCryptoKeyFormatPkcs8:
-      return CheckKeyCreationUsages(all_private_key_usages_, usage_mask);
+      return CheckKeyCreationUsages(all_private_key_usages_, usages);
     case blink::WebCryptoKeyFormatJwk:
       return CheckKeyCreationUsages(
-          all_public_key_usages_ | all_private_key_usages_, usage_mask);
+          all_public_key_usages_ | all_private_key_usages_, usages);
     default:
       return Status::ErrorUnsupportedImportKeyFormat();
   }
 }
 
 Status RsaHashedAlgorithm::ImportKeyPkcs8(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
+    blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
   Status status = NssSupportsRsaPrivateKeyImport();
   if (status.IsError())
     return status;
 
   if (!key_data.byte_length())
     return Status::ErrorImportEmptyKeyData();
 
   // The binary blob 'key_data' is expected to be a DER-encoded ASN.1 PKCS#8
   // private key info object.
@@ skipping 34 matching lines @@
   if (status.IsError())
     return status;
 
   scoped_ptr<PrivateKeyNss> key_handle(
       new PrivateKeyNss(private_key.Pass(), CryptoData(pkcs8_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePrivate,
                                      extractable,
                                      key_algorithm,
-                                     usage_mask);
+                                     usages);
 
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ImportKeySpki(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
+    blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
   if (!key_data.byte_length())
     return Status::ErrorImportEmptyKeyData();
 
   // The binary blob 'key_data' is expected to be a DER-encoded ASN.1 Subject
   // Public Key Info. Decode this to a CERTSubjectPublicKeyInfo.
   SECItem spki_item = MakeSECItemForBuffer(key_data);
   const ScopedCERTSubjectPublicKeyInfo spki(
       SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_item));
   if (!spki)
@@ skipping 23 matching lines @@
   if (status.IsError())
     return status;
 
   scoped_ptr<PublicKeyNss> key_handle(
       new PublicKeyNss(sec_public_key.Pass(), CryptoData(spki_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
-                                     usage_mask);
+                                     usages);
 
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ExportKeyPkcs8(const blink::WebCryptoKey& key,
                                           std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
   *buffer = PrivateKeyNss::Cast(key)->pkcs8_data();
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ExportKeySpki(const blink::WebCryptoKey& key,
                                          std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePublic)
     return Status::ErrorUnexpectedKeyType();
   *buffer = PublicKeyNss::Cast(key)->spki_data();
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ImportKeyJwk(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
+    blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
   const char* jwk_algorithm =
       GetJwkAlgorithm(algorithm.rsaHashedImportParams()->hash().id());
 
   if (!jwk_algorithm)
     return Status::ErrorUnexpected();
 
   JwkRsaInfo jwk;
   Status status =
-      ReadRsaKeyJwk(key_data, jwk_algorithm, extractable, usage_mask, &jwk);
+      ReadRsaKeyJwk(key_data, jwk_algorithm, extractable, usages, &jwk);
   if (status.IsError())
     return status;
 
   // Once the key type is known, verify the usages.
   status = CheckKeyCreationUsages(
       jwk.is_private_key ? all_private_key_usages_ : all_public_key_usages_,
-      usage_mask);
+      usages);
   if (status.IsError())
     return Status::ErrorCreateKeyBadUsages();
 
   return jwk.is_private_key
-             ? ImportRsaPrivateKey(algorithm, extractable, usage_mask, jwk, key)
+             ? ImportRsaPrivateKey(algorithm, extractable, usages, jwk, key)
              : ImportRsaPublicKey(algorithm,
                                   extractable,
-                                  usage_mask,
+                                  usages,
                                   CryptoData(jwk.n),
                                   CryptoData(jwk.e),
                                   key);
 }
 
 Status RsaHashedAlgorithm::ExportKeyJwk(const blink::WebCryptoKey& key,
                                         std::vector<uint8_t>* buffer) const {
   const char* jwk_algorithm =
       GetJwkAlgorithm(key.algorithm().rsaHashedParams()->hash().id());
 
@@ skipping 40 matching lines @@
       return Status::Success();
     }
     default:
       return Status::ErrorUnexpected();
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content