move KeyUsageAllows to more logical place(part2)

components/webcrypto/algorithm_dispatch.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/algorithm_dispatch.h"
 
 #include "base/logging.h"
 #include "components/webcrypto/algorithm_implementation.h"
 #include "components/webcrypto/algorithm_registry.h"
 #include "components/webcrypto/crypto_data.h"
@@ skipping 47 matching lines @@
 
   return impl->ExportKey(format, key, buffer);
 }
 
 }  // namespace
 
 Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                const blink::WebCryptoKey& key,
                const CryptoData& data,
                std::vector<uint8_t>* buffer) {
-  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageEncrypt))
+  if (!key.keyUsageAllows(blink::WebCryptoKeyUsageEncrypt))
     return Status::ErrorUnexpected();
   return EncryptDontCheckUsage(algorithm, key, data, buffer);
 }
 
 Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                const blink::WebCryptoKey& key,
                const CryptoData& data,
                std::vector<uint8_t>* buffer) {
-  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageDecrypt))
+  if (!key.keyUsageAllows(blink::WebCryptoKeyUsageDecrypt))
     return Status::ErrorUnexpected();
   return DecryptDontCheckKeyUsage(algorithm, key, data, buffer);
 }
 
 Status Digest(const blink::WebCryptoAlgorithm& algorithm,
               const CryptoData& data,
               std::vector<uint8_t>* buffer) {
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
@@ skipping 55 matching lines @@
                  std::vector<uint8_t>* buffer) {
   if (!key.extractable())
     return Status::ErrorKeyNotExtractable();
   return ExportKeyDontCheckExtractability(format, key, buffer);
 }
 
 Status Sign(const blink::WebCryptoAlgorithm& algorithm,
             const blink::WebCryptoKey& key,
             const CryptoData& data,
             std::vector<uint8_t>* buffer) {
-  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageSign))
+  if (!key.keyUsageAllows(blink::WebCryptoKeyUsageSign))
     return Status::ErrorUnexpected();
   if (algorithm.id() != key.algorithm().id())
     return Status::ErrorUnexpected();
 
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return status;
 
   return impl->Sign(algorithm, key, data, buffer);
 }
 
 Status Verify(const blink::WebCryptoAlgorithm& algorithm,
               const blink::WebCryptoKey& key,
               const CryptoData& signature,
               const CryptoData& data,
               bool* signature_match) {
-  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageVerify))
+  if (!key.keyUsageAllows(blink::WebCryptoKeyUsageVerify))
     return Status::ErrorUnexpected();
   if (algorithm.id() != key.algorithm().id())
     return Status::ErrorUnexpected();
 
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return status;
 
   return impl->Verify(algorithm, key, signature, data, signature_match);
 }
 
 Status WrapKey(blink::WebCryptoKeyFormat format,
                const blink::WebCryptoKey& key_to_wrap,
                const blink::WebCryptoKey& wrapping_key,
                const blink::WebCryptoAlgorithm& wrapping_algorithm,
                std::vector<uint8_t>* buffer) {
-  if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageWrapKey))
+  if (!wrapping_key.keyUsageAllows(blink::WebCryptoKeyUsageWrapKey))
     return Status::ErrorUnexpected();
 
   std::vector<uint8_t> exported_data;
   Status status = ExportKey(format, key_to_wrap, &exported_data);
   if (status.IsError())
     return status;
   return EncryptDontCheckUsage(wrapping_algorithm, wrapping_key,
                                CryptoData(exported_data), buffer);
 }
 
 Status UnwrapKey(blink::WebCryptoKeyFormat format,
                  const CryptoData& wrapped_key_data,
                  const blink::WebCryptoKey& wrapping_key,
                  const blink::WebCryptoAlgorithm& wrapping_algorithm,
                  const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  blink::WebCryptoKey* key) {
-  if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageUnwrapKey))
+  if (!wrapping_key.keyUsageAllows(blink::WebCryptoKeyUsageUnwrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   // Fail fast if the import is doomed to fail.
   const AlgorithmImplementation* import_impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &import_impl);
   if (status.IsError())
     return status;
 
@@ skipping 13 matching lines @@
   // key bytes however this should be OK. For more discussion see
   // http://crubg.com/372040
   return ImportKey(format, CryptoData(buffer), algorithm, extractable, usages,
                    key);
 }
 
 Status DeriveBits(const blink::WebCryptoAlgorithm& algorithm,
                   const blink::WebCryptoKey& base_key,
                   unsigned int length_bits,
                   std::vector<uint8_t>* derived_bytes) {
-  if (!KeyUsageAllows(base_key, blink::WebCryptoKeyUsageDeriveBits))
+  if (!base_key.keyUsageAllows(blink::WebCryptoKeyUsageDeriveBits))
     return Status::ErrorUnexpected();
 
   if (algorithm.id() != base_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return status;
 
   return impl->DeriveBits(algorithm, base_key, true, length_bits,
                           derived_bytes);
 }
 
 Status DeriveKey(const blink::WebCryptoAlgorithm& algorithm,
                  const blink::WebCryptoKey& base_key,
                  const blink::WebCryptoAlgorithm& import_algorithm,
                  const blink::WebCryptoAlgorithm& key_length_algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  blink::WebCryptoKey* derived_key) {
-  if (!KeyUsageAllows(base_key, blink::WebCryptoKeyUsageDeriveKey))
+  if (!base_key.keyUsageAllows(blink::WebCryptoKeyUsageDeriveKey))
     return Status::ErrorUnexpected();
 
   if (algorithm.id() != base_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   if (import_algorithm.id() != key_length_algorithm.id())
     return Status::ErrorUnexpected();
 
   const AlgorithmImplementation* import_impl = NULL;
   Status status =
@@ skipping 59 matching lines @@
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return false;
 
   status = impl->DeserializeKeyForClone(algorithm, type, extractable, usages,
                                         key_data, key);
   return status.IsSuccess();
 }
 
 }  // namespace webcrypto