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

content/renderer/webcrypto/webcrypto_impl_openssl.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 <vector>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
@@ skipping 103 matching lines @@
 
   unsigned char* const buffer_data =
       reinterpret_cast<unsigned char*>(buffer->data());
 
   int output_len = 0;
   if (!EVP_CipherUpdate(
           context.get(), buffer_data, &output_len, data, data_size))
     return Status::Error();
   int final_output_chunk_len = 0;
   if (!EVP_CipherFinal_ex(
-          context.get(), buffer_data + output_len, &final_output_chunk_len))
+          context.get(), buffer_data + output_len, &final_output_chunk_len)) {
     return Status::Error();
+  }
 
   const unsigned final_output_len =
       static_cast<unsigned>(output_len) +
       static_cast<unsigned>(final_output_chunk_len);
   DCHECK_LE(final_output_len, output_max_len);
 
   webcrypto::ShrinkBuffer(buffer, final_output_len);
 
   return Status::Success();
 }
@@ skipping 76 matching lines @@
     case blink::WebCryptoAlgorithmIdSha512:
       digest_algorithm = EVP_sha512();
       break;
     default:
       // Not a digest algorithm.
       return Status::ErrorUnsupported();
   }
 
   crypto::ScopedOpenSSL<EVP_MD_CTX, EVP_MD_CTX_destroy> digest_context(
       EVP_MD_CTX_create());
-  if (!digest_context.get()) {
+  if (!digest_context.get())
     return Status::Error();
-  }
 
   if (!EVP_DigestInit_ex(digest_context.get(), digest_algorithm, NULL) ||
       !EVP_DigestUpdate(digest_context.get(), data, data_size)) {
     return Status::Error();
   }
 
   const int hash_expected_size = EVP_MD_CTX_size(digest_context.get());
   if (hash_expected_size <= 0) {
     return Status::ErrorUnexpected();
   }
@@ skipping 22 matching lines @@
   unsigned keylen_bytes = 0;
   blink::WebCryptoKeyType key_type;
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc: {
       const blink::WebCryptoAesKeyGenParams* params =
           algorithm.aesKeyGenParams();
       DCHECK(params);
       if (params->lengthBits() % 8)
         return Status::ErrorGenerateKeyLength();
       keylen_bytes = params->lengthBits() / 8;
-      if (!GetAESCipherByKeyLength(keylen_bytes)) {
+      if (!GetAESCipherByKeyLength(keylen_bytes))
         return Status::Error();
-      }
       key_type = blink::WebCryptoKeyTypeSecret;
       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());
-      }
       key_type = blink::WebCryptoKeyTypeSecret;
       break;
     }
 
     default: { return Status::ErrorUnsupported(); }
   }
 
-  if (keylen_bytes == 0) {
+  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))) {
+  if (!(RAND_bytes(&random_bytes[0], keylen_bytes)))
     return Status::Error();
-  }
 
   *key = blink::WebCryptoKey::create(
       new SymKeyHandle(&random_bytes[0], random_bytes.size()),
       key_type, extractable, algorithm, usage_mask);
 
   return Status::Success();
 }
 
 Status WebCryptoImpl::GenerateKeyPairInternal(
     const blink::WebCryptoAlgorithm& algorithm,
@@ skipping 171 matching lines @@
     const blink::WebCryptoKey& key,
     const unsigned char* signature,
     unsigned signature_size,
     const unsigned char* data,
     unsigned data_size,
     bool* signature_match) {
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac: {
       blink::WebArrayBuffer result;
       Status status = SignInternal(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);
 
       break;
@@ skipping 12 matching lines @@
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoKey* key) {
   // TODO(padolph): Placeholder for OpenSSL implementation.
   // Issue http://crbug.com/267888.
   return Status::ErrorUnsupported();
 }
 
 }  // namespace content