Cleanup: rename usage_mask --> usages.

content/child/webcrypto/webcrypto_impl.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/webcrypto_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 193 matching lines @@
 
   std::vector<uint8_t> buffer;
 };
 
 typedef EncryptState DecryptState;
 typedef EncryptState DigestState;
 
 struct GenerateKeyState : public BaseState {
   GenerateKeyState(const blink::WebCryptoAlgorithm& algorithm,
                    bool extractable,
-                   blink::WebCryptoKeyUsageMask usage_mask,
+                   blink::WebCryptoKeyUsageMask usages,
                    const blink::WebCryptoResult& result)
       : BaseState(result),
         algorithm(algorithm),
         extractable(extractable),
-        usage_mask(usage_mask) {}
+        usages(usages) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const bool extractable;
-  const blink::WebCryptoKeyUsageMask usage_mask;
+  const blink::WebCryptoKeyUsageMask usages;
 
   webcrypto::GenerateKeyResult generate_key_result;
 };
 
 struct ImportKeyState : public BaseState {
   ImportKeyState(blink::WebCryptoKeyFormat format,
                  const unsigned char* key_data,
                  unsigned int key_data_size,
                  const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
-                 blink::WebCryptoKeyUsageMask usage_mask,
+                 blink::WebCryptoKeyUsageMask usages,
                  const blink::WebCryptoResult& result)
       : BaseState(result),
         format(format),
         key_data(key_data, key_data + key_data_size),
         algorithm(algorithm),
         extractable(extractable),
-        usage_mask(usage_mask) {}
+        usages(usages) {}
 
   const blink::WebCryptoKeyFormat format;
   const std::vector<uint8_t> key_data;
   const blink::WebCryptoAlgorithm algorithm;
   const bool extractable;
-  const blink::WebCryptoKeyUsageMask usage_mask;
+  const blink::WebCryptoKeyUsageMask usages;
 
   blink::WebCryptoKey key;
 };
 
 struct ExportKeyState : public BaseState {
   ExportKeyState(blink::WebCryptoKeyFormat format,
                  const blink::WebCryptoKey& key,
                  const blink::WebCryptoResult& result)
       : BaseState(result), format(format), key(key) {}
 
@@ skipping 138 matching lines @@
     state->generate_key_result.Complete(&state->result);
   }
 }
 
 void DoGenerateKey(scoped_ptr<GenerateKeyState> passed_state) {
   GenerateKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::GenerateKey(state->algorithm,
                                          state->extractable,
-                                         state->usage_mask,
+                                         state->usages,
                                          &state->generate_key_result);
   state->origin_thread->PostTask(
       FROM_HERE, base::Bind(DoGenerateKeyReply, Passed(&passed_state)));
 }
 
 void DoImportKeyReply(scoped_ptr<ImportKeyState> state) {
   CompleteWithKeyOrError(state->status, state->key, &state->result);
 }
 
 void DoImportKey(scoped_ptr<ImportKeyState> passed_state) {
   ImportKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
   state->status = webcrypto::ImportKey(state->format,
                                        webcrypto::CryptoData(state->key_data),
                                        state->algorithm,
                                        state->extractable,
-                                       state->usage_mask,
+                                       state->usages,
                                        &state->key);
   if (state->status.IsSuccess()) {
     DCHECK(state->key.handle());
     DCHECK(!state->key.algorithm().isNull());
     DCHECK_EQ(state->extractable, state->key.extractable());
   }
 
   state->origin_thread->PostTask(
       FROM_HERE, base::Bind(DoImportKeyReply, Passed(&passed_state)));
 }
@@ skipping 149 matching lines @@
   scoped_ptr<DigestState> state(new DigestState(
       algorithm, blink::WebCryptoKey::createNull(), data, data_size, result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
                                   base::Bind(DoDigest, Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::generateKey(const blink::WebCryptoAlgorithm& algorithm,
                                 bool extractable,
-                                blink::WebCryptoKeyUsageMask usage_mask,
+                                blink::WebCryptoKeyUsageMask usages,
                                 blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
 
   scoped_ptr<GenerateKeyState> state(
-      new GenerateKeyState(algorithm, extractable, usage_mask, result));
+      new GenerateKeyState(algorithm, extractable, usages, result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
                                   base::Bind(DoGenerateKey, Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::importKey(blink::WebCryptoKeyFormat format,
                               const unsigned char* key_data,
                               unsigned int key_data_size,
                               const blink::WebCryptoAlgorithm& algorithm,
                               bool extractable,
-                              blink::WebCryptoKeyUsageMask usage_mask,
+                              blink::WebCryptoKeyUsageMask usages,
                               blink::WebCryptoResult result) {
-  scoped_ptr<ImportKeyState> state(new ImportKeyState(format,
-                                                      key_data,
-                                                      key_data_size,
-                                                      algorithm,
-                                                      extractable,
-                                                      usage_mask,
-                                                      result));
+  scoped_ptr<ImportKeyState> state(new ImportKeyState(
+      format, key_data, key_data_size, algorithm, extractable, usages, result));
   if (!CryptoThreadPool::PostTask(FROM_HERE,
                                   base::Bind(DoImportKey, Passed(&state)))) {
     CompleteWithThreadPoolError(&result);
   }
 }
 
 void WebCryptoImpl::exportKey(blink::WebCryptoKeyFormat format,
                               const blink::WebCryptoKey& key,
                               blink::WebCryptoResult result) {
   scoped_ptr<ExportKeyState> state(new ExportKeyState(format, key, result));
@@ skipping 93 matching lines @@
       &key);
 }
 
 bool WebCryptoImpl::serializeKeyForClone(
     const blink::WebCryptoKey& key,
     blink::WebVector<unsigned char>& key_data) {
   return webcrypto::SerializeKeyForClone(key, &key_data);
 }
 
 }  // namespace content