Clang format slam.

net/http/http_auth_cache.cc

 // Copyright (c) 2011 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/http/http_auth_cache.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 
@@ skipping 33 matching lines @@
 void CheckOriginIsValid(const GURL& origin) {
   DCHECK(origin.is_valid());
   // Note that the scheme may be FTP when we're using a HTTP proxy.
   DCHECK(origin.SchemeIsHTTPOrHTTPS() || origin.SchemeIs("ftp") ||
          origin.SchemeIsWSOrWSS());
   DCHECK(origin.GetOrigin() == origin);
 }
 
 // Functor used by remove_if.
 struct IsEnclosedBy {
-  explicit IsEnclosedBy(const std::string& path) : path(path) { }
-  bool operator() (const std::string& x) const {
+  explicit IsEnclosedBy(const std::string& path) : path(path) {}
+  bool operator()(const std::string& x) const {
     return IsEnclosingPath(path, x);
   }
   const std::string& path;
 };
 
 void RecordLookupPosition(int position) {
   UMA_HISTOGRAM_COUNTS_100("Net.HttpAuthCacheLookupPosition", position);
 }
 
 void RecordLookupByPathPosition(int position) {
@@ skipping 78 matching lines @@
   base::TimeTicks now = base::TimeTicks::Now();
 
   // Check for existing entry (we will re-use it if present).
   HttpAuthCache::Entry* entry = Lookup(origin, realm, scheme);
   if (!entry) {
     bool evicted = false;
     // Failsafe to prevent unbounded memory growth of the cache.
     if (entries_.size() >= kMaxNumRealmEntries) {
       LOG(WARNING) << "Num auth cache entries reached limit -- evicting";
       UMA_HISTOGRAM_LONG_TIMES("Net.HttpAuthCacheAddEvictedCreation",
-          now - entries_.back().creation_time_);
+                               now - entries_.back().creation_time_);
       UMA_HISTOGRAM_LONG_TIMES("Net.HttpAuthCacheAddEvictedLastUse",
-          now - entries_.back().last_use_time_);
+                               now - entries_.back().last_use_time_);
       entries_.pop_back();
       evicted = true;
     }
     UMA_HISTOGRAM_BOOLEAN("Net.HttpAuthCacheAddEvicted", evicted);
 
     entries_.push_front(Entry());
     entry = &entries_.front();
     entry->origin_ = origin;
     entry->realm_ = realm;
     entry->scheme_ = scheme;
@@ skipping 15 matching lines @@
 HttpAuthCache::Entry::~Entry() {
 }
 
 void HttpAuthCache::Entry::UpdateStaleChallenge(
     const std::string& auth_challenge) {
   auth_challenge_ = auth_challenge;
   nonce_count_ = 1;
 }
 
 HttpAuthCache::Entry::Entry()
-    : scheme_(HttpAuth::AUTH_SCHEME_MAX),
-      nonce_count_(0) {
+    : scheme_(HttpAuth::AUTH_SCHEME_MAX), nonce_count_(0) {
 }
 
 void HttpAuthCache::Entry::AddPath(const std::string& path) {
   std::string parent_dir = GetParentDirectory(path);
   if (!HasEnclosingPath(parent_dir, NULL)) {
     // Remove any entries that have been subsumed by the new entry.
     paths_.remove_if(IsEnclosedBy(parent_dir));
 
     bool evicted = false;
     // Failsafe to prevent unbounded memory growth of the cache.
     if (paths_.size() >= kMaxNumPathsPerRealmEntry) {
       LOG(WARNING) << "Num path entries for " << origin()
                    << " has grown too large -- evicting";
       paths_.pop_back();
       evicted = true;
     }
     UMA_HISTOGRAM_BOOLEAN("Net.HttpAuthCacheAddPathEvicted", evicted);
 
     // Add new path.
     paths_.push_front(parent_dir);
   }
 }
 
 bool HttpAuthCache::Entry::HasEnclosingPath(const std::string& dir,
                                             size_t* path_len) {
   DCHECK(GetParentDirectory(dir) == dir);
-  for (PathList::const_iterator it = paths_.begin(); it != paths_.end();
-       ++it) {
+  for (PathList::const_iterator it = paths_.begin(); it != paths_.end(); ++it) {
     if (IsEnclosingPath(*it, dir)) {
       // No element of paths_ may enclose any other element.
       // Therefore this path is the tightest bound.  Important because
       // the length returned is used to determine the cache entry that
       // has the closest enclosing path in LookupByPath().
       if (path_len)
         *path_len = it->length();
       return true;
     }
   }
@@ skipping 24 matching lines @@
   HttpAuthCache::Entry* entry = Lookup(origin, realm, scheme);
   if (!entry)
     return false;
   entry->UpdateStaleChallenge(auth_challenge);
   entry->last_use_time_ = base::TimeTicks::Now();
   return true;
 }
 
 void HttpAuthCache::UpdateAllFrom(const HttpAuthCache& other) {
   for (EntryList::const_iterator it = other.entries_.begin();
-       it != other.entries_.end(); ++it) {
+       it != other.entries_.end();
+       ++it) {
     // Add an Entry with one of the original entry's paths.
     DCHECK(it->paths_.size() > 0);
-    Entry* entry = Add(it->origin(), it->realm(), it->scheme(),
-                       it->auth_challenge(), it->credentials(),
+    Entry* entry = Add(it->origin(),
+                       it->realm(),
+                       it->scheme(),
+                       it->auth_challenge(),
+                       it->credentials(),
                        it->paths_.back());
     // Copy all other paths.
     for (Entry::PathList::const_reverse_iterator it2 = ++it->paths_.rbegin();
-         it2 != it->paths_.rend(); ++it2)
+         it2 != it->paths_.rend();
+         ++it2)
       entry->AddPath(*it2);
     // Copy nonce count (for digest authentication).
     entry->nonce_count_ = it->nonce_count_;
   }
 }
 
 }  // namespace net