Cleanup: rename usage_mask --> usages.

content/child/webcrypto/test/test_helpers.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/test/test_helpers.h"
 
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 349 matching lines @@
   EXPECT_EQ(algorithm.id(), key.algorithm().id());
   EXPECT_EQ(extractable, key.extractable());
   EXPECT_EQ(usage, key.usages());
   return key;
 }
 
 void ImportRsaKeyPair(const std::vector<uint8_t>& spki_der,
                       const std::vector<uint8_t>& pkcs8_der,
                       const blink::WebCryptoAlgorithm& algorithm,
                       bool extractable,
-                      blink::WebCryptoKeyUsageMask public_key_usage_mask,
-                      blink::WebCryptoKeyUsageMask private_key_usage_mask,
+                      blink::WebCryptoKeyUsageMask public_key_usages,
+                      blink::WebCryptoKeyUsageMask private_key_usages,
                       blink::WebCryptoKey* public_key,
                       blink::WebCryptoKey* private_key) {
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(spki_der),
                       algorithm,
                       true,
-                      public_key_usage_mask,
+                      public_key_usages,
                       public_key));
   EXPECT_FALSE(public_key->isNull());
   EXPECT_TRUE(public_key->handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key->type());
   EXPECT_EQ(algorithm.id(), public_key->algorithm().id());
   EXPECT_TRUE(public_key->extractable());
-  EXPECT_EQ(public_key_usage_mask, public_key->usages());
+  EXPECT_EQ(public_key_usages, public_key->usages());
 
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(pkcs8_der),
                       algorithm,
                       extractable,
-                      private_key_usage_mask,
+                      private_key_usages,
                       private_key));
   EXPECT_FALSE(private_key->isNull());
   EXPECT_TRUE(private_key->handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key->type());
   EXPECT_EQ(algorithm.id(), private_key->algorithm().id());
   EXPECT_EQ(extractable, private_key->extractable());
-  EXPECT_EQ(private_key_usage_mask, private_key->usages());
+  EXPECT_EQ(private_key_usages, private_key->usages());
 }
 
 Status ImportKeyJwkFromDict(const base::DictionaryValue& dict,
                             const blink::WebCryptoAlgorithm& algorithm,
                             bool extractable,
-                            blink::WebCryptoKeyUsageMask usage_mask,
+                            blink::WebCryptoKeyUsageMask usages,
                             blink::WebCryptoKey* key) {
   return ImportKey(blink::WebCryptoKeyFormatJwk,
                    CryptoData(MakeJsonVector(dict)),
                    algorithm,
                    extractable,
-                   usage_mask,
+                   usages,
                    key);
 }
 
 scoped_ptr<base::DictionaryValue> GetJwkDictionary(
     const std::vector<uint8_t>& json) {
   base::StringPiece json_string(
       reinterpret_cast<const char*>(vector_as_array(&json)), json.size());
   base::Value* value = base::JSONReader::Read(json_string);
   EXPECT_TRUE(value);
   base::DictionaryValue* dict_value = NULL;
@@ skipping 171 matching lines @@
 
   // Export the key in raw format and compare to the original.
   std::vector<uint8_t> key_raw_out;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
   EXPECT_BYTES_EQ_HEX(key_hex, key_raw_out);
 }
 
 Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
                          bool extractable,
-                         blink::WebCryptoKeyUsageMask usage_mask,
+                         blink::WebCryptoKeyUsageMask usages,
                          blink::WebCryptoKey* key) {
   GenerateKeyResult result;
-  Status status = GenerateKey(algorithm, extractable, usage_mask, &result);
+  Status status = GenerateKey(algorithm, extractable, usages, &result);
   if (status.IsError())
     return status;
 
   if (result.type() != GenerateKeyResult::TYPE_SECRET_KEY)
     return Status::ErrorUnexpected();
 
   *key = result.secret_key();
 
   return Status::Success();
 }
 
 Status GenerateKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                        bool extractable,
-                       blink::WebCryptoKeyUsageMask usage_mask,
+                       blink::WebCryptoKeyUsageMask usages,
                        blink::WebCryptoKey* public_key,
                        blink::WebCryptoKey* private_key) {
   GenerateKeyResult result;
-  Status status = GenerateKey(algorithm, extractable, usage_mask, &result);
+  Status status = GenerateKey(algorithm, extractable, usages, &result);
   if (status.IsError())
     return status;
 
   if (result.type() != GenerateKeyResult::TYPE_PUBLIC_PRIVATE_KEY_PAIR)
     return Status::ErrorUnexpected();
 
   *public_key = result.public_key();
   *private_key = result.private_key();
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namesapce content