Clang format slam.

net/cert/multi_threaded_cert_verifier.cc

Index: net/cert/multi_threaded_cert_verifier.cc
diff --git a/net/cert/multi_threaded_cert_verifier.cc b/net/cert/multi_threaded_cert_verifier.cc
index f1b9bb8d1faf19c95a9b231314bebeb6528bc3fd..09387d6e70733bb23608f649fafd58d15f0e2977 100644
--- a/net/cert/multi_threaded_cert_verifier.cc
+++ b/net/cert/multi_threaded_cert_verifier.cc
@@ -80,21 +80,21 @@ const unsigned kTTLSecs = 1800;  // 30 minutes.
 
 }  // namespace
 
-MultiThreadedCertVerifier::CachedResult::CachedResult() : error(ERR_FAILED) {}
+MultiThreadedCertVerifier::CachedResult::CachedResult() : error(ERR_FAILED) {
+}
 
-MultiThreadedCertVerifier::CachedResult::~CachedResult() {}
+MultiThreadedCertVerifier::CachedResult::~CachedResult() {
+}
 
 MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     const base::Time& now)
-    : verification_time(now),
-      expiration_time(now) {
+    : verification_time(now), expiration_time(now) {
 }
 
 MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     const base::Time& now,
     const base::Time& expiration)
-    : verification_time(now),
-      expiration_time(expiration) {
+    : verification_time(now), expiration_time(expiration) {
 }
 
 bool MultiThreadedCertVerifier::CacheExpirationFunctor::operator()(
@@ -132,21 +132,17 @@ bool MultiThreadedCertVerifier::CacheExpirationFunctor::operator()(
          now.verification_time < expiration.expiration_time;
 };
 
-
 // Represents the output and result callback of a request.
 class CertVerifierRequest {
  public:
   CertVerifierRequest(const CompletionCallback& callback,
                       CertVerifyResult* verify_result,
                       const BoundNetLog& net_log)
-      : callback_(callback),
-        verify_result_(verify_result),
-        net_log_(net_log) {
+      : callback_(callback), verify_result_(verify_result), net_log_(net_log) {
     net_log_.BeginEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST);
   }
 
-  ~CertVerifierRequest() {
-  }
+  ~CertVerifierRequest() {}
 
   // Ensures that the result callback will never be made.
   void Cancel() {
@@ -177,7 +173,6 @@ class CertVerifierRequest {
   const BoundNetLog net_log_;
 };
 
-
 // CertVerifierWorker runs on a worker thread and takes care of the blocking
 // process of performing the certificate verification.  Deletes itself
 // eventually if Start() succeeds.
@@ -199,8 +194,7 @@ class CertVerifierWorker {
         origin_loop_(base::MessageLoop::current()),
         cert_verifier_(cert_verifier),
         canceled_(false),
-        error_(ERR_FAILED) {
-  }
+        error_(ERR_FAILED) {}
 
   // Returns the certificate being verified. May only be called /before/
   // Start() is called.
@@ -210,7 +204,8 @@ class CertVerifierWorker {
     DCHECK_EQ(base::MessageLoop::current(), origin_loop_);
 
     return base::WorkerPool::PostTask(
-        FROM_HERE, base::Bind(&CertVerifierWorker::Run, base::Unretained(this)),
+        FROM_HERE,
+        base::Bind(&CertVerifierWorker::Run, base::Unretained(this)),
         true /* task is slow */);
   }
 
@@ -283,8 +278,8 @@ class CertVerifierWorker {
       canceled = canceled_;
       if (!canceled) {
         origin_loop_->PostTask(
-            FROM_HERE, base::Bind(
-                &CertVerifierWorker::DoReply, base::Unretained(this)));
+            FROM_HERE,
+            base::Bind(&CertVerifierWorker::DoReply, base::Unretained(this)));
       }
     }
 
@@ -319,15 +314,13 @@ class CertVerifierWorker {
 // lives only on the CertVerifier's origin message loop.
 class CertVerifierJob {
  public:
-  CertVerifierJob(CertVerifierWorker* worker,
-                  const BoundNetLog& net_log)
+  CertVerifierJob(CertVerifierWorker* worker, const BoundNetLog& net_log)
       : start_time_(base::TimeTicks::Now()),
         worker_(worker),
         net_log_(net_log) {
-    net_log_.BeginEvent(
-        NetLog::TYPE_CERT_VERIFIER_JOB,
-        base::Bind(&NetLogX509CertificateCallback,
-                   base::Unretained(worker_->certificate())));
+    net_log_.BeginEvent(NetLog::TYPE_CERT_VERIFIER_JOB,
+                        base::Bind(&NetLogX509CertificateCallback,
+                                   base::Unretained(worker_->certificate())));
   }
 
   ~CertVerifierJob() {
@@ -340,9 +333,8 @@ class CertVerifierJob {
   }
 
   void AddRequest(CertVerifierRequest* request) {
-    request->net_log().AddEvent(
-        NetLog::TYPE_CERT_VERIFIER_REQUEST_BOUND_TO_JOB,
-        net_log_.source().ToEventParametersCallback());
+    request->net_log().AddEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST_BOUND_TO_JOB,
+                                net_log_.source().ToEventParametersCallback());
 
     requests_.push_back(request);
   }
@@ -373,16 +365,18 @@ class CertVerifierJob {
     std::vector<CertVerifierRequest*> requests;
     requests_.swap(requests);
 
-    for (std::vector<CertVerifierRequest*>::iterator
-         i = requests.begin(); i != requests.end(); i++) {
+    for (std::vector<CertVerifierRequest*>::iterator i = requests.begin();
+         i != requests.end();
+         i++) {
       (*i)->Post(verify_result);
       // Post() causes the CertVerifierRequest to delete itself.
     }
   }
 
   void DeleteAllCanceled() {
-    for (std::vector<CertVerifierRequest*>::iterator
-         i = requests_.begin(); i != requests_.end(); i++) {
+    for (std::vector<CertVerifierRequest*>::iterator i = requests_.begin();
+         i != requests_.end();
+         i++) {
       if ((*i)->canceled()) {
         delete *i;
       } else {
@@ -439,11 +433,15 @@ int MultiThreadedCertVerifier::Verify(X509Certificate* cert,
 
   const CertificateList empty_cert_list;
   const CertificateList& additional_trust_anchors =
-      trust_anchor_provider_ ?
-          trust_anchor_provider_->GetAdditionalTrustAnchors() : empty_cert_list;
-
-  const RequestParams key(cert->fingerprint(), cert->ca_fingerprint(),
-                          hostname, flags, additional_trust_anchors);
+      trust_anchor_provider_
+          ? trust_anchor_provider_->GetAdditionalTrustAnchors()
+          : empty_cert_list;
+
+  const RequestParams key(cert->fingerprint(),
+                          cert->ca_fingerprint(),
+                          hostname,
+                          flags,
+                          additional_trust_anchors);
   const CertVerifierCache::value_type* cached_entry =
       cache_.Get(key, CacheValidityPeriod(base::Time::Now()));
   if (cached_entry) {
@@ -509,8 +507,7 @@ MultiThreadedCertVerifier::RequestParams::RequestParams(
     const std::string& hostname_arg,
     int flags_arg,
     const CertificateList& additional_trust_anchors)
-    : hostname(hostname_arg),
-      flags(flags_arg) {
+    : hostname(hostname_arg), flags(flags_arg) {
   hash_values.reserve(2 + additional_trust_anchors.size());
   hash_values.push_back(cert_fingerprint_arg);
   hash_values.push_back(ca_fingerprint_arg);
@@ -518,7 +515,8 @@ MultiThreadedCertVerifier::RequestParams::RequestParams(
     hash_values.push_back(additional_trust_anchors[i]->fingerprint());
 }
 
-MultiThreadedCertVerifier::RequestParams::~RequestParams() {}
+MultiThreadedCertVerifier::RequestParams::~RequestParams() {
+}
 
 bool MultiThreadedCertVerifier::RequestParams::operator<(
     const RequestParams& other) const {
@@ -529,10 +527,11 @@ bool MultiThreadedCertVerifier::RequestParams::operator<(
     return flags < other.flags;
   if (hostname != other.hostname)
     return hostname < other.hostname;
-  return std::lexicographical_compare(
-      hash_values.begin(), hash_values.end(),
-      other.hash_values.begin(), other.hash_values.end(),
-      net::SHA1HashValueLessThan());
+  return std::lexicographical_compare(hash_values.begin(),
+                                      hash_values.end(),
+                                      other.hash_values.begin(),
+                                      other.hash_values.end(),
+                                      net::SHA1HashValueLessThan());
 }
 
 // HandleResult is called by CertVerifierWorker on the origin message loop.
@@ -546,15 +545,20 @@ void MultiThreadedCertVerifier::HandleResult(
     const CertVerifyResult& verify_result) {
   DCHECK(CalledOnValidThread());
 
-  const RequestParams key(cert->fingerprint(), cert->ca_fingerprint(),
-                          hostname, flags, additional_trust_anchors);
+  const RequestParams key(cert->fingerprint(),
+                          cert->ca_fingerprint(),
+                          hostname,
+                          flags,
+                          additional_trust_anchors);
 
   CachedResult cached_result;
   cached_result.error = error;
   cached_result.result = verify_result;
   base::Time now = base::Time::Now();
   cache_.Put(
-      key, cached_result, CacheValidityPeriod(now),
+      key,
+      cached_result,
+      CacheValidityPeriod(now),
       CacheValidityPeriod(now, now + base::TimeDelta::FromSeconds(kTTLSecs)));
 
   std::map<RequestParams, CertVerifierJob*>::iterator j;
@@ -575,8 +579,7 @@ void MultiThreadedCertVerifier::HandleResult(
   delete job;
 }
 
-void MultiThreadedCertVerifier::OnCACertChanged(
-    const X509Certificate* cert) {
+void MultiThreadedCertVerifier::OnCACertChanged(const X509Certificate* cert) {
   DCHECK(CalledOnValidThread());
 
   ClearCache();