Clang format slam.

net/proxy/proxy_script_decider.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_script_decider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
@@ skipping 13 matching lines @@
 namespace {
 
 bool LooksLikePacScript(const base::string16& script) {
   // Note: this is only an approximation! It may not always work correctly,
   // however it is very likely that legitimate scripts have this exact string,
   // since they must minimally define a function of this name. Conversely, a
   // file not containing the string is not likely to be a PAC script.
   //
   // An exact test would have to load the script in a javascript evaluator.
   return script.find(base::ASCIIToUTF16("FindProxyForURL")) !=
-             base::string16::npos;
+         base::string16::npos;
 }
-
 }
 
 // This is the hard-coded location used by the DNS portion of web proxy
 // auto-discovery.
 //
 // Note that we not use DNS devolution to find the WPAD host, since that could
 // be dangerous should our top level domain registry  become out of date.
 //
 // Instead we directly resolve "wpad", and let the operating system apply the
 // DNS suffix search paths. This is the same approach taken by Firefox, and
@@ skipping 31 matching lines @@
 ProxyScriptDecider::ProxyScriptDecider(
     ProxyScriptFetcher* proxy_script_fetcher,
     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
     NetLog* net_log)
     : resolver_(NULL),
       proxy_script_fetcher_(proxy_script_fetcher),
       dhcp_proxy_script_fetcher_(dhcp_proxy_script_fetcher),
       current_pac_source_index_(0u),
       pac_mandatory_(false),
       next_state_(STATE_NONE),
-      net_log_(BoundNetLog::Make(
-          net_log, NetLog::SOURCE_PROXY_SCRIPT_DECIDER)),
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_PROXY_SCRIPT_DECIDER)),
       fetch_pac_bytes_(false),
       quick_check_enabled_(true) {
-  if (proxy_script_fetcher &&
-      proxy_script_fetcher->GetRequestContext() &&
+  if (proxy_script_fetcher && proxy_script_fetcher->GetRequestContext() &&
       proxy_script_fetcher->GetRequestContext()->host_resolver()) {
-      host_resolver_.reset(new SingleRequestHostResolver(
-          proxy_script_fetcher->GetRequestContext()->host_resolver()));
+    host_resolver_.reset(new SingleRequestHostResolver(
+        proxy_script_fetcher->GetRequestContext()->host_resolver()));
   }
 }
 
 ProxyScriptDecider::~ProxyScriptDecider() {
   if (next_state_ != STATE_NONE)
     Cancel();
 }
 
-int ProxyScriptDecider::Start(
-    const ProxyConfig& config, const base::TimeDelta wait_delay,
-    bool fetch_pac_bytes, const CompletionCallback& callback) {
+int ProxyScriptDecider::Start(const ProxyConfig& config,
+                              const base::TimeDelta wait_delay,
+                              bool fetch_pac_bytes,
+                              const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(!callback.is_null());
   DCHECK(config.HasAutomaticSettings());
 
   net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER);
 
   fetch_pac_bytes_ = fetch_pac_bytes;
 
   // Save the |wait_delay| as a non-negative value.
   wait_delay_ = wait_delay;
@@ skipping 25 matching lines @@
 // TODO(eroman): Return a const-pointer.
 ProxyResolverScriptData* ProxyScriptDecider::script_data() const {
   DCHECK_EQ(STATE_NONE, next_state_);
   return script_data_.get();
 }
 
 // Initialize the fallback rules.
 // (1) WPAD (DHCP).
 // (2) WPAD (DNS).
 // (3) Custom PAC URL.
-ProxyScriptDecider::PacSourceList ProxyScriptDecider::
-    BuildPacSourcesFallbackList(
+ProxyScriptDecider::PacSourceList
+ProxyScriptDecider::BuildPacSourcesFallbackList(
     const ProxyConfig& config) const {
   PacSourceList pac_sources;
   if (config.auto_detect()) {
     pac_sources.push_back(PacSource(PacSource::WPAD_DHCP, GURL(kWpadUrl)));
     pac_sources.push_back(PacSource(PacSource::WPAD_DNS, GURL(kWpadUrl)));
   }
   if (config.has_pac_url())
     pac_sources.push_back(PacSource(PacSource::CUSTOM, config.pac_url()));
   return pac_sources;
 }
@@ skipping 58 matching lines @@
 }
 
 int ProxyScriptDecider::DoWait() {
   next_state_ = STATE_WAIT_COMPLETE;
 
   // If no waiting is required, continue on to the next state.
   if (wait_delay_.ToInternalValue() == 0)
     return OK;
 
   // Otherwise wait the specified amount of time.
-  wait_timer_.Start(FROM_HERE, wait_delay_, this,
-                    &ProxyScriptDecider::OnWaitTimerFired);
+  wait_timer_.Start(
+      FROM_HERE, wait_delay_, this, &ProxyScriptDecider::OnWaitTimerFired);
   net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_WAIT);
   return ERR_IO_PENDING;
 }
 
 int ProxyScriptDecider::DoWaitComplete(int result) {
   DCHECK_EQ(OK, result);
   if (wait_delay_.ToInternalValue() != 0) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_PROXY_SCRIPT_DECIDER_WAIT,
                                       result);
   }
   if (quick_check_enabled_ && current_pac_source().type == PacSource::WPAD_DNS)
     next_state_ = STATE_QUICK_CHECK;
   else
     next_state_ = GetStartState();
   return OK;
 }
 
 int ProxyScriptDecider::DoQuickCheck() {
   DCHECK(quick_check_enabled_);
   if (host_resolver_.get() == NULL) {
     // If we have no resolver, skip QuickCheck altogether.
     next_state_ = GetStartState();
     return OK;
   }
 
   quick_check_start_time_ = base::Time::Now();
   std::string host = current_pac_source().url.host();
   HostResolver::RequestInfo reqinfo(HostPortPair(host, 80));
   reqinfo.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
-  CompletionCallback callback = base::Bind(
-      &ProxyScriptDecider::OnIOCompletion,
-      base::Unretained(this));
+  CompletionCallback callback =
+      base::Bind(&ProxyScriptDecider::OnIOCompletion, base::Unretained(this));
 
   next_state_ = STATE_QUICK_CHECK_COMPLETE;
-  quick_check_timer_.Start(FROM_HERE,
-                           base::TimeDelta::FromMilliseconds(
-                              kQuickCheckDelayMs),
-                           base::Bind(callback, ERR_NAME_NOT_RESOLVED));
+  quick_check_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromMilliseconds(kQuickCheckDelayMs),
+      base::Bind(callback, ERR_NAME_NOT_RESOLVED));
 
   // We use HIGHEST here because proxy decision blocks doing any other requests.
-  return host_resolver_->Resolve(reqinfo, HIGHEST, &wpad_addresses_,
-                                 callback, net_log_);
+  return host_resolver_->Resolve(
+      reqinfo, HIGHEST, &wpad_addresses_, callback, net_log_);
 }
 
 int ProxyScriptDecider::DoQuickCheckComplete(int result) {
   DCHECK(quick_check_enabled_);
   base::TimeDelta delta = base::Time::Now() - quick_check_start_time_;
   if (result == OK)
     UMA_HISTOGRAM_TIMES("Net.WpadQuickCheckSuccess", delta);
   else
     UMA_HISTOGRAM_TIMES("Net.WpadQuickCheckFailure", delta);
   host_resolver_->Cancel();
@@ skipping 19 matching lines @@
                                  base::Unretained(&pac_source),
                                  &effective_pac_url));
 
   if (pac_source.type == PacSource::WPAD_DHCP) {
     if (!dhcp_proxy_script_fetcher_) {
       net_log_.AddEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER);
       return ERR_UNEXPECTED;
     }
 
     return dhcp_proxy_script_fetcher_->Fetch(
-        &pac_script_, base::Bind(&ProxyScriptDecider::OnIOCompletion,
-                                 base::Unretained(this)));
+        &pac_script_,
+        base::Bind(&ProxyScriptDecider::OnIOCompletion,
+                   base::Unretained(this)));
   }
 
   if (!proxy_script_fetcher_) {
     net_log_.AddEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER);
     return ERR_UNEXPECTED;
   }
 
   return proxy_script_fetcher_->Fetch(
-      effective_pac_url, &pac_script_,
+      effective_pac_url,
+      &pac_script_,
       base::Bind(&ProxyScriptDecider::OnIOCompletion, base::Unretained(this)));
 }
 
 int ProxyScriptDecider::DoFetchPacScriptComplete(int result) {
   DCHECK(fetch_pac_bytes_);
 
   net_log_.EndEventWithNetErrorCode(
       NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT, result);
   if (result != OK)
     return TryToFallbackPacSource(result);
@@ skipping 15 matching lines @@
 int ProxyScriptDecider::DoVerifyPacScriptComplete(int result) {
   if (result != OK)
     return TryToFallbackPacSource(result);
 
   const PacSource& pac_source = current_pac_source();
 
   // Extract the current script data.
   if (fetch_pac_bytes_) {
     script_data_ = ProxyResolverScriptData::FromUTF16(pac_script_);
   } else {
-    script_data_ = pac_source.type == PacSource::CUSTOM ?
-        ProxyResolverScriptData::FromURL(pac_source.url) :
-        ProxyResolverScriptData::ForAutoDetect();
+    script_data_ = pac_source.type == PacSource::CUSTOM
+                       ? ProxyResolverScriptData::FromURL(pac_source.url)
+                       : ProxyResolverScriptData::ForAutoDetect();
   }
 
   // Let the caller know which automatic setting we ended up initializing the
   // resolver for (there may have been multiple fallbacks to choose from.)
   if (current_pac_source().type == PacSource::CUSTOM) {
     effective_config_ =
         ProxyConfig::CreateFromCustomPacURL(current_pac_source().url);
     effective_config_.set_pac_mandatory(pac_mandatory_);
   } else {
     if (fetch_pac_bytes_) {
@@ skipping 40 matching lines @@
       NetLog::TYPE_PROXY_SCRIPT_DECIDER_FALLING_BACK_TO_NEXT_PAC_SOURCE);
   if (quick_check_enabled_ && current_pac_source().type == PacSource::WPAD_DNS)
     next_state_ = STATE_QUICK_CHECK;
   else
     next_state_ = GetStartState();
 
   return OK;
 }
 
 ProxyScriptDecider::State ProxyScriptDecider::GetStartState() const {
-  return fetch_pac_bytes_ ?  STATE_FETCH_PAC_SCRIPT : STATE_VERIFY_PAC_SCRIPT;
+  return fetch_pac_bytes_ ? STATE_FETCH_PAC_SCRIPT : STATE_VERIFY_PAC_SCRIPT;
 }
 
 void ProxyScriptDecider::DetermineURL(const PacSource& pac_source,
                                       GURL* effective_pac_url) {
   DCHECK(effective_pac_url);
 
   switch (pac_source.type) {
     case PacSource::WPAD_DHCP:
       break;
     case PacSource::WPAD_DNS:
       *effective_pac_url = GURL(kWpadUrl);
       break;
     case PacSource::CUSTOM:
       *effective_pac_url = pac_source.url;
       break;
   }
 }
 
-const ProxyScriptDecider::PacSource&
-    ProxyScriptDecider::current_pac_source() const {
+const ProxyScriptDecider::PacSource& ProxyScriptDecider::current_pac_source()
+    const {
   DCHECK_LT(current_pac_source_index_, pac_sources_.size());
   return pac_sources_[current_pac_source_index_];
 }
 
 void ProxyScriptDecider::OnWaitTimerFired() {
   OnIOCompletion(OK);
 }
 
 void ProxyScriptDecider::DidComplete() {
   net_log_.EndEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER);
@@ skipping 17 matching lines @@
   }
 
   // This is safe to call in any state.
   if (dhcp_proxy_script_fetcher_)
     dhcp_proxy_script_fetcher_->Cancel();
 
   DidComplete();
 }
 
 }  // namespace net