[style] Remove braces from single-line if statements for style consistency.

content/renderer/webcrypto/webcrypto_impl_nss.cc

 // Copyright 2013 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/webcrypto_impl.h"
 
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
@@ skipping 282 matching lines @@
   SymKeyHandle* sym_key = reinterpret_cast<SymKeyHandle*>(key.handle());
 
   const blink::WebCryptoAesGcmParams* params = algorithm.aesGcmParams();
   if (!params)
     return Status::ErrorUnexpected();
 
   // TODO(eroman): The spec doesn't define the default value. Assume 128 for now
   // since that is the maximum tag length:
   // http://www.w3.org/2012/webcrypto/track/issues/46
   unsigned tag_length_bits = 128;
-  if (params->hasTagLengthBits()) {
+  if (params->hasTagLengthBits())
     tag_length_bits = params->optionalTagLengthBits();
-  }
 
-  if (tag_length_bits > 128 || (tag_length_bits % 8) != 0) {
+  if (tag_length_bits > 128 || (tag_length_bits % 8) != 0)
     return Status::ErrorInvalidAesGcmTagLength();
-  }
+
   unsigned tag_length_bytes = tag_length_bits / 8;
 
   CK_GCM_PARAMS gcm_params = {0};
   gcm_params.pIv =
       const_cast<unsigned char*>(algorithm.aesGcmParams()->iv().data());
   gcm_params.ulIvLen = algorithm.aesGcmParams()->iv().size();
 
   gcm_params.pAAD =
       const_cast<unsigned char*>(params->optionalAdditionalData().data());
   gcm_params.ulAADLen = params->optionalAdditionalData().size();
@@ skipping 118 matching lines @@
   // 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;
 
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac: {
       const blink::WebCryptoHmacParams* params = algorithm.hmacParams();
-      if (!params) {
+      if (!params)
         return Status::ErrorUnexpected();
-      }
 
       mechanism = WebCryptoHashToHMACMechanism(params->hash());
-      if (mechanism == CKM_INVALID_MECHANISM) {
+      if (mechanism == CKM_INVALID_MECHANISM)
         return Status::ErrorUnsupported();
-      }
 
       flags |= CKF_SIGN | CKF_VERIFY;
 
       break;
     }
     case blink::WebCryptoAlgorithmIdAesCbc: {
       mechanism = CKM_AES_CBC;
       flags |= CKF_ENCRYPT | CKF_DECRYPT;
       break;
     }
@@ skipping 25 matching lines @@
   crypto::ScopedPK11Slot slot(PK11_GetInternalSlot());
   crypto::ScopedPK11SymKey pk11_sym_key(
       PK11_ImportSymKeyWithFlags(slot.get(),
                                  mechanism,
                                  PK11_OriginUnwrap,
                                  CKA_FLAGS_ONLY,
                                  &key_item,
                                  flags,
                                  false,
                                  NULL));
-  if (!pk11_sym_key.get()) {
+  if (!pk11_sym_key.get())
     return Status::Error();
-  }
 
   *key = blink::WebCryptoKey::create(new SymKeyHandle(pk11_sym_key.Pass()),
                                       type, extractable, algorithm, usage_mask);
   return Status::Success();
 }
 
 Status ExportKeyInternalRaw(
     const blink::WebCryptoKey& key,
     blink::WebArrayBuffer* buffer) {
 
@@ skipping 182 matching lines @@
 
 Status SignHmac(
     const blink::WebCryptoAlgorithm& algorithm,
     const blink::WebCryptoKey& key,
     const unsigned char* data,
     unsigned data_size,
     blink::WebArrayBuffer* buffer) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdHmac, algorithm.id());
 
   const blink::WebCryptoHmacParams* params = algorithm.hmacParams();
-  if (!params) {
+  if (!params)
     return Status::ErrorUnexpected();
-  }
 
   SymKeyHandle* sym_key = reinterpret_cast<SymKeyHandle*>(key.handle());
 
   DCHECK_EQ(PK11_GetMechanism(sym_key->key()),
             WebCryptoHashToHMACMechanism(params->hash()));
 
   SECItem param_item = { siBuffer, NULL, 0 };
   SECItem data_item = {
     siBuffer,
     const_cast<unsigned char*>(data),
@@ skipping 32 matching lines @@
     const blink::WebCryptoKey& key,
     const unsigned char* signature,
     unsigned signature_size,
     const unsigned char* data,
     unsigned data_size,
     bool* signature_match) {
   DCHECK_EQ(blink::WebCryptoAlgorithmIdHmac, algorithm.id());
 
   blink::WebArrayBuffer result;
   Status status = SignHmac(algorithm, key, data, data_size, &result);
-  if (status.IsError()) {
+  if (status.IsError())
     return status;
-  }
 
   // Handling of truncated signatures is underspecified in the WebCrypto
   // spec, so here we fail verification if a truncated signature is being
   // verified.
   // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=23097
   *signature_match =
     result.byteLength() == signature_size &&
     crypto::SecureMemEqual(result.data(), signature, signature_size);
 
   return Status::Success();
@@ skipping 261 matching lines @@
   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) {
+  if (!private_key)
     return Status::Error();
-  }
 
   *public_key = blink::WebCryptoKey::create(
       new PublicKeyHandle(crypto::ScopedSECKEYPublicKey(sec_public_key)),
       blink::WebCryptoKeyTypePublic,
       true,
       algorithm,
       usage_mask);
   *private_key = blink::WebCryptoKey::create(
       new PrivateKeyHandle(scoped_sec_private_key.Pass()),
       blink::WebCryptoKeyTypePrivate,
@@ skipping 20 matching lines @@
       // Ensure the key length is a multiple of 8 bits. Let NSS verify further
       // algorithm-specific length restrictions.
       if (params->lengthBits() % 8)
         return Status::ErrorGenerateKeyLength();
       *keylen_bytes = params->lengthBits() / 8;
       break;
     }
     case blink::WebCryptoAlgorithmIdHmac: {
       const blink::WebCryptoHmacKeyParams* params = algorithm.hmacKeyParams();
       DCHECK(params);
-      if (params->hasLengthBytes()) {
+      if (params->hasLengthBytes())
         *keylen_bytes = params->optionalLengthBytes();
-      } else {
+      else
         *keylen_bytes = webcrypto::ShaBlockSizeBytes(params->hash().id());
-      }
       break;
     }
 
     default:
       return Status::ErrorUnsupported();
   }
 
-  if (*keylen_bytes == 0) {
+  if (*keylen_bytes == 0)
     return Status::ErrorGenerateKeyLength();
-  }
 
   return Status::Success();
 }
 
 }  // namespace
 
 void WebCryptoImpl::Init() {
   crypto::EnsureNSSInit();
 }
 
@@ skipping 46 matching lines @@
       return Status::ErrorUnsupported();
   }
 }
 
 Status WebCryptoImpl::DigestInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     const unsigned char* data,
     unsigned data_size,
     blink::WebArrayBuffer* buffer) {
   HASH_HashType hash_type = WebCryptoAlgorithmToNSSHashType(algorithm);
-  if (hash_type == HASH_AlgNULL) {
+  if (hash_type == HASH_AlgNULL)
     return Status::ErrorUnsupported();
-  }
 
   HASHContext* context = HASH_Create(hash_type);
-  if (!context) {
+  if (!context)
     return Status::Error();
-  }
 
   HASH_Begin(context);
 
   HASH_Update(context, data, data_size);
 
   unsigned 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 result_length = 0;
   HASH_End(context, digest, &result_length, hash_result_length);
 
   HASH_Destroy(context);
 
-  if (result_length != hash_result_length) {
+  if (result_length != hash_result_length)
     return Status::ErrorUnexpected();
-  }
   return Status::Success();
 }
 
 Status WebCryptoImpl::GenerateSecretKeyInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoKey* key) {
 
   CK_MECHANISM_TYPE mech = WebCryptoAlgorithmToGenMechanism(algorithm);
   blink::WebCryptoKeyType key_type = blink::WebCryptoKeyTypeSecret;
 
-  if (mech == CKM_INVALID_MECHANISM) {
+  if (mech == CKM_INVALID_MECHANISM)
     return Status::ErrorUnsupported();
-  }
 
   unsigned int keylen_bytes = 0;
   Status status = GetGenerateSecretKeyLength(algorithm, &keylen_bytes);
   if (status.IsError())
     return status;
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
-  if (!slot) {
+  if (!slot)
     return Status::Error();
-  }
 
   crypto::ScopedPK11SymKey pk11_key(
       PK11_KeyGen(slot.get(), mech, NULL, keylen_bytes, NULL));
 
-  if (!pk11_key) {
+  if (!pk11_key)
     return Status::Error();
-  }
 
   *key = blink::WebCryptoKey::create(
       new SymKeyHandle(pk11_key.Pass()),
       key_type, extractable, algorithm, usage_mask);
   return Status::Success();
 }
 
 Status WebCryptoImpl::GenerateKeyPairInternal(
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
@@ skipping 179 matching lines @@
 
   *key = blink::WebCryptoKey::create(new PublicKeyHandle(pubkey.Pass()),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace content