Clang format slam.

net/cert/multi_threaded_cert_verifier.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/multi_threaded_cert_verifier.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 62 matching lines @@
 namespace {
 
 // The default value of max_cache_entries_.
 const unsigned kMaxCacheEntries = 256;
 
 // The number of seconds for which we'll cache a cache entry.
 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()(
     const CacheValidityPeriod& now,
     const CacheValidityPeriod& expiration) const {
   // Ensure this functor is being used for expiration only, and not strict
   // weak ordering/sorting. |now| should only ever contain a single
   // base::Time.
   // Note: DCHECK_EQ is not used due to operator<< overloading requirements.
   DCHECK(now.verification_time == now.expiration_time);
@@ skipping 17 matching lines @@
   // This algorithm is only problematic if the user consistently keeps
   // adjusting their clock backwards in increments smaller than the expiration
   // TTL, in which case, cached elements continue to be added. However,
   // because the cache has a fixed upper bound, if no entries are expired, a
   // 'random' entry will be, thus keeping the memory constraints bounded over
   // time.
   return now.verification_time >= expiration.verification_time &&
          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() {
     callback_.Reset();
     verify_result_ = NULL;
     net_log_.AddEvent(NetLog::TYPE_CANCELLED);
     net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST);
   }
 
   // Copies the contents of |verify_result| to the caller's
@@ skipping 10 matching lines @@
   bool canceled() const { return callback_.is_null(); }
 
   const BoundNetLog& net_log() const { return net_log_; }
 
  private:
   CompletionCallback callback_;
   CertVerifyResult* verify_result_;
   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.
 class CertVerifierWorker {
  public:
   CertVerifierWorker(CertVerifyProc* verify_proc,
                      X509Certificate* cert,
                      const std::string& hostname,
                      int flags,
                      CRLSet* crl_set,
                      const CertificateList& additional_trust_anchors,
                      MultiThreadedCertVerifier* cert_verifier)
       : verify_proc_(verify_proc),
         cert_(cert),
         hostname_(hostname),
         flags_(flags),
         crl_set_(crl_set),
         additional_trust_anchors_(additional_trust_anchors),
         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.
   X509Certificate* certificate() const { return cert_.get(); }
 
   bool Start() {
     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 */);
   }
 
   // Cancel is called from the origin loop when the MultiThreadedCertVerifier is
   // getting deleted.
   void Cancel() {
     DCHECK_EQ(base::MessageLoop::current(), origin_loop_);
     base::AutoLock locked(lock_);
     canceled_ = true;
   }
@@ skipping 52 matching lines @@
     // If it does so after this function, we assume that the MessageLoop will
     // process pending tasks. In which case we'll notice the |canceled_| flag
     // in DoReply.
 
     bool canceled;
     {
       base::AutoLock locked(lock_);
       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)));
       }
     }
 
     if (canceled)
       delete this;
   }
 
   scoped_refptr<CertVerifyProc> verify_proc_;
   scoped_refptr<X509Certificate> cert_;
   const std::string hostname_;
@@ skipping 14 matching lines @@
   int error_;
   CertVerifyResult verify_result_;
 
   DISALLOW_COPY_AND_ASSIGN(CertVerifierWorker);
 };
 
 // A CertVerifierJob is a one-to-one counterpart of a CertVerifierWorker. It
 // 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() {
     if (worker_) {
       net_log_.AddEvent(NetLog::TYPE_CANCELLED);
       net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB);
       worker_->Cancel();
       DeleteAllCanceled();
     }
   }
 
   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);
   }
 
   void HandleResult(
       const MultiThreadedCertVerifier::CachedResult& verify_result,
       bool is_first_job) {
     worker_ = NULL;
     net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB);
     base::TimeDelta latency = base::TimeTicks::Now() - start_time_;
@@ skipping 10 matching lines @@
                                  100);
     }
     PostAll(verify_result);
   }
 
  private:
   void PostAll(const MultiThreadedCertVerifier::CachedResult& verify_result) {
     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 {
         LOG(DFATAL) << "CertVerifierRequest leaked!";
       }
     }
   }
 
   const base::TimeTicks start_time_;
   std::vector<CertVerifierRequest*> requests_;
@@ skipping 36 matching lines @@
 
   if (callback.is_null() || !verify_result || hostname.empty()) {
     *out_req = NULL;
     return ERR_INVALID_ARGUMENT;
   }
 
   requests_++;
 
   const CertificateList empty_cert_list;
   const CertificateList& additional_trust_anchors =
-      trust_anchor_provider_ ?
-          trust_anchor_provider_->GetAdditionalTrustAnchors() : empty_cert_list;
+      trust_anchor_provider_
+          ? trust_anchor_provider_->GetAdditionalTrustAnchors()
+          : empty_cert_list;
 
-  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);
   const CertVerifierCache::value_type* cached_entry =
       cache_.Get(key, CacheValidityPeriod(base::Time::Now()));
   if (cached_entry) {
     ++cache_hits_;
     *out_req = NULL;
     *verify_result = cached_entry->result;
     return cached_entry->error;
   }
 
   // No cache hit. See if an identical request is currently in flight.
@@ skipping 45 matching lines @@
   CertVerifierRequest* request = reinterpret_cast<CertVerifierRequest*>(req);
   request->Cancel();
 }
 
 MultiThreadedCertVerifier::RequestParams::RequestParams(
     const SHA1HashValue& cert_fingerprint_arg,
     const SHA1HashValue& ca_fingerprint_arg,
     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);
   for (size_t i = 0; i < additional_trust_anchors.size(); ++i)
     hash_values.push_back(additional_trust_anchors[i]->fingerprint());
 }
 
-MultiThreadedCertVerifier::RequestParams::~RequestParams() {}
+MultiThreadedCertVerifier::RequestParams::~RequestParams() {
+}
 
 bool MultiThreadedCertVerifier::RequestParams::operator<(
     const RequestParams& other) const {
   // |flags| is compared before |cert_fingerprint|, |ca_fingerprint|, and
   // |hostname| under assumption that integer comparisons are faster than
   // memory and string comparisons.
   if (flags != other.flags)
     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.
 // It deletes CertVerifierJob.
 void MultiThreadedCertVerifier::HandleResult(
     X509Certificate* cert,
     const std::string& hostname,
     int flags,
     const CertificateList& additional_trust_anchors,
     int error,
     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;
   j = inflight_.find(key);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
   CertVerifierJob* job = j->second;
   inflight_.erase(j);
   bool is_first_job = false;
   if (first_job_ == job) {
     is_first_job = true;
     first_job_ = NULL;
   }
 
   job->HandleResult(cached_result, is_first_job);
   delete job;
 }
 
-void MultiThreadedCertVerifier::OnCACertChanged(
-    const X509Certificate* cert) {
+void MultiThreadedCertVerifier::OnCACertChanged(const X509Certificate* cert) {
   DCHECK(CalledOnValidThread());
 
   ClearCache();
 }
 
 }  // namespace net