Clang format slam.

net/quic/crypto/proof_verifier_chromium.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/crypto/proof_verifier_chromium.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 190 matching lines @@
     callback->Run(rv == OK, error_details_, &verify_details);
     // Will delete |this|.
     proof_verifier_->OnJobComplete(this);
   }
 }
 
 int ProofVerifierChromium::Job::DoVerifyCert(int result) {
   next_state_ = STATE_VERIFY_CERT_COMPLETE;
 
   int flags = 0;
-  return verifier_->Verify(
-      cert_.get(),
-      hostname_,
-      flags,
-      SSLConfigService::GetCRLSet().get(),
-      &verify_details_->cert_verify_result,
-      base::Bind(&ProofVerifierChromium::Job::OnIOComplete,
-                 base::Unretained(this)),
-      net_log_);
+  return verifier_->Verify(cert_.get(),
+                           hostname_,
+                           flags,
+                           SSLConfigService::GetCRLSet().get(),
+                           &verify_details_->cert_verify_result,
+                           base::Bind(&ProofVerifierChromium::Job::OnIOComplete,
+                                      base::Unretained(this)),
+                           net_log_);
 }
 
 int ProofVerifierChromium::Job::DoVerifyCertComplete(int result) {
   verifier_.reset();
 
   if (result <= ERR_FAILED) {
     error_details_ = StringPrintf("Failed to verify certificate chain: %s",
                                   ErrorToString(result));
     DLOG(WARNING) << error_details_;
     result = ERR_FAILED;
   }
 
   // Exit DoLoop and return the result to the caller to VerifyProof.
   DCHECK_EQ(STATE_NONE, next_state_);
   return result;
 }
 
 bool ProofVerifierChromium::Job::VerifySignature(const string& signed_data,
-                                            const string& signature,
-                                            const string& cert) {
+                                                 const string& signature,
+                                                 const string& cert) {
   StringPiece spki;
   if (!asn1::ExtractSPKIFromDERCert(cert, &spki)) {
     DLOG(WARNING) << "ExtractSPKIFromDERCert failed";
     return false;
   }
 
   crypto::SignatureVerifier verifier;
 
   size_t size_bits;
   X509Certificate::PublicKeyType type;
-  X509Certificate::GetPublicKeyInfo(cert_->os_cert_handle(), &size_bits,
-                                    &type);
+  X509Certificate::GetPublicKeyInfo(cert_->os_cert_handle(), &size_bits, &type);
   if (type == X509Certificate::kPublicKeyTypeRSA) {
     crypto::SignatureVerifier::HashAlgorithm hash_alg =
         crypto::SignatureVerifier::SHA256;
     crypto::SignatureVerifier::HashAlgorithm mask_hash_alg = hash_alg;
     unsigned int hash_len = 32;  // 32 is the length of a SHA-256 hash.
 
     bool ok = verifier.VerifyInitRSAPSS(
-        hash_alg, mask_hash_alg, hash_len,
-        reinterpret_cast<const uint8*>(signature.data()), signature.size(),
-        reinterpret_cast<const uint8*>(spki.data()), spki.size());
+        hash_alg,
+        mask_hash_alg,
+        hash_len,
+        reinterpret_cast<const uint8*>(signature.data()),
+        signature.size(),
+        reinterpret_cast<const uint8*>(spki.data()),
+        spki.size());
     if (!ok) {
       DLOG(WARNING) << "VerifyInitRSAPSS failed";
       return false;
     }
   } else if (type == X509Certificate::kPublicKeyTypeECDSA) {
     // This is the algorithm ID for ECDSA with SHA-256. Parameters are ABSENT.
     // RFC 5758:
     //   ecdsa-with-SHA256 OBJECT IDENTIFIER ::= { iso(1) member-body(2)
     //        us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) 2 }
     //   ...
     //   When the ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-SHA384, or
     //   ecdsa-with-SHA512 algorithm identifier appears in the algorithm field
     //   as an AlgorithmIdentifier, the encoding MUST omit the parameters
     //   field.  That is, the AlgorithmIdentifier SHALL be a SEQUENCE of one
     //   component, the OID ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-
     //   SHA384, or ecdsa-with-SHA512.
     // See also RFC 5480, Appendix A.
     static const uint8 kECDSAWithSHA256AlgorithmID[] = {
-      0x30, 0x0a,
-        0x06, 0x08,
-          0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02,
+        0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02,
     };
 
-    if (!verifier.VerifyInit(
-            kECDSAWithSHA256AlgorithmID, sizeof(kECDSAWithSHA256AlgorithmID),
-            reinterpret_cast<const uint8*>(signature.data()),
-            signature.size(),
-            reinterpret_cast<const uint8*>(spki.data()),
-            spki.size())) {
+    if (!verifier.VerifyInit(kECDSAWithSHA256AlgorithmID,
+                             sizeof(kECDSAWithSHA256AlgorithmID),
+                             reinterpret_cast<const uint8*>(signature.data()),
+                             signature.size(),
+                             reinterpret_cast<const uint8*>(spki.data()),
+                             spki.size())) {
       DLOG(WARNING) << "VerifyInit failed";
       return false;
     }
   } else {
     LOG(ERROR) << "Unsupported public key type " << type;
     return false;
   }
 
   verifier.VerifyUpdate(reinterpret_cast<const uint8*>(kProofSignatureLabel),
                         sizeof(kProofSignatureLabel));
   verifier.VerifyUpdate(reinterpret_cast<const uint8*>(signed_data.data()),
                         signed_data.size());
 
   if (!verifier.VerifyFinal()) {
     DLOG(WARNING) << "VerifyFinal failed";
     return false;
   }
 
   DVLOG(1) << "VerifyFinal success";
   return true;
 }
 
 ProofVerifierChromium::ProofVerifierChromium(CertVerifier* cert_verifier)
-    : cert_verifier_(cert_verifier) {}
+    : cert_verifier_(cert_verifier) {
+}
 
 ProofVerifierChromium::~ProofVerifierChromium() {
   STLDeleteElements(&active_jobs_);
 }
 
 ProofVerifierChromium::Status ProofVerifierChromium::VerifyProof(
     const std::string& hostname,
     const std::string& server_config,
     const std::vector<std::string>& certs,
     const std::string& signature,
     const ProofVerifyContext* verify_context,
     std::string* error_details,
     scoped_ptr<ProofVerifyDetails>* verify_details,
     ProofVerifierCallback* callback) {
   if (!verify_context) {
     *error_details = "Missing context";
     return FAILURE;
   }
   const ProofVerifyContextChromium* chromium_context =
       reinterpret_cast<const ProofVerifyContextChromium*>(verify_context);
   scoped_ptr<Job> job(new Job(this, cert_verifier_, chromium_context->net_log));
-  Status status = job->VerifyProof(hostname, server_config, certs, signature,
-                                   error_details, verify_details, callback);
+  Status status = job->VerifyProof(hostname,
+                                   server_config,
+                                   certs,
+                                   signature,
+                                   error_details,
+                                   verify_details,
+                                   callback);
   if (status == PENDING) {
     active_jobs_.insert(job.release());
   }
   return status;
 }
 
 void ProofVerifierChromium::OnJobComplete(Job* job) {
   active_jobs_.erase(job);
   delete job;
 }
 
 }  // namespace net