[style] Run webcrypto files through clang-format.

content/renderer/webcrypto/platform_crypto_nss.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 <cryptohi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
@@ skipping 39 matching lines @@
 struct CK_GCM_PARAMS {
   CK_BYTE_PTR pIv;
   CK_ULONG ulIvLen;
   CK_BYTE_PTR pAAD;
   CK_ULONG ulAADLen;
   CK_ULONG ulTagBits;
 };
 #endif  // !defined(CKM_AES_GCM)
 
 // Signature for PK11_Encrypt and PK11_Decrypt.
-typedef SECStatus
-(*PK11_EncryptDecryptFunction)(
-    PK11SymKey*, CK_MECHANISM_TYPE, SECItem*,
-    unsigned char*, unsigned int*, unsigned int,
-    const unsigned char*, unsigned int);
+typedef SECStatus (*PK11_EncryptDecryptFunction)(PK11SymKey*,
+                                                 CK_MECHANISM_TYPE,
+                                                 SECItem*,
+                                                 unsigned char*,
+                                                 unsigned int*,
+                                                 unsigned int,
+                                                 const unsigned char*,
+                                                 unsigned int);
 
 // Singleton to abstract away dynamically loading libnss3.so
 class AesGcmSupport {
  public:
-  bool IsSupported() const {
-    return pk11_encrypt_func_ && pk11_decrypt_func_;
-  }
+  bool IsSupported() const { return pk11_encrypt_func_ && pk11_decrypt_func_; }
 
   // Returns NULL if unsupported.
   PK11_EncryptDecryptFunction pk11_encrypt_func() const {
     return pk11_encrypt_func_;
   }
 
   // Returns NULL if unsupported.
   PK11_EncryptDecryptFunction pk11_decrypt_func() const {
     return pk11_decrypt_func_;
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<AesGcmSupport>;
 
   AesGcmSupport() {
 #if !defined(USE_NSS)
     // Using a bundled version of NSS that is guaranteed to have this symbol.
     pk11_encrypt_func_ = PK11_Encrypt;
     pk11_decrypt_func_ = PK11_Decrypt;
 #else
     // Using system NSS libraries and PCKS #11 modules, which may not have the
     // necessary function (PK11_Encrypt) or mechanism support (CKM_AES_GCM).
 
     // If PK11_Encrypt() was successfully resolved, then NSS will support
     // AES-GCM directly. This was introduced in NSS 3.15.
-    pk11_encrypt_func_ =
-        reinterpret_cast<PK11_EncryptDecryptFunction>(
-            dlsym(RTLD_DEFAULT, "PK11_Encrypt"));
-    pk11_decrypt_func_ =
-        reinterpret_cast<PK11_EncryptDecryptFunction>(
-            dlsym(RTLD_DEFAULT, "PK11_Decrypt"));
+    pk11_encrypt_func_ = reinterpret_cast<PK11_EncryptDecryptFunction>(
+        dlsym(RTLD_DEFAULT, "PK11_Encrypt"));
+    pk11_decrypt_func_ = reinterpret_cast<PK11_EncryptDecryptFunction>(
+        dlsym(RTLD_DEFAULT, "PK11_Decrypt"));
 #endif
   }
 
   PK11_EncryptDecryptFunction pk11_encrypt_func_;
   PK11_EncryptDecryptFunction pk11_decrypt_func_;
 };
 
 base::LazyInstance<AesGcmSupport>::Leaky g_aes_gcm_support =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 52 matching lines @@
 };
 
 namespace {
 
 // Creates a SECItem for the data in |buffer|. This does NOT make a copy, so
 // |buffer| should outlive the SECItem.
 SECItem MakeSECItemForBuffer(const CryptoData& buffer) {
   SECItem item = {
       siBuffer,
       // NSS requires non-const data even though it is just for input.
-      const_cast<unsigned char*>(buffer.bytes()),
-      buffer.byte_length()
-  };
+      const_cast<unsigned char*>(buffer.bytes()), buffer.byte_length()};
   return item;
 }
 
 HASH_HashType WebCryptoAlgorithmToNSSHashType(
     blink::WebCryptoAlgorithmId algorithm) {
   switch (algorithm) {
     case blink::WebCryptoAlgorithmIdSha1:
       return HASH_AlgSHA1;
     case blink::WebCryptoAlgorithmIdSha224:
       return HASH_AlgSHA224;
@@ skipping 91 matching lines @@
     return Status::Error();
   }
 
   ShrinkBuffer(buffer, final_output_chunk_len + output_len);
   return Status::Success();
 }
 
 // Helper to either encrypt or decrypt for AES-GCM. The result of encryption is
 // the concatenation of the ciphertext and the authentication tag. Similarly,
 // this is the expectation for the input to decryption.
-Status AesGcmEncryptDecrypt(
-    EncryptOrDecrypt mode,
-    SymKey* key,
-    const CryptoData& data,
-    const CryptoData& iv,
-    const CryptoData& additional_data,
-    unsigned int tag_length_bits,
-    blink::WebArrayBuffer* buffer) {
+Status AesGcmEncryptDecrypt(EncryptOrDecrypt mode,
+                            SymKey* key,
+                            const CryptoData& data,
+                            const CryptoData& iv,
+                            const CryptoData& additional_data,
+                            unsigned int tag_length_bits,
+                            blink::WebArrayBuffer* buffer) {
   if (!g_aes_gcm_support.Get().IsSupported())
     return Status::ErrorUnsupported();
 
   // TODO(eroman): Is this necessary?
   if ((tag_length_bits % 8) != 0)
     return Status::ErrorInvalidAesGcmTagLength();
   unsigned int tag_length_bytes = tag_length_bits / 8;
 
   CK_GCM_PARAMS gcm_params = {0};
   gcm_params.pIv = const_cast<unsigned char*>(iv.bytes());
@@ skipping 29 matching lines @@
     // From the analysis of that bug it looks like it might be safe to pass a
     // correctly sized buffer but lie about its size. Since resizing the
     // WebCryptoArrayBuffer is expensive that hack may be worth looking into.
     buffer_size = data.byte_length();
   }
 
   *buffer = blink::WebArrayBuffer::create(buffer_size, 1);
   unsigned char* buffer_data = reinterpret_cast<unsigned char*>(buffer->data());
 
   PK11_EncryptDecryptFunction func =
-      (mode == ENCRYPT) ? g_aes_gcm_support.Get().pk11_encrypt_func() :
-                          g_aes_gcm_support.Get().pk11_decrypt_func();
+      (mode == ENCRYPT) ? g_aes_gcm_support.Get().pk11_encrypt_func()
+                        : g_aes_gcm_support.Get().pk11_decrypt_func();
 
   unsigned int output_len = 0;
-  SECStatus result = func(key->key(), CKM_AES_GCM, &param,
-                          buffer_data, &output_len, buffer->byteLength(),
-                          data.bytes(), data.byte_length());
+  SECStatus result = func(key->key(),
+                          CKM_AES_GCM,
+                          &param,
+                          buffer_data,
+                          &output_len,
+                          buffer->byteLength(),
+                          data.bytes(),
+                          data.byte_length());
 
   if (result != SECSuccess)
     return Status::Error();
 
   // Unfortunately the buffer needs to be shrunk for decryption (see the NSS bug
   // above).
   ShrinkBuffer(buffer, output_len);
 
   return Status::Success();
 }
@@ skipping 35 matching lines @@
 }
 
 bool IsAlgorithmRsa(const blink::WebCryptoAlgorithm& algorithm) {
   return algorithm.id() == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5;
 }
 
 }  // namespace
 
-Status ImportKeyRaw(
-    const blink::WebCryptoAlgorithm& algorithm,
-    const CryptoData& key_data,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    blink::WebCryptoKey* key) {
+Status ImportKeyRaw(const blink::WebCryptoAlgorithm& algorithm,
+                    const CryptoData& key_data,
+                    bool extractable,
+                    blink::WebCryptoKeyUsageMask usage_mask,
+                    blink::WebCryptoKey* key) {
 
   DCHECK(!algorithm.isNull());
 
   // TODO(bryaneyler): Need to split handling for symmetric and asymmetric keys.
   // Currently only supporting symmetric.
   CK_MECHANISM_TYPE mechanism = CKM_INVALID_MECHANISM;
   // Flags are verified at the Blink layer; here the flags are set to all
   // possible operations for this key type.
   CK_FLAGS flags = 0;
 
@@ skipping 51 matching lines @@
     return Status::Error();
 
   *key = blink::WebCryptoKey::create(new SymKey(pk11_sym_key.Pass()),
                                      blink::WebCryptoKeyTypeSecret,
                                      extractable,
                                      algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
-Status ExportKeyRaw(
-    SymKey* key,
-    blink::WebArrayBuffer* buffer) {
+Status ExportKeyRaw(SymKey* key, blink::WebArrayBuffer* buffer) {
   if (PK11_ExtractKeyValue(key->key()) != SECSuccess)
     return Status::Error();
 
   const SECItem* key_data = PK11_GetKeyData(key->key());
   if (!key_data)
     return Status::Error();
 
   *buffer = CreateArrayBuffer(key_data->data, key_data->len);
 
   return Status::Success();
@@ skipping 31 matching lines @@
       // TODO(padolph): Handle other key types.
       break;
     default:
       break;
   }
   return blink::WebCryptoAlgorithm::createNull();
 }
 
 }  // namespace
 
-Status ImportKeySpki(
-    const blink::WebCryptoAlgorithm& algorithm_or_null,
-    const CryptoData& key_data,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    blink::WebCryptoKey* key) {
+Status ImportKeySpki(const blink::WebCryptoAlgorithm& algorithm_or_null,
+                     const CryptoData& key_data,
+                     bool extractable,
+                     blink::WebCryptoKeyUsageMask usage_mask,
+                     blink::WebCryptoKey* key) {
 
   DCHECK(key);
 
   if (!key_data.byte_length())
     return Status::ErrorImportEmptyKeyData();
   DCHECK(key_data.bytes());
 
   // The binary blob 'key_data' is expected to be a DER-encoded ASN.1 Subject
   // Public Key Info. Decode this to a CERTSubjectPublicKeyInfo.
   SECItem spki_item = MakeSECItemForBuffer(key_data);
   const ScopedCERTSubjectPublicKeyInfo spki(
       SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_item));
   if (!spki)
     return Status::Error();
 
   crypto::ScopedSECKEYPublicKey sec_public_key(
       SECKEY_ExtractPublicKey(spki.get()));
   if (!sec_public_key)
     return Status::Error();
 
   const KeyType sec_key_type = SECKEY_GetPublicKeyType(sec_public_key.get());
   blink::WebCryptoAlgorithm algorithm =
       ResolveNssKeyTypeWithInputAlgorithm(sec_key_type, algorithm_or_null);
   if (algorithm.isNull())
     return Status::Error();
 
-  *key = blink::WebCryptoKey::create(
-      new PublicKey(sec_public_key.Pass()),
-      blink::WebCryptoKeyTypePublic,
-      extractable,
-      algorithm,
-      usage_mask);
+  *key = blink::WebCryptoKey::create(new PublicKey(sec_public_key.Pass()),
+                                     blink::WebCryptoKeyTypePublic,
+                                     extractable,
+                                     algorithm,
+                                     usage_mask);
 
   return Status::Success();
 }
 
-Status ExportKeySpki(
-    PublicKey* key,
-    blink::WebArrayBuffer* buffer) {
+Status ExportKeySpki(PublicKey* key, blink::WebArrayBuffer* buffer) {
   const crypto::ScopedSECItem spki_der(
       SECKEY_EncodeDERSubjectPublicKeyInfo(key->key()));
   if (!spki_der)
     return Status::Error();
 
   DCHECK(spki_der->data);
   DCHECK(spki_der->len);
 
   *buffer = CreateArrayBuffer(spki_der->data, spki_der->len);
 
   return Status::Success();
 }
 
-Status ImportKeyPkcs8(
-    const blink::WebCryptoAlgorithm& algorithm_or_null,
-    const CryptoData& key_data,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    blink::WebCryptoKey* key) {
+Status ImportKeyPkcs8(const blink::WebCryptoAlgorithm& algorithm_or_null,
+                      const CryptoData& key_data,
+                      bool extractable,
+                      blink::WebCryptoKeyUsageMask usage_mask,
+                      blink::WebCryptoKey* key) {
 
   DCHECK(key);
 
   if (!key_data.byte_length())
     return Status::ErrorImportEmptyKeyData();
   DCHECK(key_data.bytes());
 
   // The binary blob 'key_data' is expected to be a DER-encoded ASN.1 PKCS#8
   // private key info object.
   SECItem pki_der = MakeSECItemForBuffer(key_data);
 
   SECKEYPrivateKey* seckey_private_key = NULL;
   crypto::ScopedPK11Slot slot(PK11_GetInternalSlot());
-  if (PK11_ImportDERPrivateKeyInfoAndReturnKey(
-          slot.get(),
-          &pki_der,
-          NULL,  // nickname
-          NULL,  // publicValue
-          false,  // isPerm
-          false,  // isPrivate
-          KU_ALL,  // usage
-          &seckey_private_key,
-          NULL) != SECSuccess) {
+  if (PK11_ImportDERPrivateKeyInfoAndReturnKey(slot.get(),
+                                               &pki_der,
+                                               NULL,    // nickname
+                                               NULL,    // publicValue
+                                               false,   // isPerm
+                                               false,   // isPrivate
+                                               KU_ALL,  // usage
+                                               &seckey_private_key,
+                                               NULL) != SECSuccess) {
     return Status::Error();
   }
   DCHECK(seckey_private_key);
   crypto::ScopedSECKEYPrivateKey private_key(seckey_private_key);
 
   const KeyType sec_key_type = SECKEY_GetPrivateKeyType(private_key.get());
   blink::WebCryptoAlgorithm algorithm =
       ResolveNssKeyTypeWithInputAlgorithm(sec_key_type, algorithm_or_null);
   if (algorithm.isNull())
     return Status::Error();
 
-  *key = blink::WebCryptoKey::create(
-      new PrivateKey(private_key.Pass()),
-      blink::WebCryptoKeyTypePrivate,
-      extractable,
-      algorithm,
-      usage_mask);
+  *key = blink::WebCryptoKey::create(new PrivateKey(private_key.Pass()),
+                                     blink::WebCryptoKeyTypePrivate,
+                                     extractable,
+                                     algorithm,
+                                     usage_mask);
 
   return Status::Success();
 }
 
 // -----------------------------------
 // Hmac
 // -----------------------------------
 
-Status SignHmac(
-    SymKey* key,
-    const blink::WebCryptoAlgorithm& hash,
-    const CryptoData& data,
-    blink::WebArrayBuffer* buffer) {
+Status SignHmac(SymKey* key,
+                const blink::WebCryptoAlgorithm& hash,
+                const CryptoData& data,
+                blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(PK11_GetMechanism(key->key()), WebCryptoHashToHMACMechanism(hash));
 
-  SECItem param_item = { siBuffer, NULL, 0 };
+  SECItem param_item = {siBuffer, NULL, 0};
   SECItem data_item = MakeSECItemForBuffer(data);
   // First call is to figure out the length.
-  SECItem signature_item = { siBuffer, NULL, 0 };
+  SECItem signature_item = {siBuffer, NULL, 0};
 
   if (PK11_SignWithSymKey(key->key(),
                           PK11_GetMechanism(key->key()),
                           &param_item,
                           &signature_item,
                           &data_item) != SECSuccess) {
     return Status::Error();
   }
 
   DCHECK_NE(0u, signature_item.len);
@@ skipping 10 matching lines @@
   }
 
   DCHECK_EQ(buffer->byteLength(), signature_item.len);
   return Status::Success();
 }
 
 // -----------------------------------
 // RsaEsPkcs1v1_5
 // -----------------------------------
 
-Status EncryptRsaEsPkcs1v1_5(
-    PublicKey* key,
-    const CryptoData& data,
-    blink::WebArrayBuffer* buffer) {
+Status EncryptRsaEsPkcs1v1_5(PublicKey* key,
+                             const CryptoData& data,
+                             blink::WebArrayBuffer* buffer) {
   const unsigned int encrypted_length_bytes =
       SECKEY_PublicKeyStrength(key->key());
 
   // RSAES can operate on messages up to a length of k - 11, where k is the
   // octet length of the RSA modulus.
   if (encrypted_length_bytes < 11 ||
       encrypted_length_bytes - 11 < data.byte_length())
     return Status::ErrorDataTooLarge();
 
   *buffer = blink::WebArrayBuffer::create(encrypted_length_bytes, 1);
   unsigned char* const buffer_data =
       reinterpret_cast<unsigned char*>(buffer->data());
 
   if (PK11_PubEncryptPKCS1(key->key(),
                            buffer_data,
                            const_cast<unsigned char*>(data.bytes()),
                            data.byte_length(),
                            NULL) != SECSuccess) {
     return Status::Error();
   }
   return Status::Success();
 }
 
-Status DecryptRsaEsPkcs1v1_5(
-    PrivateKey* key,
-    const CryptoData& data,
-    blink::WebArrayBuffer* buffer) {
+Status DecryptRsaEsPkcs1v1_5(PrivateKey* key,
+                             const CryptoData& data,
+                             blink::WebArrayBuffer* buffer) {
   const int modulus_length_bytes = PK11_GetPrivateModulusLen(key->key());
   if (modulus_length_bytes <= 0)
     return Status::ErrorUnexpected();
   const unsigned int max_output_length_bytes = modulus_length_bytes;
 
   *buffer = blink::WebArrayBuffer::create(max_output_length_bytes, 1);
   unsigned char* const buffer_data =
       reinterpret_cast<unsigned char*>(buffer->data());
 
   unsigned int output_length_bytes = 0;
   if (PK11_PrivDecryptPKCS1(key->key(),
                             buffer_data,
                             &output_length_bytes,
                             max_output_length_bytes,
                             const_cast<unsigned char*>(data.bytes()),
                             data.byte_length()) != SECSuccess) {
     return Status::Error();
   }
   DCHECK_LE(output_length_bytes, max_output_length_bytes);
   ShrinkBuffer(buffer, output_length_bytes);
   return Status::Success();
 }
 
 // -----------------------------------
 // RsaSsaPkcs1v1_5
 // -----------------------------------
 
-Status SignRsaSsaPkcs1v1_5(
-    PrivateKey* key,
-    const blink::WebCryptoAlgorithm& hash,
-    const CryptoData& data,
-    blink::WebArrayBuffer* buffer) {
+Status SignRsaSsaPkcs1v1_5(PrivateKey* key,
+                           const blink::WebCryptoAlgorithm& hash,
+                           const CryptoData& data,
+                           blink::WebArrayBuffer* buffer) {
   // Pick the NSS signing algorithm by combining RSA-SSA (RSA PKCS1) and the
   // inner hash of the input Web Crypto algorithm.
   SECOidTag sign_alg_tag;
   switch (hash.id()) {
     case blink::WebCryptoAlgorithmIdSha1:
       sign_alg_tag = SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION;
       break;
     case blink::WebCryptoAlgorithmIdSha224:
       sign_alg_tag = SEC_OID_PKCS1_SHA224_WITH_RSA_ENCRYPTION;
       break;
@@ skipping 16 matching lines @@
                    data.byte_length(),
                    key->key(),
                    sign_alg_tag) != SECSuccess) {
     return Status::Error();
   }
 
   *buffer = CreateArrayBuffer(signature_item->data, signature_item->len);
   return Status::Success();
 }
 
-Status VerifyRsaSsaPkcs1v1_5(
-    PublicKey* key,
-    const blink::WebCryptoAlgorithm& hash,
-    const CryptoData& signature,
-    const CryptoData& data,
-    bool* signature_match) {
+Status VerifyRsaSsaPkcs1v1_5(PublicKey* key,
+                             const blink::WebCryptoAlgorithm& hash,
+                             const CryptoData& signature,
+                             const CryptoData& data,
+                             bool* signature_match) {
   const SECItem signature_item = MakeSECItemForBuffer(signature);
 
   SECOidTag hash_alg_tag;
   switch (hash.id()) {
     case blink::WebCryptoAlgorithmIdSha1:
       hash_alg_tag = SEC_OID_SHA1;
       break;
     case blink::WebCryptoAlgorithmIdSha224:
       hash_alg_tag = SEC_OID_SHA224;
       break;
@@ skipping 40 matching lines @@
                             blink::WebArrayBuffer* buffer) {
   // TODO(eroman): Inline.
   return AesGcmEncryptDecrypt(
       mode, key, data, iv, additional_data, tag_length_bits, buffer);
 }
 
 // -----------------------------------
 // Key generation
 // -----------------------------------
 
-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) {
   const blink::WebCryptoRsaKeyGenParams* const params =
       algorithm.rsaKeyGenParams();
   DCHECK(params);
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::Error();
 
   unsigned long public_exponent;
   if (!params->modulusLengthBits())
     return Status::ErrorGenerateRsaZeroModulus();
 
   if (!BigIntegerToLong(params->publicExponent().data(),
                         params->publicExponent().size(),
-                        &public_exponent) || !public_exponent) {
+                        &public_exponent) ||
+      !public_exponent) {
     return Status::ErrorGenerateKeyPublicExponent();
   }
 
   PK11RSAGenParams rsa_gen_params;
   rsa_gen_params.keySizeInBits = params->modulusLengthBits();
   rsa_gen_params.pe = public_exponent;
 
   // Flags are verified at the Blink layer; here the flags are set to all
   // possible operations for the given key type.
   CK_FLAGS operation_flags;
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
     case blink::WebCryptoAlgorithmIdRsaOaep:
       operation_flags = CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP;
       break;
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
       operation_flags = CKF_SIGN | CKF_VERIFY;
       break;
     default:
       NOTREACHED();
       return Status::ErrorUnexpected();
   }
-  const CK_FLAGS operation_flags_mask = CKF_ENCRYPT | CKF_DECRYPT |
-                                        CKF_SIGN | CKF_VERIFY | CKF_WRAP |
-                                        CKF_UNWRAP;
+  const CK_FLAGS operation_flags_mask =
+      CKF_ENCRYPT | CKF_DECRYPT | CKF_SIGN | CKF_VERIFY | CKF_WRAP | CKF_UNWRAP;
   const PK11AttrFlags attribute_flags = 0;  // Default all PK11_ATTR_ flags.
 
   // Note: NSS does not generate an sec_public_key if the call below fails,
   // so there is no danger of a leaked sec_public_key.
   SECKEYPublicKey* sec_public_key;
   crypto::ScopedSECKEYPrivateKey scoped_sec_private_key(
       PK11_GenerateKeyPairWithOpFlags(slot.get(),
                                       CKM_RSA_PKCS_KEY_PAIR_GEN,
                                       &rsa_gen_params,
                                       &sec_public_key,
                                       attribute_flags,
                                       operation_flags,
                                       operation_flags_mask,
                                       NULL));
   if (!private_key)
     return Status::Error();
 
   *public_key = blink::WebCryptoKey::create(
       new PublicKey(crypto::ScopedSECKEYPublicKey(sec_public_key)),
       blink::WebCryptoKeyTypePublic,
       true,
       algorithm,
       usage_mask);
-  *private_key = blink::WebCryptoKey::create(
-      new PrivateKey(scoped_sec_private_key.Pass()),
-      blink::WebCryptoKeyTypePrivate,
-      extractable,
-      algorithm,
-      usage_mask);
+  *private_key =
+      blink::WebCryptoKey::create(new PrivateKey(scoped_sec_private_key.Pass()),
+                                  blink::WebCryptoKeyTypePrivate,
+                                  extractable,
+                                  algorithm,
+                                  usage_mask);
 
   return Status::Success();
 }
 
-void Init() {
-  crypto::EnsureNSSInit();
-}
+void Init() { crypto::EnsureNSSInit(); }
 
-Status DigestSha(
-    blink::WebCryptoAlgorithmId algorithm,
-    const CryptoData& data,
-    blink::WebArrayBuffer* buffer) {
+Status DigestSha(blink::WebCryptoAlgorithmId algorithm,
+                 const CryptoData& data,
+                 blink::WebArrayBuffer* buffer) {
   HASH_HashType hash_type = WebCryptoAlgorithmToNSSHashType(algorithm);
   if (hash_type == HASH_AlgNULL)
     return Status::ErrorUnsupported();
 
   HASHContext* context = HASH_Create(hash_type);
   if (!context)
     return Status::Error();
 
   HASH_Begin(context);
 
   HASH_Update(context, data.bytes(), data.byte_length());
 
   unsigned int hash_result_length = HASH_ResultLenContext(context);
   DCHECK_LE(hash_result_length, static_cast<size_t>(HASH_LENGTH_MAX));
 
   *buffer = blink::WebArrayBuffer::create(hash_result_length, 1);
 
   unsigned char* digest = reinterpret_cast<unsigned char*>(buffer->data());
 
   unsigned int result_length = 0;
   HASH_End(context, digest, &result_length, hash_result_length);
 
   HASH_Destroy(context);
 
   if (result_length != hash_result_length)
     return Status::ErrorUnexpected();
   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) {
   CK_MECHANISM_TYPE mech = WebCryptoAlgorithmToGenMechanism(algorithm);
   blink::WebCryptoKeyType key_type = blink::WebCryptoKeyTypeSecret;
 
   if (mech == CKM_INVALID_MECHANISM)
     return Status::ErrorUnsupported();
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::Error();
 
   crypto::ScopedPK11SymKey pk11_key(
       PK11_KeyGen(slot.get(), mech, NULL, keylen_bytes, NULL));
 
   if (!pk11_key)
     return Status::Error();
 
   *key = blink::WebCryptoKey::create(new SymKey(pk11_key.Pass()),
                                      key_type,
                                      extractable,
                                      algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
-Status ImportRsaPublicKey(
-    const blink::WebCryptoAlgorithm& algorithm,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    const CryptoData& modulus_data,
-    const CryptoData& exponent_data,
-    blink::WebCryptoKey* key) {
+Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
+                          bool extractable,
+                          blink::WebCryptoKeyUsageMask usage_mask,
+                          const CryptoData& modulus_data,
+                          const CryptoData& exponent_data,
+                          blink::WebCryptoKey* key) {
 
   if (!modulus_data.byte_length())
     return Status::ErrorImportRsaEmptyModulus();
 
   if (!exponent_data.byte_length())
     return Status::ErrorImportRsaEmptyExponent();
 
   DCHECK(modulus_data.bytes());
   DCHECK(exponent_data.bytes());
 
@@ skipping 38 matching lines @@
                                      algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content