[style] Run webcrypto files through clang-format.

content/renderer/webcrypto/webcrypto_impl.cc

 // Copyright (c) 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 "base/logging.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/shared_crypto.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
@@ skipping 14 matching lines @@
 }
 
 bool IsAlgorithmAsymmetric(const blink::WebCryptoAlgorithm& algorithm) {
   // TODO(padolph): include all other asymmetric algorithms once they are
   // defined, e.g. EC and DH.
   return (algorithm.id() == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
           algorithm.id() == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
           algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep);
 }
 
-
 }  // namespace
 
-WebCryptoImpl::WebCryptoImpl() {
-  webcrypto::Init();
-}
+WebCryptoImpl::WebCryptoImpl() { webcrypto::Init(); }
 
 WebCryptoImpl::~WebCryptoImpl() {}
 
-void WebCryptoImpl::encrypt(
-    const blink::WebCryptoAlgorithm& algorithm,
-    const blink::WebCryptoKey& key,
-    const unsigned char* data,
-    unsigned int data_size,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::encrypt(const blink::WebCryptoAlgorithm& algorithm,
+                            const blink::WebCryptoKey& key,
+                            const unsigned char* data,
+                            unsigned int data_size,
+                            blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = webcrypto::Encrypt(
       algorithm, key, webcrypto::CryptoData(data, data_size), &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
-void WebCryptoImpl::decrypt(
-    const blink::WebCryptoAlgorithm& algorithm,
-    const blink::WebCryptoKey& key,
-    const unsigned char* data,
-    unsigned int data_size,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::decrypt(const blink::WebCryptoAlgorithm& algorithm,
+                            const blink::WebCryptoKey& key,
+                            const unsigned char* data,
+                            unsigned int data_size,
+                            blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = webcrypto::Decrypt(
       algorithm, key, webcrypto::CryptoData(data, data_size), &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
-void WebCryptoImpl::digest(
-    const blink::WebCryptoAlgorithm& algorithm,
-    const unsigned char* data,
-    unsigned int data_size,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::digest(const blink::WebCryptoAlgorithm& algorithm,
+                           const unsigned char* data,
+                           unsigned int data_size,
+                           blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = webcrypto::Digest(
       algorithm, webcrypto::CryptoData(data, data_size), &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
-void WebCryptoImpl::generateKey(
-    const blink::WebCryptoAlgorithm& algorithm,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask usage_mask,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::generateKey(const blink::WebCryptoAlgorithm& algorithm,
+                                bool extractable,
+                                blink::WebCryptoKeyUsageMask usage_mask,
+                                blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   if (IsAlgorithmAsymmetric(algorithm)) {
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
     Status status = webcrypto::GenerateKeyPair(
         algorithm, extractable, usage_mask, &public_key, &private_key);
     if (status.IsError()) {
       CompleteWithError(status, &result);
     } else {
       DCHECK(public_key.handle());
@@ skipping 41 matching lines @@
   if (status.IsError()) {
     CompleteWithError(status, &result);
   } else {
     DCHECK(key.handle());
     DCHECK(!key.algorithm().isNull());
     DCHECK_EQ(extractable, key.extractable());
     result.completeWithKey(key);
   }
 }
 
-void WebCryptoImpl::exportKey(
-    blink::WebCryptoKeyFormat format,
-    const blink::WebCryptoKey& key,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::exportKey(blink::WebCryptoKeyFormat format,
+                              const blink::WebCryptoKey& key,
+                              blink::WebCryptoResult result) {
   blink::WebArrayBuffer buffer;
   Status status = webcrypto::ExportKey(format, key, &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
-void WebCryptoImpl::sign(
-    const blink::WebCryptoAlgorithm& algorithm,
-    const blink::WebCryptoKey& key,
-    const unsigned char* data,
-    unsigned int data_size,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::sign(const blink::WebCryptoAlgorithm& algorithm,
+                         const blink::WebCryptoKey& key,
+                         const unsigned char* data,
+                         unsigned int data_size,
+                         blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   blink::WebArrayBuffer buffer;
   Status status = webcrypto::Sign(
       algorithm, key, webcrypto::CryptoData(data, data_size), &buffer);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBuffer(buffer);
 }
 
-void WebCryptoImpl::verifySignature(
-    const blink::WebCryptoAlgorithm& algorithm,
-    const blink::WebCryptoKey& key,
-    const unsigned char* signature,
-    unsigned int signature_size,
-    const unsigned char* data,
-    unsigned int data_size,
-    blink::WebCryptoResult result) {
+void WebCryptoImpl::verifySignature(const blink::WebCryptoAlgorithm& algorithm,
+                                    const blink::WebCryptoKey& key,
+                                    const unsigned char* signature,
+                                    unsigned int signature_size,
+                                    const unsigned char* data,
+                                    unsigned int data_size,
+                                    blink::WebCryptoResult result) {
   DCHECK(!algorithm.isNull());
   bool signature_match = false;
   Status status = webcrypto::VerifySignature(
       algorithm,
       key,
       webcrypto::CryptoData(signature, signature_size),
       webcrypto::CryptoData(data, data_size),
       &signature_match);
   if (status.IsError())
     CompleteWithError(status, &result);
   else
     result.completeWithBoolean(signature_match);
 }
 
 }  // namespace content