Clang format slam.

net/cert/cert_verify_proc_android.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_android.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 
 // Returns true if the certificate verification call was successful (regardless
 // of its result), i.e. if |verify_result| was set. Otherwise returns false.
 bool VerifyFromAndroidTrustManager(const std::vector<std::string>& cert_bytes,
                                    const std::string& hostname,
                                    CertVerifyResult* verify_result) {
   android::CertVerifyStatusAndroid status;
   std::vector<std::string> verified_chain;
 
   // TODO(joth): Fetch the authentication type from SSL rather than hardcode.
-  android::VerifyX509CertChain(cert_bytes, "RSA", hostname,
-                               &status, &verify_result->is_issued_by_known_root,
+  android::VerifyX509CertChain(cert_bytes,
+                               "RSA",
+                               hostname,
+                               &status,
+                               &verify_result->is_issued_by_known_root,
                                &verified_chain);
   switch (status) {
     case android::VERIFY_FAILED:
       return false;
     case android::VERIFY_OK:
       break;
     case android::VERIFY_NO_TRUSTED_ROOT:
       verify_result->cert_status |= CERT_STATUS_AUTHORITY_INVALID;
       break;
     case android::VERIFY_EXPIRED:
@@ skipping 25 matching lines @@
   }
 
   // Extract the public key hashes.
   for (size_t i = 0; i < verified_chain.size(); i++) {
     base::StringPiece spki_bytes;
     if (!asn1::ExtractSPKIFromDERCert(verified_chain[i], &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());
     verify_result->public_key_hashes.push_back(sha1);
 
     HashValue sha256(HASH_VALUE_SHA256);
     crypto::SHA256HashString(spki_bytes, sha256.data(), crypto::kSHA256Length);
     verify_result->public_key_hashes.push_back(sha256);
   }
 
   return true;
 }
 
 bool GetChainDEREncodedBytes(X509Certificate* cert,
                              std::vector<std::string>* chain_bytes) {
   X509Certificate::OSCertHandle cert_handle = cert->os_cert_handle();
   X509Certificate::OSCertHandles cert_handles =
       cert->GetIntermediateCertificates();
 
   // Make sure the peer's own cert is the first in the chain, if it's not
   // already there.
   if (cert_handles.empty() || cert_handles[0] != cert_handle)
     cert_handles.insert(cert_handles.begin(), cert_handle);
 
   chain_bytes->reserve(cert_handles.size());
-  for (X509Certificate::OSCertHandles::const_iterator it =
-       cert_handles.begin(); it != cert_handles.end(); ++it) {
+  for (X509Certificate::OSCertHandles::const_iterator it = cert_handles.begin();
+       it != cert_handles.end();
+       ++it) {
     std::string cert_bytes;
-    if(!X509Certificate::GetDEREncoded(*it, &cert_bytes))
+    if (!X509Certificate::GetDEREncoded(*it, &cert_bytes))
       return false;
     chain_bytes->push_back(cert_bytes);
   }
   return true;
 }
 
 }  // namespace
 
-CertVerifyProcAndroid::CertVerifyProcAndroid() {}
+CertVerifyProcAndroid::CertVerifyProcAndroid() {
+}
 
-CertVerifyProcAndroid::~CertVerifyProcAndroid() {}
+CertVerifyProcAndroid::~CertVerifyProcAndroid() {
+}
 
 bool CertVerifyProcAndroid::SupportsAdditionalTrustAnchors() const {
   return false;
 }
 
 int CertVerifyProcAndroid::VerifyInternal(
     X509Certificate* cert,
     const std::string& hostname,
     int flags,
     CRLSet* crl_set,
@@ skipping 11 matching lines @@
     NOTREACHED();
     return ERR_FAILED;
   }
   if (IsCertStatusError(verify_result->cert_status))
     return MapCertStatusToNetError(verify_result->cert_status);
 
   return OK;
 }
 
 }  // namespace net