Clang format slam.

net/quic/test_tools/crypto_test_utils_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 "net/quic/test_tools/crypto_test_utils.h"
 
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
 #include <openssl/obj_mac.h>
 #include <openssl/sha.h>
 
 #include "crypto/openssl_util.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/channel_id.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace {
 
 void EvpMdCtxCleanUp(EVP_MD_CTX* ctx) {
   (void)EVP_MD_CTX_cleanup(ctx);
 }
 
-} // namespace anonymous
+}  // namespace anonymous
 
 namespace net {
 
 namespace test {
 
 class TestChannelIDSigner : public ChannelIDSigner {
  public:
-  virtual ~TestChannelIDSigner() { }
+  virtual ~TestChannelIDSigner() {}
 
   // ChannelIDSigner implementation.
 
   virtual bool Sign(const string& hostname,
                     StringPiece signed_data,
                     string* out_key,
                     string* out_signature) OVERRIDE {
     crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> ecdsa_key(
         HostnameToKey(hostname));
 
     *out_key = SerializeKey(ecdsa_key.get());
     if (out_key->empty()) {
       return false;
     }
 
     EVP_MD_CTX md_ctx;
     EVP_MD_CTX_init(&md_ctx);
-    crypto::ScopedOpenSSL<EVP_MD_CTX, EvpMdCtxCleanUp>
-        md_ctx_cleanup(&md_ctx);
+    crypto::ScopedOpenSSL<EVP_MD_CTX, EvpMdCtxCleanUp> md_ctx_cleanup(&md_ctx);
 
-    if (EVP_DigestSignInit(&md_ctx, NULL, EVP_sha256(), NULL,
-                           ecdsa_key.get()) != 1) {
+    if (EVP_DigestSignInit(
+            &md_ctx, NULL, EVP_sha256(), NULL, ecdsa_key.get()) != 1) {
       return false;
     }
 
-    EVP_DigestUpdate(&md_ctx, ChannelIDVerifier::kContextStr,
+    EVP_DigestUpdate(&md_ctx,
+                     ChannelIDVerifier::kContextStr,
                      strlen(ChannelIDVerifier::kContextStr) + 1);
-    EVP_DigestUpdate(&md_ctx, ChannelIDVerifier::kClientToServerStr,
+    EVP_DigestUpdate(&md_ctx,
+                     ChannelIDVerifier::kClientToServerStr,
                      strlen(ChannelIDVerifier::kClientToServerStr) + 1);
     EVP_DigestUpdate(&md_ctx, signed_data.data(), signed_data.size());
 
     size_t sig_len;
     if (!EVP_DigestSignFinal(&md_ctx, NULL, &sig_len)) {
       return false;
     }
 
     scoped_ptr<uint8[]> der_sig(new uint8[sig_len]);
     if (!EVP_DigestSignFinal(&md_ctx, der_sig.get(), &sig_len)) {
       return false;
     }
 
     uint8* derp = der_sig.get();
     crypto::ScopedOpenSSL<ECDSA_SIG, ECDSA_SIG_free> sig(
         d2i_ECDSA_SIG(NULL, const_cast<const uint8**>(&derp), sig_len));
     if (sig.get() == NULL) {
       return false;
     }
 
     // The signature consists of a pair of 32-byte numbers.
     static const size_t kSignatureLength = 32 * 2;
     scoped_ptr<uint8[]> signature(new uint8[kSignatureLength]);
     memset(signature.get(), 0, kSignatureLength);
     BN_bn2bin(sig.get()->r, signature.get() + 32 - BN_num_bytes(sig.get()->r));
     BN_bn2bin(sig.get()->s, signature.get() + 64 - BN_num_bytes(sig.get()->s));
 
-    *out_signature = string(reinterpret_cast<char*>(signature.get()),
-                            kSignatureLength);
+    *out_signature =
+        string(reinterpret_cast<char*>(signature.get()), kSignatureLength);
 
     return true;
   }
 
   virtual string GetKeyForHostname(const string& hostname) OVERRIDE {
     crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> ecdsa_key(
         HostnameToKey(hostname));
     return SerializeKey(ecdsa_key.get());
   }
 
@@ skipping 61 matching lines @@
 };
 
 // static
 ChannelIDSigner* CryptoTestUtils::ChannelIDSignerForTesting() {
   return new TestChannelIDSigner();
 }
 
 }  // namespace test
 
 }  // namespace net