Clang format slam.

net/cert/cert_verify_proc_openssl.cc

 // Copyright (c) 2012 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/cert/cert_verify_proc_openssl.h"
 
 #include <openssl/x509v3.h>
 
 #include <string>
 #include <vector>
@@ skipping 73 matching lines @@
     case X509_V_ERR_APPLICATION_VERIFICATION:
       return CERT_STATUS_INVALID;
     default:
       NOTREACHED() << "Invalid X509 err " << err;
       return CERT_STATUS_INVALID;
   }
 }
 
 // sk_X509_free is a function-style macro, so can't be used as a template
 // param directly.
-void sk_X509_free_fn(STACK_OF(X509)* st) {
+void sk_X509_free_fn(STACK_OF(X509) * st) {
   sk_X509_free(st);
 }
 
 void GetCertChainInfo(X509_STORE_CTX* store_ctx,
                       CertVerifyResult* verify_result) {
   STACK_OF(X509)* chain = X509_STORE_CTX_get_chain(store_ctx);
   X509* verified_cert = NULL;
   std::vector<X509*> verified_chain;
   for (int i = 0; i < sk_X509_num(chain); ++i) {
     X509* cert = sk_X509_value(chain, i);
@@ skipping 30 matching lines @@
     verify_result->is_issued_by_known_root = true;
     if (TestRootCerts::HasInstance()) {
       X509* root = NULL;
       if (verified_chain.empty()) {
         root = verified_cert;
       } else {
         root = verified_chain.back();
       }
       TestRootCerts* root_certs = TestRootCerts::GetInstance();
       if (root_certs->Contains(root))
-          verify_result->is_issued_by_known_root = false;
+        verify_result->is_issued_by_known_root = false;
     }
   }
 }
 
-void AppendPublicKeyHashes(X509_STORE_CTX* store_ctx,
-                           HashValueVector* hashes) {
+void AppendPublicKeyHashes(X509_STORE_CTX* store_ctx, HashValueVector* hashes) {
   STACK_OF(X509)* chain = X509_STORE_CTX_get_chain(store_ctx);
   for (int i = 0; i < sk_X509_num(chain); ++i) {
     X509* cert = sk_X509_value(chain, i);
 
     std::string der_data;
     if (!X509Certificate::GetDEREncoded(cert, &der_data))
       continue;
 
     base::StringPiece der_bytes(der_data);
     base::StringPiece spki_bytes;
     if (!asn1::ExtractSPKIFromDERCert(der_bytes, &spki_bytes))
       continue;
 
     HashValue sha1(HASH_VALUE_SHA1);
     base::SHA1HashBytes(reinterpret_cast<const uint8*>(spki_bytes.data()),
-                        spki_bytes.size(), sha1.data());
+                        spki_bytes.size(),
+                        sha1.data());
     hashes->push_back(sha1);
 
     HashValue sha256(HASH_VALUE_SHA256);
     crypto::SHA256HashString(spki_bytes, sha256.data(), crypto::kSHA256Length);
     hashes->push_back(sha256);
   }
 }
 
 }  // namespace
 
-CertVerifyProcOpenSSL::CertVerifyProcOpenSSL() {}
+CertVerifyProcOpenSSL::CertVerifyProcOpenSSL() {
+}
 
-CertVerifyProcOpenSSL::~CertVerifyProcOpenSSL() {}
+CertVerifyProcOpenSSL::~CertVerifyProcOpenSSL() {
+}
 
 bool CertVerifyProcOpenSSL::SupportsAdditionalTrustAnchors() const {
   return false;
 }
 
 int CertVerifyProcOpenSSL::VerifyInternal(
     X509Certificate* cert,
     const std::string& hostname,
     int flags,
     CRLSet* crl_set,
@@ skipping 10 matching lines @@
       X509_STORE_CTX_new());
 
   crypto::ScopedOpenSSL<STACK_OF(X509), sk_X509_free_fn> intermediates(
       sk_X509_new_null());
   if (!intermediates.get())
     return ERR_OUT_OF_MEMORY;
 
   const X509Certificate::OSCertHandles& os_intermediates =
       cert->GetIntermediateCertificates();
   for (X509Certificate::OSCertHandles::const_iterator it =
-       os_intermediates.begin(); it != os_intermediates.end(); ++it) {
+           os_intermediates.begin();
+       it != os_intermediates.end();
+       ++it) {
     if (!sk_X509_push(intermediates.get(), *it))
       return ERR_OUT_OF_MEMORY;
   }
-  if (X509_STORE_CTX_init(ctx.get(), X509Certificate::cert_store(),
-                          cert->os_cert_handle(), intermediates.get()) != 1) {
+  if (X509_STORE_CTX_init(ctx.get(),
+                          X509Certificate::cert_store(),
+                          cert->os_cert_handle(),
+                          intermediates.get()) != 1) {
     NOTREACHED();
     return ERR_FAILED;
   }
 
   if (X509_verify_cert(ctx.get()) != 1) {
     int x509_error = X509_STORE_CTX_get_error(ctx.get());
     CertStatus cert_status = MapCertErrorToCertStatus(x509_error);
     LOG(ERROR) << "X509 Verification error "
-        << X509_verify_cert_error_string(x509_error)
-        << " : " << x509_error
-        << " : " << X509_STORE_CTX_get_error_depth(ctx.get())
-        << " : " << cert_status;
+               << X509_verify_cert_error_string(x509_error) << " : "
+               << x509_error << " : "
+               << X509_STORE_CTX_get_error_depth(ctx.get()) << " : "
+               << cert_status;
     verify_result->cert_status |= cert_status;
   }
 
   GetCertChainInfo(ctx.get(), verify_result);
   AppendPublicKeyHashes(ctx.get(), &verify_result->public_key_hashes);
   if (IsCertStatusError(verify_result->cert_status))
     return MapCertStatusToNetError(verify_result->cert_status);
 
   return OK;
 }
 
 }  // namespace net