[style] Run webcrypto files through clang-format.

content/renderer/webcrypto/jwk.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 <algorithm>
 #include <functional>
 #include <map>
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 namespace webcrypto {
 
 namespace {
 
 typedef blink::WebCryptoAlgorithm (*AlgorithmCreationFunc)();
 
 class JwkAlgorithmInfo {
  public:
   JwkAlgorithmInfo()
       : creation_func_(NULL),
-        required_key_length_bytes_(NO_KEY_SIZE_REQUIREMENT) {
-
-  }
+        required_key_length_bytes_(NO_KEY_SIZE_REQUIREMENT) {}
 
   explicit JwkAlgorithmInfo(AlgorithmCreationFunc algorithm_creation_func)
       : creation_func_(algorithm_creation_func),
-        required_key_length_bytes_(NO_KEY_SIZE_REQUIREMENT) {
-  }
+        required_key_length_bytes_(NO_KEY_SIZE_REQUIREMENT) {}
 
   JwkAlgorithmInfo(AlgorithmCreationFunc algorithm_creation_func,
                    unsigned int required_key_length_bits)
       : creation_func_(algorithm_creation_func),
         required_key_length_bytes_(required_key_length_bits / 8) {
     DCHECK((required_key_length_bits % 8) == 0);
   }
 
   bool CreateAlgorithm(blink::WebCryptoAlgorithm* algorithm) const {
     *algorithm = creation_func_();
     return !algorithm->isNull();
   }
 
   bool IsInvalidKeyByteLength(size_t byte_length) const {
     if (required_key_length_bytes_ == NO_KEY_SIZE_REQUIREMENT)
       return false;
-    return required_key_length_bytes_  != byte_length;
+    return required_key_length_bytes_ != byte_length;
   }
 
  private:
   enum { NO_KEY_SIZE_REQUIREMENT = UINT_MAX };
 
   AlgorithmCreationFunc creation_func_;
 
   // The expected key size for the algorithm or NO_KEY_SIZE_REQUIREMENT.
   unsigned int required_key_length_bytes_;
-
 };
 
 typedef std::map<std::string, JwkAlgorithmInfo> JwkAlgorithmInfoMap;
 
 class JwkAlgorithmRegistry {
  public:
   JwkAlgorithmRegistry() {
     // TODO(eroman):
     // http://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-20
     // says HMAC with SHA-2 should have a key size at least as large as the
     // hash output.
-    alg_to_info_["HS256"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateHmacAlgorithmByHashId,
-                        blink::WebCryptoAlgorithmIdSha256>);
-    alg_to_info_["HS384"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateHmacAlgorithmByHashId,
-                        blink::WebCryptoAlgorithmIdSha384>);
-    alg_to_info_["HS512"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateHmacAlgorithmByHashId,
-                         blink::WebCryptoAlgorithmIdSha512>);
-    alg_to_info_["RS256"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateRsaSsaAlgorithm,
-                         blink::WebCryptoAlgorithmIdSha256>);
-    alg_to_info_["RS384"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateRsaSsaAlgorithm,
-                         blink::WebCryptoAlgorithmIdSha384>);
-    alg_to_info_["RS512"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateRsaSsaAlgorithm,
-                         blink::WebCryptoAlgorithmIdSha512>);
+    alg_to_info_["HS256"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacAlgorithmByHashId,
+                                          blink::WebCryptoAlgorithmIdSha256>);
+    alg_to_info_["HS384"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacAlgorithmByHashId,
+                                          blink::WebCryptoAlgorithmIdSha384>);
+    alg_to_info_["HS512"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacAlgorithmByHashId,
+                                          blink::WebCryptoAlgorithmIdSha512>);
+    alg_to_info_["RS256"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaAlgorithm,
+                                          blink::WebCryptoAlgorithmIdSha256>);
+    alg_to_info_["RS384"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaAlgorithm,
+                                          blink::WebCryptoAlgorithmIdSha384>);
+    alg_to_info_["RS512"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaAlgorithm,
+                                          blink::WebCryptoAlgorithmIdSha512>);
     alg_to_info_["RSA1_5"] = JwkAlgorithmInfo(
         &BindAlgorithmId<CreateAlgorithm,
                          blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5>);
-    alg_to_info_["RSA-OAEP"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateRsaOaepAlgorithm,
-                         blink::WebCryptoAlgorithmIdSha1>);
+    alg_to_info_["RSA-OAEP"] =
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaOaepAlgorithm,
+                                          blink::WebCryptoAlgorithmIdSha1>);
     // TODO(padolph): The Web Crypto spec does not enumerate AES-KW 128 yet
     alg_to_info_["A128KW"] =
         JwkAlgorithmInfo(&blink::WebCryptoAlgorithm::createNull, 128);
     // TODO(padolph): The Web Crypto spec does not enumerate AES-KW 256 yet
     alg_to_info_["A256KW"] =
         JwkAlgorithmInfo(&blink::WebCryptoAlgorithm::createNull, 256);
     alg_to_info_["A128GCM"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateAlgorithm,
-                         blink::WebCryptoAlgorithmIdAesGcm>, 128);
+        &BindAlgorithmId<CreateAlgorithm, blink::WebCryptoAlgorithmIdAesGcm>,
+        128);
     alg_to_info_["A256GCM"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateAlgorithm,
-                         blink::WebCryptoAlgorithmIdAesGcm>, 256);
+        &BindAlgorithmId<CreateAlgorithm, blink::WebCryptoAlgorithmIdAesGcm>,
+        256);
     alg_to_info_["A128CBC"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateAlgorithm,
-                         blink::WebCryptoAlgorithmIdAesCbc>, 128);
+        &BindAlgorithmId<CreateAlgorithm, blink::WebCryptoAlgorithmIdAesCbc>,
+        128);
     alg_to_info_["A192CBC"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateAlgorithm,
-                         blink::WebCryptoAlgorithmIdAesCbc>, 192);
+        &BindAlgorithmId<CreateAlgorithm, blink::WebCryptoAlgorithmIdAesCbc>,
+        192);
     alg_to_info_["A256CBC"] = JwkAlgorithmInfo(
-        &BindAlgorithmId<CreateAlgorithm,
-                         blink::WebCryptoAlgorithmIdAesCbc>, 256);
+        &BindAlgorithmId<CreateAlgorithm, blink::WebCryptoAlgorithmIdAesCbc>,
+        256);
   }
 
   // Returns NULL if the algorithm name was not registered.
   const JwkAlgorithmInfo* GetAlgorithmInfo(const std::string& jwk_alg) const {
     const JwkAlgorithmInfoMap::const_iterator pos = alg_to_info_.find(jwk_alg);
     if (pos == alg_to_info_.end())
       return NULL;
     return &pos->second;
   }
 
@@ skipping 16 matching lines @@
 bool WebCryptoAlgorithmsConsistent(const blink::WebCryptoAlgorithm& alg1,
                                    const blink::WebCryptoAlgorithm& alg2) {
   DCHECK(!alg1.isNull());
   DCHECK(!alg2.isNull());
   if (alg1.id() != alg2.id())
     return false;
   switch (alg1.id()) {
     case blink::WebCryptoAlgorithmIdHmac:
     case blink::WebCryptoAlgorithmIdRsaOaep:
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
-      if (WebCryptoAlgorithmsConsistent(
-              GetInnerHashAlgorithm(alg1),
-              GetInnerHashAlgorithm(alg2))) {
+      if (WebCryptoAlgorithmsConsistent(GetInnerHashAlgorithm(alg1),
+                                        GetInnerHashAlgorithm(alg2))) {
         return true;
       }
       break;
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
     case blink::WebCryptoAlgorithmIdSha1:
     case blink::WebCryptoAlgorithmIdSha224:
     case blink::WebCryptoAlgorithmIdSha256:
     case blink::WebCryptoAlgorithmIdSha384:
     case blink::WebCryptoAlgorithmIdSha512:
     case blink::WebCryptoAlgorithmIdAesCbc:
@@ skipping 73 matching lines @@
 
   if (!value->GetAsBoolean(result))
     return Status::ErrorJwkPropertyWrongType(path, "boolean");
 
   *property_exists = true;
   return Status::Success();
 }
 
 }  // namespace
 
-Status ImportKeyJwk(
-    const CryptoData& key_data,
-    const blink::WebCryptoAlgorithm& algorithm_or_null,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    blink::WebCryptoKey* key) {
+Status ImportKeyJwk(const CryptoData& key_data,
+                    const blink::WebCryptoAlgorithm& algorithm_or_null,
+                    bool extractable,
+                    blink::WebCryptoKeyUsageMask usage_mask,
+                    blink::WebCryptoKey* key) {
 
   // The goal of this method is to extract key material and meta data from the
   // incoming JWK, combine them with the input parameters, and ultimately import
   // a Web Crypto Key.
   //
   // JSON Web Key Format (JWK)
   // http://tools.ietf.org/html/draft-ietf-jose-json-web-key-16
   // TODO(padolph): Not all possible values are handled by this code right now
   //
   // A JWK is a simple JSON dictionary with the following entries
@@ skipping 188 matching lines @@
       return Status::ErrorJwkUnrecognizedAlgorithm();  // case 1
 
     // JWK alg valid
     if (algorithm_or_null.isNull()) {
       // input algorithm not specified
       algorithm = jwk_algorithm;  // case 2
     } else {
       // input algorithm specified
       if (!WebCryptoAlgorithmsConsistent(jwk_algorithm, algorithm_or_null))
         return Status::ErrorJwkAlgorithmInconsistent();  // case 3
-      algorithm = algorithm_or_null;  // case 4
+      algorithm = algorithm_or_null;                     // case 4
     }
   } else {
     // JWK alg missing
     if (algorithm_or_null.isNull())
       return Status::ErrorJwkAlgorithmMissing();  // case 5
-    algorithm = algorithm_or_null;  // case 6
+    algorithm = algorithm_or_null;                // case 6
   }
   DCHECK(!algorithm.isNull());
 
   // JWK "use" (optional) --> usage_mask parameter
   std::string jwk_use_value;
   bool has_jwk_use;
   status =
       GetOptionalJwkString(dict_value, "use", &jwk_use_value, &has_jwk_use);
   if (status.IsError())
     return status;
@@ skipping 75 matching lines @@
   } else {
     return Status::ErrorJwkUnrecognizedKty();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content