Clang format slam.

net/proxy/proxy_service.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_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 111 matching lines @@
  public:
   DefaultPollPolicy() {}
 
   virtual Mode GetNextDelay(int initial_error,
                             TimeDelta current_delay,
                             TimeDelta* next_delay) const OVERRIDE {
     if (initial_error != OK) {
       // Re-try policy for failures.
       const int kDelay1Seconds = 8;
       const int kDelay2Seconds = 32;
-      const int kDelay3Seconds = 2 * 60;  // 2 minutes
+      const int kDelay3Seconds = 2 * 60;       // 2 minutes
       const int kDelay4Seconds = 4 * 60 * 60;  // 4 Hours
 
       // Initial poll.
       if (current_delay < TimeDelta()) {
         *next_delay = TimeDelta::FromSeconds(kDelay1Seconds);
         return MODE_USE_TIMER;
       }
       switch (current_delay.InSeconds()) {
         case kDelay1Seconds:
           *next_delay = TimeDelta::FromSeconds(kDelay2Seconds);
@@ skipping 15 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultPollPolicy);
 };
 
 // Config getter that always returns direct settings.
 class ProxyConfigServiceDirect : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config)
-      OVERRIDE {
+  virtual ConfigAvailability GetLatestProxyConfig(
+      ProxyConfig* config) OVERRIDE {
     *config = ProxyConfig::CreateDirect();
     config->set_source(PROXY_CONFIG_SOURCE_UNKNOWN);
     return CONFIG_VALID;
   }
 };
 
 // Proxy resolver that fails every time.
 class ProxyResolverNull : public ProxyResolver {
  public:
   ProxyResolverNull() : ProxyResolver(false /*expects_pac_bytes*/) {}
 
   // ProxyResolver implementation.
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     return ERR_NOT_IMPLEMENTED;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
-    NOTREACHED();
-  }
+  virtual void CancelRequest(RequestHandle request) OVERRIDE { NOTREACHED(); }
 
   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
-    NOTREACHED();
-  }
+  virtual void CancelSetPacScript() OVERRIDE { NOTREACHED(); }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& /*script_data*/,
       const CompletionCallback& /*callback*/) OVERRIDE {
     return ERR_NOT_IMPLEMENTED;
   }
 };
 
 // ProxyResolver that simulates a PAC script which returns
 // |pac_string| for every single URL.
 class ProxyResolverFromPacString : public ProxyResolver {
  public:
   explicit ProxyResolverFromPacString(const std::string& pac_string)
-      : ProxyResolver(false /*expects_pac_bytes*/),
-        pac_string_(pac_string) {}
+      : ProxyResolver(false /*expects_pac_bytes*/), pac_string_(pac_string) {}
 
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     results->UsePacString(pac_string_);
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
-    NOTREACHED();
-  }
+  virtual void CancelRequest(RequestHandle request) OVERRIDE { NOTREACHED(); }
 
   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
-    NOTREACHED();
-  }
+  virtual void CancelSetPacScript() OVERRIDE { NOTREACHED(); }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
       const CompletionCallback& callback) OVERRIDE {
     return OK;
   }
 
  private:
   const std::string pac_string_;
 };
@@ skipping 38 matching lines @@
   dict->Set("new_config", new_config->ToValue());
   return dict;
 }
 
 base::Value* NetLogBadProxyListCallback(const ProxyRetryInfoMap* retry_info,
                                         NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   base::ListValue* list = new base::ListValue();
 
   for (ProxyRetryInfoMap::const_iterator iter = retry_info->begin();
-       iter != retry_info->end(); ++iter) {
+       iter != retry_info->end();
+       ++iter) {
     list->Append(new base::StringValue(iter->first));
   }
   dict->Set("bad_proxy_list", list);
   return dict;
 }
 
 // Returns NetLog parameters on a successfuly proxy resolution.
 base::Value* NetLogFinishedResolvingProxyCallback(
     ProxyInfo* result,
     NetLog::LogLevel /* log_level */) {
@@ skipping 29 matching lines @@
 // InitProxyResolver is a single-use class which encapsulates cancellation as
 // part of its destructor. Start() or StartSkipDecider() should be called just
 // once. The instance can be destroyed at any time, and the request will be
 // cancelled.
 
 class ProxyService::InitProxyResolver {
  public:
   InitProxyResolver()
       : proxy_resolver_(NULL),
         next_state_(STATE_NONE),
-        quick_check_enabled_(true) {
-  }
+        quick_check_enabled_(true) {}
 
   ~InitProxyResolver() {
     // Note that the destruction of ProxyScriptDecider will automatically cancel
     // any outstanding work.
     if (next_state_ == STATE_SET_PAC_SCRIPT_COMPLETE) {
       proxy_resolver_->CancelSetPacScript();
     }
   }
 
   // Begins initializing the proxy resolver; calls |callback| when done.
@@ skipping 102 matching lines @@
           break;
       }
     } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
     return rv;
   }
 
   int DoDecideProxyScript() {
     next_state_ = STATE_DECIDE_PROXY_SCRIPT_COMPLETE;
 
     return decider_->Start(
-        config_, wait_delay_, proxy_resolver_->expects_pac_bytes(),
+        config_,
+        wait_delay_,
+        proxy_resolver_->expects_pac_bytes(),
         base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)));
   }
 
   int DoDecideProxyScriptComplete(int result) {
     if (result != OK)
       return result;
 
     effective_config_ = decider_->effective_config();
     script_data_ = decider_->script_data();
 
     next_state_ = STATE_SET_PAC_SCRIPT;
     return OK;
   }
 
   int DoSetPacScript() {
     DCHECK(script_data_.get());
     // TODO(eroman): Should log this latency to the NetLog.
     next_state_ = STATE_SET_PAC_SCRIPT_COMPLETE;
     return proxy_resolver_->SetPacScript(
         script_data_,
         base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)));
   }
 
-  int DoSetPacScriptComplete(int result) {
-    return result;
-  }
+  int DoSetPacScriptComplete(int result) { return result; }
 
   void OnIOCompletion(int result) {
     DCHECK_NE(STATE_NONE, next_state_);
     int rv = DoLoop(result);
     if (rv != ERR_IO_PENDING)
       DoCallback(rv);
   }
 
   void DoCallback(int result) {
     DCHECK_NE(ERR_IO_PENDING, result);
@@ skipping 14 matching lines @@
 };
 
 // ProxyService::ProxyScriptDeciderPoller -------------------------------------
 
 // This helper class encapsulates the logic to schedule and run periodic
 // background checks to see if the PAC script (or effective proxy configuration)
 // has changed. If a change is detected, then the caller will be notified via
 // the ChangeCallback.
 class ProxyService::ProxyScriptDeciderPoller {
  public:
-  typedef base::Callback<void(int, ProxyResolverScriptData*,
-                              const ProxyConfig&)> ChangeCallback;
+  typedef base::Callback<
+      void(int, ProxyResolverScriptData*, const ProxyConfig&)> ChangeCallback;
 
   // Builds a poller helper, and starts polling for updates. Whenever a change
   // is observed, |callback| will be invoked with the details.
   //
   //   |config| specifies the (unresolved) proxy configuration to poll.
   //   |proxy_resolver_expects_pac_bytes| the type of proxy resolver we expect
   //                                      to use the resulting script data with
   //                                      (so it can choose the right format).
   //   |proxy_script_fetcher| this pointer must remain alive throughout our
   //                          lifetime. It is the dependency that will be used
@@ skipping 84 matching lines @@
 
   void DoPoll() {
     last_poll_time_ = TimeTicks::Now();
 
     // Start the proxy script decider to see if anything has changed.
     // TODO(eroman): Pass a proper NetLog rather than NULL.
     decider_.reset(new ProxyScriptDecider(
         proxy_script_fetcher_, dhcp_proxy_script_fetcher_, NULL));
     decider_->set_quick_check_enabled(quick_check_enabled_);
     int result = decider_->Start(
-        config_, TimeDelta(), proxy_resolver_expects_pac_bytes_,
+        config_,
+        TimeDelta(),
+        proxy_resolver_expects_pac_bytes_,
         base::Bind(&ProxyScriptDeciderPoller::OnProxyScriptDeciderCompleted,
                    base::Unretained(this)));
 
     if (result != ERR_IO_PENDING)
       OnProxyScriptDeciderCompleted(result);
   }
 
   void OnProxyScriptDeciderCompleted(int result) {
     if (HasScriptDataChanged(result, decider_->script_data())) {
       // Something has changed, we must notify the ProxyService so it can
@@ skipping 78 matching lines @@
 
 // static
 const ProxyService::PacPollPolicy*
     ProxyService::ProxyScriptDeciderPoller::poll_policy_ = NULL;
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
-    PacRequest(ProxyService* service,
-               const GURL& url,
-               ProxyInfo* results,
-               const net::CompletionCallback& user_callback,
-               const BoundNetLog& net_log)
+  PacRequest(ProxyService* service,
+             const GURL& url,
+             ProxyInfo* results,
+             const net::CompletionCallback& user_callback,
+             const BoundNetLog& net_log)
       : service_(service),
         user_callback_(user_callback),
         results_(results),
         url_(url),
         resolve_job_(NULL),
         config_id_(ProxyConfig::kInvalidConfigID),
         config_source_(PROXY_CONFIG_SOURCE_UNKNOWN),
         net_log_(net_log) {
     DCHECK(!user_callback.is_null());
   }
 
   // Starts the resolve proxy request.
   int Start() {
     DCHECK(!was_cancelled());
     DCHECK(!is_started());
 
     DCHECK(service_->config_.is_valid());
 
     config_id_ = service_->config_.id();
     config_source_ = service_->config_.source();
     proxy_resolve_start_time_ = TimeTicks::Now();
 
     return resolver()->GetProxyForURL(
-        url_, results_,
+        url_,
+        results_,
         base::Bind(&PacRequest::QueryComplete, base::Unretained(this)),
-        &resolve_job_, net_log_);
+        &resolve_job_,
+        net_log_);
   }
 
   bool is_started() const {
     // Note that !! casts to bool. (VS gives a warning otherwise).
     return !!resolve_job_;
   }
 
   void StartAndCompleteCheckingForSynchronous() {
     int rv = service_->TryToCompleteSynchronously(url_, results_);
     if (rv == ERR_IO_PENDING)
@@ skipping 18 matching lines @@
 
     // Mark as cancelled, to prevent accessing this again later.
     service_ = NULL;
     user_callback_.Reset();
     results_ = NULL;
 
     net_log_.EndEvent(NetLog::TYPE_PROXY_SERVICE);
   }
 
   // Returns true if Cancel() has been called.
-  bool was_cancelled() const {
-    return user_callback_.is_null();
-  }
+  bool was_cancelled() const { return user_callback_.is_null(); }
 
   // Helper to call after ProxyResolver completion (both synchronous and
   // asynchronous). Fixes up the result that is to be returned to user.
   int QueryDidComplete(int result_code) {
     DCHECK(!was_cancelled());
 
     // Note that DidFinishResolvingProxy might modify |results_|.
     int rv = service_->DidFinishResolvingProxy(results_, result_code, net_log_);
 
     // Make a note in the results which configuration was in use at the
@@ skipping 56 matching lines @@
   TimeTicks proxy_resolve_start_time_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            ProxyResolver* resolver,
                            NetLog* net_log)
     : resolver_(resolver),
       next_config_id_(1),
-      current_state_(STATE_NONE) ,
+      current_state_(STATE_NONE),
       net_log_(net_log),
-      stall_proxy_auto_config_delay_(TimeDelta::FromMilliseconds(
-          kDelayAfterNetworkChangesMs)),
+      stall_proxy_auto_config_delay_(
+          TimeDelta::FromMilliseconds(kDelayAfterNetworkChangesMs)),
       quick_check_enabled_(true) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   NetworkChangeNotifier::AddDNSObserver(this);
   ResetConfigService(config_service);
 }
 
 // static
 ProxyService* ProxyService::CreateUsingSystemProxyResolver(
     ProxyConfigService* proxy_config_service,
     size_t num_pac_threads,
@@ skipping 12 matching lines @@
   ProxyResolver* proxy_resolver = new MultiThreadedProxyResolver(
       new ProxyResolverFactoryForSystem(), num_pac_threads);
 
   return new ProxyService(proxy_config_service, proxy_resolver, net_log);
 }
 
 // static
 ProxyService* ProxyService::CreateWithoutProxyResolver(
     ProxyConfigService* proxy_config_service,
     NetLog* net_log) {
-  return new ProxyService(proxy_config_service,
-                          new ProxyResolverNull(),
-                          net_log);
+  return new ProxyService(
+      proxy_config_service, new ProxyResolverNull(), net_log);
 }
 
 // static
 ProxyService* ProxyService::CreateFixed(const ProxyConfig& pc) {
   // TODO(eroman): This isn't quite right, won't work if |pc| specifies
   //               a PAC script.
-  return CreateUsingSystemProxyResolver(new ProxyConfigServiceFixed(pc),
-                                        0, NULL);
+  return CreateUsingSystemProxyResolver(
+      new ProxyConfigServiceFixed(pc), 0, NULL);
 }
 
 // static
 ProxyService* ProxyService::CreateFixed(const std::string& proxy) {
   net::ProxyConfig proxy_config;
   proxy_config.proxy_rules().ParseFromString(proxy);
   return ProxyService::CreateFixed(proxy_config);
 }
 
 // static
 ProxyService* ProxyService::CreateDirect() {
   return CreateDirectWithNetLog(NULL);
 }
 
 ProxyService* ProxyService::CreateDirectWithNetLog(NetLog* net_log) {
   // Use direct connections.
-  return new ProxyService(new ProxyConfigServiceDirect, new ProxyResolverNull,
-                          net_log);
+  return new ProxyService(
+      new ProxyConfigServiceDirect, new ProxyResolverNull, net_log);
 }
 
 // static
 ProxyService* ProxyService::CreateFixedFromPacResult(
     const std::string& pac_string) {
-
   // We need the settings to contain an "automatic" setting, otherwise the
   // ProxyResolver dependency we give it will never be used.
   scoped_ptr<ProxyConfigService> proxy_config_service(
       new ProxyConfigServiceFixed(ProxyConfig::CreateAutoDetect()));
 
   scoped_ptr<ProxyResolver> proxy_resolver(
       new ProxyResolverFromPacString(pac_string));
 
-  return new ProxyService(proxy_config_service.release(),
-                          proxy_resolver.release(),
-                          NULL);
+  return new ProxyService(
+      proxy_config_service.release(), proxy_resolver.release(), NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                ProxyInfo* result,
                                const net::CompletionCallback& callback,
                                PacRequest** pac_request,
                                const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   net_log.BeginEvent(NetLog::TYPE_PROXY_SERVICE);
 
   // Notify our polling-based dependencies that a resolve is taking place.
   // This way they can schedule their polls in response to network activity.
   config_service_->OnLazyPoll();
   if (script_poller_.get())
-     script_poller_->OnLazyPoll();
+    script_poller_->OnLazyPoll();
 
   if (current_state_ == STATE_NONE)
     ApplyProxyConfigIfAvailable();
 
   // Strip away any reference fragments and the username/password, as they
   // are not relevant to proxy resolution.
   GURL url = SimplifyUrlForRequest(raw_url);
 
   // Check if the request can be completed right away. (This is the case when
   // using a direct connection for example).
@@ skipping 205 matching lines @@
 
   // We don't have new proxy settings to try, try to fallback to the next proxy
   // in the list.
   bool did_fallback = result->Fallback(net_log);
 
   // Return synchronous failure if there is nothing left to fall-back to.
   // TODO(eroman): This is a yucky API, clean it up.
   return did_fallback ? OK : ERR_FAILED;
 }
 
-bool ProxyService::MarkProxiesAsBadUntil(
-    const ProxyInfo& result,
-    base::TimeDelta retry_delay,
-    const ProxyServer& another_bad_proxy,
-    const BoundNetLog& net_log) {
-  result.proxy_list_.UpdateRetryInfoOnFallback(&proxy_retry_info_, retry_delay,
-                                               false,
-                                               another_bad_proxy,
-                                               net_log);
+bool ProxyService::MarkProxiesAsBadUntil(const ProxyInfo& result,
+                                         base::TimeDelta retry_delay,
+                                         const ProxyServer& another_bad_proxy,
+                                         const BoundNetLog& net_log) {
+  result.proxy_list_.UpdateRetryInfoOnFallback(
+      &proxy_retry_info_, retry_delay, false, another_bad_proxy, net_log);
   if (another_bad_proxy.is_valid())
     return result.proxy_list_.size() > 2;
   else
     return result.proxy_list_.size() > 1;
 }
 
 void ProxyService::ReportSuccess(const ProxyInfo& result) {
   DCHECK(CalledOnValidThread());
 
   const ProxyRetryInfoMap& new_retry_info = result.proxy_retry_info();
   if (new_retry_info.empty())
     return;
 
   for (ProxyRetryInfoMap::const_iterator iter = new_retry_info.begin();
-       iter != new_retry_info.end(); ++iter) {
+       iter != new_retry_info.end();
+       ++iter) {
     ProxyRetryInfoMap::iterator existing = proxy_retry_info_.find(iter->first);
     if (existing == proxy_retry_info_.end())
       proxy_retry_info_[iter->first] = iter->second;
     else if (existing->second.bad_until < iter->second.bad_until)
       existing->second.bad_until = iter->second.bad_until;
   }
   if (net_log_) {
     net_log_->AddGlobalEntry(
         NetLog::TYPE_BAD_PROXY_LIST_REPORTED,
         base::Bind(&NetLogBadProxyListCallback, &new_retry_info));
   }
 }
 
 void ProxyService::CancelPacRequest(PacRequest* req) {
   DCHECK(CalledOnValidThread());
   DCHECK(req);
   req->Cancel();
   RemovePendingRequest(req);
 }
 
 LoadState ProxyService::GetLoadState(const PacRequest* req) const {
   CHECK(req);
   if (current_state_ == STATE_WAITING_FOR_INIT_PROXY_RESOLVER)
     return init_proxy_resolver_->GetLoadState();
   return req->GetLoadState();
 }
 
 bool ProxyService::ContainsPendingRequest(PacRequest* req) {
-  PendingRequests::iterator it = std::find(
-      pending_requests_.begin(), pending_requests_.end(), req);
+  PendingRequests::iterator it =
+      std::find(pending_requests_.begin(), pending_requests_.end(), req);
   return pending_requests_.end() != it;
 }
 
 void ProxyService::RemovePendingRequest(PacRequest* req) {
   DCHECK(ContainsPendingRequest(req));
-  PendingRequests::iterator it = std::find(
-      pending_requests_.begin(), pending_requests_.end(), req);
+  PendingRequests::iterator it =
+      std::find(pending_requests_.begin(), pending_requests_.end(), req);
   pending_requests_.erase(it);
 }
 
 int ProxyService::DidFinishResolvingProxy(ProxyInfo* result,
                                           int result_code,
                                           const BoundNetLog& net_log) {
   // Log the result of the proxy resolution.
   if (result_code == OK) {
     // When logging all events is enabled, dump the proxy list.
     if (net_log.IsLogging()) {
@@ skipping 90 matching lines @@
 #elif defined(OS_IOS)
   return new ProxyConfigServiceIOS();
 #elif defined(OS_MACOSX)
   return new ProxyConfigServiceMac(io_thread_task_runner);
 #elif defined(OS_CHROMEOS)
   LOG(ERROR) << "ProxyConfigService for ChromeOS should be created in "
              << "profile_io_data.cc::CreateProxyConfigService and this should "
              << "be used only for examples.";
   return new UnsetProxyConfigService;
 #elif defined(OS_LINUX)
-  ProxyConfigServiceLinux* linux_config_service =
-      new ProxyConfigServiceLinux();
+  ProxyConfigServiceLinux* linux_config_service = new ProxyConfigServiceLinux();
 
   // Assume we got called on the thread that runs the default glib
   // main loop, so the current thread is where we should be running
   // gconf calls from.
   scoped_refptr<base::SingleThreadTaskRunner> glib_thread_task_runner =
       base::ThreadTaskRunnerHandle::Get();
 
   // The file loop should be a MessageLoopForIO on Linux.
   DCHECK_EQ(base::MessageLoop::TYPE_IO, file_loop->type());
 
@@ skipping 19 matching lines @@
 }
 
 // static
 const ProxyService::PacPollPolicy* ProxyService::set_pac_script_poll_policy(
     const PacPollPolicy* policy) {
   return ProxyScriptDeciderPoller::set_policy(policy);
 }
 
 // static
 scoped_ptr<ProxyService::PacPollPolicy>
-  ProxyService::CreateDefaultPacPollPolicy() {
+ProxyService::CreateDefaultPacPollPolicy() {
   return scoped_ptr<PacPollPolicy>(new DefaultPollPolicy());
 }
 
 #if defined(SPDY_PROXY_AUTH_ORIGIN)
 void ProxyService::RecordDataReductionProxyBypassInfo(
     bool is_primary,
     const ProxyServer& proxy_server,
     DataReductionProxyBypassEventType bypass_type) const {
   // Only record UMA if the proxy isn't already on the retry list.
   if (proxy_retry_info_.find(proxy_server.ToURI()) != proxy_retry_info_.end())
     return;
 
   if (is_primary) {
     UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.BypassInfoPrimary",
-                              bypass_type, BYPASS_EVENT_TYPE_MAX);
+                              bypass_type,
+                              BYPASS_EVENT_TYPE_MAX);
   } else {
     UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.BypassInfoFallback",
-                              bypass_type, BYPASS_EVENT_TYPE_MAX);
+                              bypass_type,
+                              BYPASS_EVENT_TYPE_MAX);
   }
 }
 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 
 void ProxyService::OnProxyConfigChanged(
     const ProxyConfig& config,
     ProxyConfigService::ConfigAvailability availability) {
   // Retrieve the current proxy configuration from the ProxyConfigService.
   // If a configuration is not available yet, we will get called back later
   // by our ProxyConfigService::Observer once it changes.
   ProxyConfig effective_config;
   switch (availability) {
     case ProxyConfigService::CONFIG_PENDING:
       // ProxyConfigService implementors should never pass CONFIG_PENDING.
       NOTREACHED() << "Proxy config change with CONFIG_PENDING availability!";
       return;
     case ProxyConfigService::CONFIG_VALID:
       effective_config = config;
       break;
     case ProxyConfigService::CONFIG_UNSET:
       effective_config = ProxyConfig::CreateDirect();
       break;
   }
 
   // Emit the proxy settings change to the NetLog stream.
   if (net_log_) {
-    net_log_->AddGlobalEntry(
-        net::NetLog::TYPE_PROXY_CONFIG_CHANGED,
-        base::Bind(&NetLogProxyConfigChangedCallback,
-                   &fetched_config_, &effective_config));
+    net_log_->AddGlobalEntry(net::NetLog::TYPE_PROXY_CONFIG_CHANGED,
+                             base::Bind(&NetLogProxyConfigChangedCallback,
+                                        &fetched_config_,
+                                        &effective_config));
   }
 
   // Set the new configuration as the most recently fetched one.
   fetched_config_ = effective_config;
   fetched_config_.set_id(1);  // Needed for a later DCHECK of is_valid().
 
   InitializeUsingLastFetchedConfig();
 }
 
 void ProxyService::InitializeUsingLastFetchedConfig() {
   ResetProxyConfig(false);
 
   DCHECK(fetched_config_.is_valid());
 
   // Increment the ID to reflect that the config has changed.
   fetched_config_.set_id(next_config_id_++);
 
   if (!fetched_config_.HasAutomaticSettings()) {
     config_ = fetched_config_;
     SetReady();
     return;
   }
 
   // Start downloading + testing the PAC scripts for this new configuration.
   current_state_ = STATE_WAITING_FOR_INIT_PROXY_RESOLVER;
 
   // If we changed networks recently, we should delay running proxy auto-config.
-  TimeDelta wait_delay =
-      stall_proxy_autoconfig_until_ - TimeTicks::Now();
+  TimeDelta wait_delay = stall_proxy_autoconfig_until_ - TimeTicks::Now();
 
   init_proxy_resolver_.reset(new InitProxyResolver());
   init_proxy_resolver_->set_quick_check_enabled(quick_check_enabled_);
   int rv = init_proxy_resolver_->Start(
       resolver_.get(),
       proxy_script_fetcher_.get(),
       dhcp_proxy_script_fetcher_.get(),
       net_log_,
       fetched_config_,
       wait_delay,
@@ skipping 53 matching lines @@
   DCHECK(io_message_loop_ != base::MessageLoop::current());
 }
 
 int SyncProxyServiceHelper::ResolveProxy(const GURL& url,
                                          ProxyInfo* proxy_info,
                                          const BoundNetLog& net_log) {
   DCHECK(io_message_loop_ != base::MessageLoop::current());
 
   io_message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncProxyServiceHelper::StartAsyncResolve, this, url,
-                 net_log));
+      base::Bind(
+          &SyncProxyServiceHelper::StartAsyncResolve, this, url, net_log));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
 int SyncProxyServiceHelper::ReconsiderProxyAfterError(
-    const GURL& url, ProxyInfo* proxy_info, const BoundNetLog& net_log) {
+    const GURL& url,
+    ProxyInfo* proxy_info,
+    const BoundNetLog& net_log) {
   DCHECK(io_message_loop_ != base::MessageLoop::current());
 
   io_message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncProxyServiceHelper::StartAsyncReconsider, this, url,
-                 net_log));
+      base::Bind(
+          &SyncProxyServiceHelper::StartAsyncReconsider, this, url, net_log));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
-SyncProxyServiceHelper::~SyncProxyServiceHelper() {}
+SyncProxyServiceHelper::~SyncProxyServiceHelper() {
+}
 
 void SyncProxyServiceHelper::StartAsyncResolve(const GURL& url,
                                                const BoundNetLog& net_log) {
-  result_ = proxy_service_->ResolveProxy(
-      url, &proxy_info_, callback_, NULL, net_log);
+  result_ =
+      proxy_service_->ResolveProxy(url, &proxy_info_, callback_, NULL, net_log);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::StartAsyncReconsider(const GURL& url,
                                                   const BoundNetLog& net_log) {
   result_ = proxy_service_->ReconsiderProxyAfterError(
       url, &proxy_info_, callback_, NULL, net_log);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net