[style] Run webcrypto files through clang-format.

content/renderer/webcrypto/platform_crypto_openssl.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/renderer/webcrypto/platform_crypto.h"
 
 #include <vector>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
@@ skipping 41 matching lines @@
     case 24:
       return EVP_aes_192_cbc();
     case 32:
       return EVP_aes_256_cbc();
     default:
       return NULL;
   }
 }
 
 // OpenSSL constants for EVP_CipherInit_ex(), do not change
-enum CipherOperation {
-  kDoDecrypt = 0,
-  kDoEncrypt = 1
-};
+enum CipherOperation { kDoDecrypt = 0, kDoEncrypt = 1 };
 
 Status AesCbcEncryptDecrypt(EncryptOrDecrypt mode,
                             SymKey* key,
                             const CryptoData& iv,
                             const CryptoData& data,
                             blink::WebArrayBuffer* buffer) {
   CipherOperation cipher_operation =
       (mode == ENCRYPT) ? kDoEncrypt : kDoDecrypt;
 
   if (data.byte_length() >= INT_MAX - AES_BLOCK_SIZE) {
@@ skipping 59 matching lines @@
   return Status::Success();
 }
 
 }  // namespace
 
 Status ExportKeyRaw(SymKey* key, blink::WebArrayBuffer* buffer) {
   *buffer = CreateArrayBuffer(Uint8VectorStart(key->key()), key->key().size());
   return Status::Success();
 }
 
-void Init() {
-  crypto::EnsureOpenSSLInit();
-}
+void Init() { crypto::EnsureOpenSSLInit(); }
 
 Status EncryptDecryptAesCbc(EncryptOrDecrypt mode,
                             SymKey* key,
                             const CryptoData& data,
                             const CryptoData& iv,
                             blink::WebArrayBuffer* buffer) {
   // TODO(eroman): inline the function here.
   return AesCbcEncryptDecrypt(mode, key, iv, data, buffer);
 }
 
@@ skipping 24 matching lines @@
       return Status::ErrorUnexpected();
   }
 
   crypto::ScopedOpenSSL<EVP_MD_CTX, EVP_MD_CTX_destroy> digest_context(
       EVP_MD_CTX_create());
   if (!digest_context.get())
     return Status::Error();
 
   if (!EVP_DigestInit_ex(digest_context.get(), digest_algorithm, NULL) ||
       !EVP_DigestUpdate(
-           digest_context.get(), data.bytes(), data.byte_length())) {
+          digest_context.get(), data.bytes(), data.byte_length())) {
     return Status::Error();
   }
 
   const int hash_expected_size = EVP_MD_CTX_size(digest_context.get());
   if (hash_expected_size <= 0)
     return Status::ErrorUnexpected();
   DCHECK_LE(hash_expected_size, EVP_MAX_MD_SIZE);
 
   *buffer = blink::WebArrayBuffer::create(hash_expected_size, 1);
   unsigned char* const hash_buffer =
       reinterpret_cast<unsigned char* const>(buffer->data());
 
   unsigned int hash_size = 0;
   if (!EVP_DigestFinal_ex(digest_context.get(), hash_buffer, &hash_size) ||
       static_cast<int>(hash_size) != hash_expected_size) {
     buffer->reset();
     return Status::Error();
   }
 
   return Status::Success();
 }
 
-Status GenerateSecretKey(
-    const blink::WebCryptoAlgorithm& algorithm,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    unsigned keylen_bytes,
-    blink::WebCryptoKey* key) {
+Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
+                         bool extractable,
+                         blink::WebCryptoKeyUsageMask usage_mask,
+                         unsigned keylen_bytes,
+                         blink::WebCryptoKey* key) {
   // TODO(eroman): Is this right?
   if (keylen_bytes == 0)
     return Status::ErrorGenerateKeyLength();
 
   crypto::OpenSSLErrStackTracer(FROM_HERE);
 
   std::vector<unsigned char> random_bytes(keylen_bytes, 0);
   if (!(RAND_bytes(&random_bytes[0], keylen_bytes)))
     return Status::Error();
 
   *key = blink::WebCryptoKey::create(new SymKey(CryptoData(random_bytes)),
                                      blink::WebCryptoKeyTypeSecret,
                                      extractable,
                                      algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
-Status GenerateRsaKeyPair(
-    const blink::WebCryptoAlgorithm& algorithm,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    blink::WebCryptoKey* public_key,
-    blink::WebCryptoKey* private_key) {
+Status GenerateRsaKeyPair(const blink::WebCryptoAlgorithm& algorithm,
+                          bool extractable,
+                          blink::WebCryptoKeyUsageMask usage_mask,
+                          blink::WebCryptoKey* public_key,
+                          blink::WebCryptoKey* private_key) {
   // TODO(padolph): Placeholder for OpenSSL implementation.
   // Issue http://crbug.com/267888.
   return Status::ErrorUnsupported();
 }
 
 Status ImportKeyRaw(const blink::WebCryptoAlgorithm& algorithm,
                     const CryptoData& key_data,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
   *key = blink::WebCryptoKey::create(new SymKey(key_data),
                                      blink::WebCryptoKeyTypeSecret,
                                      extractable,
                                      algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
 Status SignHmac(SymKey* key,
                 const blink::WebCryptoAlgorithm& hash,
                 const CryptoData& data,
                 blink::WebArrayBuffer* buffer) {
   blink::WebArrayBuffer result;
 
-  // TODO(eroman): De-indent this code.
-      const EVP_MD* evp_sha = 0;
-      unsigned int hmac_expected_length = 0;
-      // Note that HMAC length is determined by the hash used.
-      switch (hash.id()) {
-        case blink::WebCryptoAlgorithmIdSha1:
-          evp_sha = EVP_sha1();
-          hmac_expected_length = SHA_DIGEST_LENGTH;
-          break;
-        case blink::WebCryptoAlgorithmIdSha224:
-          evp_sha = EVP_sha224();
-          hmac_expected_length = SHA224_DIGEST_LENGTH;
-          break;
-        case blink::WebCryptoAlgorithmIdSha256:
-          evp_sha = EVP_sha256();
-          hmac_expected_length = SHA256_DIGEST_LENGTH;
-          break;
-        case blink::WebCryptoAlgorithmIdSha384:
-          evp_sha = EVP_sha384();
-          hmac_expected_length = SHA384_DIGEST_LENGTH;
-          break;
-        case blink::WebCryptoAlgorithmIdSha512:
-          evp_sha = EVP_sha512();
-          hmac_expected_length = SHA512_DIGEST_LENGTH;
-          break;
-        default:
-          // Not a digest algorithm.
-          return Status::ErrorUnsupported();
-      }
+  const EVP_MD* evp_sha = 0;
+  unsigned int hmac_expected_length = 0;
+  // Note that HMAC length is determined by the hash used.
+  switch (hash.id()) {
+    case blink::WebCryptoAlgorithmIdSha1:
+      evp_sha = EVP_sha1();
+      hmac_expected_length = SHA_DIGEST_LENGTH;
+      break;
+    case blink::WebCryptoAlgorithmIdSha224:
+      evp_sha = EVP_sha224();
+      hmac_expected_length = SHA224_DIGEST_LENGTH;
+      break;
+    case blink::WebCryptoAlgorithmIdSha256:
+      evp_sha = EVP_sha256();
+      hmac_expected_length = SHA256_DIGEST_LENGTH;
+      break;
+    case blink::WebCryptoAlgorithmIdSha384:
+      evp_sha = EVP_sha384();
+      hmac_expected_length = SHA384_DIGEST_LENGTH;
+      break;
+    case blink::WebCryptoAlgorithmIdSha512:
+      evp_sha = EVP_sha512();
+      hmac_expected_length = SHA512_DIGEST_LENGTH;
+      break;
+    default:
+      // Not a digest algorithm.
+      return Status::ErrorUnsupported();
+  }
 
-      const std::vector<unsigned char>& raw_key = key->key();
+  const std::vector<unsigned char>& raw_key = key->key();
 
-      // OpenSSL wierdness here.
-      // First, HMAC() needs a void* for the key data, so make one up front as a
-      // cosmetic to avoid a cast. Second, OpenSSL does not like a NULL key,
-      // which will result if the raw_key vector is empty; an entirely valid
-      // case. Handle this specific case by pointing to an empty array.
-      const unsigned char null_key[] = {};
-      const void* const raw_key_voidp = raw_key.size() ? &raw_key[0] : null_key;
+  // OpenSSL wierdness here.
+  // First, HMAC() needs a void* for the key data, so make one up front as a
+  // cosmetic to avoid a cast. Second, OpenSSL does not like a NULL key,
+  // which will result if the raw_key vector is empty; an entirely valid
+  // case. Handle this specific case by pointing to an empty array.
+  const unsigned char null_key[] = {};
+  const void* const raw_key_voidp = raw_key.size() ? &raw_key[0] : null_key;
 
-      result = blink::WebArrayBuffer::create(hmac_expected_length, 1);
-      crypto::ScopedOpenSSLSafeSizeBuffer<EVP_MAX_MD_SIZE> hmac_result(
-          reinterpret_cast<unsigned char*>(result.data()),
-          hmac_expected_length);
+  result = blink::WebArrayBuffer::create(hmac_expected_length, 1);
+  crypto::ScopedOpenSSLSafeSizeBuffer<EVP_MAX_MD_SIZE> hmac_result(
+      reinterpret_cast<unsigned char*>(result.data()), hmac_expected_length);
 
-      crypto::OpenSSLErrStackTracer(FROM_HERE);
+  crypto::OpenSSLErrStackTracer(FROM_HERE);
 
-      unsigned int hmac_actual_length;
-      unsigned char* const success = HMAC(evp_sha,
-                                          raw_key_voidp,
-                                          raw_key.size(),
-                                          data.bytes(),
-                                          data.byte_length(),
-                                          hmac_result.safe_buffer(),
-                                          &hmac_actual_length);
-      if (!success || hmac_actual_length != hmac_expected_length)
-        return Status::Error();
+  unsigned int hmac_actual_length;
+  unsigned char* const success = HMAC(evp_sha,
+                                      raw_key_voidp,
+                                      raw_key.size(),
+                                      data.bytes(),
+                                      data.byte_length(),
+                                      hmac_result.safe_buffer(),
+                                      &hmac_actual_length);
+  if (!success || hmac_actual_length != hmac_expected_length)
+    return Status::Error();
 
   *buffer = result;
   return Status::Success();
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usage_mask,
                           const CryptoData& modulus_data,
                           const CryptoData& exponent_data,
@@ skipping 68 matching lines @@
 Status ExportKeySpki(PublicKey* key, blink::WebArrayBuffer* buffer) {
   // TODO(eroman): http://crbug.com/267888
   return Status::ErrorUnsupported();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content