Clang format slam.

net/proxy/proxy_list.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/proxy/proxy_list.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 53 matching lines @@
         if (bad_proxy->second.try_while_bad)
           bad_proxies_to_try.push_back(*iter);
         continue;
       }
     }
     good_proxies.push_back(*iter);
   }
 
   // "proxies_ = good_proxies + bad_proxies"
   proxies_.swap(good_proxies);
-  proxies_.insert(proxies_.end(), bad_proxies_to_try.begin(),
-                  bad_proxies_to_try.end());
+  proxies_.insert(
+      proxies_.end(), bad_proxies_to_try.begin(), bad_proxies_to_try.end());
 }
 
 void ProxyList::RemoveProxiesWithoutScheme(int scheme_bit_field) {
   for (std::vector<ProxyServer>::iterator it = proxies_.begin();
-       it != proxies_.end(); ) {
+       it != proxies_.end();) {
     if (!(scheme_bit_field & it->scheme())) {
       it = proxies_.erase(it);
       continue;
     }
     ++it;
   }
 }
 
 void ProxyList::Clear() {
   proxies_.clear();
@@ skipping 16 matching lines @@
 
 const ProxyServer& ProxyList::Get() const {
   DCHECK(!proxies_.empty());
   return proxies_[0];
 }
 
 void ProxyList::SetFromPacString(const std::string& pac_string) {
   base::StringTokenizer entry_tok(pac_string, ";");
   proxies_.clear();
   while (entry_tok.GetNext()) {
-    ProxyServer uri = ProxyServer::FromPacString(
-        entry_tok.token_begin(), entry_tok.token_end());
+    ProxyServer uri = ProxyServer::FromPacString(entry_tok.token_begin(),
+                                                 entry_tok.token_end());
     // Silently discard malformed inputs.
     if (uri.is_valid())
       proxies_.push_back(uri);
   }
 
   // If we failed to parse anything from the PAC results list, fallback to
   // DIRECT (this basically means an error in the PAC script).
   if (proxies_.empty()) {
     proxies_.push_back(ProxyServer::Direct());
   }
@@ skipping 12 matching lines @@
 
 base::ListValue* ProxyList::ToValue() const {
   base::ListValue* list = new base::ListValue();
   for (size_t i = 0; i < proxies_.size(); ++i)
     list->AppendString(proxies_[i].ToURI());
   return list;
 }
 
 bool ProxyList::Fallback(ProxyRetryInfoMap* proxy_retry_info,
                          const BoundNetLog& net_log) {
-
   // TODO(eroman): It would be good if instead of removing failed proxies
   // from the list, we simply annotated them with the error code they failed
   // with. Of course, ProxyService::ReconsiderProxyAfterError() would need to
   // be given this information by the network transaction.
   //
   // The advantage of this approach is when the network transaction
   // fails, we could output the full list of proxies that were attempted, and
   // why each one of those failed (as opposed to just the last failure).
   //
   // And also, before failing the transaction wholesale, we could go back and
   // retry the "bad proxies" which we never tried to begin with.
   // (RemoveBadProxies would annotate them as 'expected bad' rather then delete
   // them from the list, so we would know what they were).
 
   if (proxies_.empty()) {
     NOTREACHED();
     return false;
   }
-  UpdateRetryInfoOnFallback(proxy_retry_info, base::TimeDelta(), true,
-                            ProxyServer(), net_log);
+  UpdateRetryInfoOnFallback(
+      proxy_retry_info, base::TimeDelta(), true, ProxyServer(), net_log);
 
   // Remove this proxy from our list.
   proxies_.erase(proxies_.begin());
   return !proxies_.empty();
 }
 
 void ProxyList::AddProxyToRetryList(ProxyRetryInfoMap* proxy_retry_info,
                                     base::TimeDelta retry_delay,
                                     bool try_while_bad,
                                     const ProxyServer& proxy_to_retry,
@@ skipping 19 matching lines @@
 void ProxyList::UpdateRetryInfoOnFallback(
     ProxyRetryInfoMap* proxy_retry_info,
     base::TimeDelta retry_delay,
     bool reconsider,
     const ProxyServer& another_proxy_to_bypass,
     const BoundNetLog& net_log) const {
   // Time to wait before retrying a bad proxy server.
   if (retry_delay == base::TimeDelta()) {
 #if defined(SPDY_PROXY_AUTH_ORIGIN)
     // Randomize the timeout over a range from one to five minutes.
-    retry_delay =
-        TimeDelta::FromMilliseconds(
-            base::RandInt(1 * 60 * 1000, 5 * 60 * 1000));
+    retry_delay = TimeDelta::FromMilliseconds(
+        base::RandInt(1 * 60 * 1000, 5 * 60 * 1000));
 #else
     retry_delay = TimeDelta::FromMinutes(5);
 #endif
   }
 
   if (proxies_.empty()) {
     NOTREACHED();
     return;
   }
 
   if (!proxies_[0].is_direct()) {
-    AddProxyToRetryList(proxy_retry_info, retry_delay, reconsider, proxies_[0],
-                        net_log);
+    AddProxyToRetryList(
+        proxy_retry_info, retry_delay, reconsider, proxies_[0], net_log);
 
     // If an additional proxy to bypass is specified, add it to the retry map
     // as well.
     if (another_proxy_to_bypass.is_valid()) {
-      AddProxyToRetryList(proxy_retry_info, retry_delay, reconsider,
-                          another_proxy_to_bypass, net_log);
+      AddProxyToRetryList(proxy_retry_info,
+                          retry_delay,
+                          reconsider,
+                          another_proxy_to_bypass,
+                          net_log);
     }
   }
 }
 
 }  // namespace net