Clang format slam.

net/proxy/proxy_service_unittest.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 <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 17 matching lines @@
 // TODO(eroman): Write a test which exercises
 //              ProxyService::SuspendAllPendingRequests().
 namespace net {
 namespace {
 
 // This polling policy will decide to poll every 1 ms.
 class ImmediatePollPolicy : public ProxyService::PacPollPolicy {
  public:
   ImmediatePollPolicy() {}
 
-  virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
+  virtual Mode GetNextDelay(int error,
+                            base::TimeDelta current_delay,
                             base::TimeDelta* next_delay) const OVERRIDE {
     *next_delay = base::TimeDelta::FromMilliseconds(1);
     return MODE_USE_TIMER;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImmediatePollPolicy);
 };
 
 // This polling policy chooses a fantastically large delay. In other words, it
 // will never trigger a poll
 class NeverPollPolicy : public ProxyService::PacPollPolicy {
  public:
   NeverPollPolicy() {}
 
-  virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
+  virtual Mode GetNextDelay(int error,
+                            base::TimeDelta current_delay,
                             base::TimeDelta* next_delay) const OVERRIDE {
     *next_delay = base::TimeDelta::FromDays(60);
     return MODE_USE_TIMER;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NeverPollPolicy);
 };
 
 // This polling policy starts a poll immediately after network activity.
 class ImmediateAfterActivityPollPolicy : public ProxyService::PacPollPolicy {
  public:
   ImmediateAfterActivityPollPolicy() {}
 
-  virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
+  virtual Mode GetNextDelay(int error,
+                            base::TimeDelta current_delay,
                             base::TimeDelta* next_delay) const OVERRIDE {
     *next_delay = base::TimeDelta();
     return MODE_START_AFTER_ACTIVITY;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImmediateAfterActivityPollPolicy);
 };
 
 // This test fixture is used to partially disable the background polling done by
@@ skipping 26 matching lines @@
   }
 
  private:
   NeverPollPolicy never_poll_policy_;
   const ProxyService::PacPollPolicy* previous_policy_;
 };
 
 const char kValidPacScript1[] = "pac-script-v1-FindProxyForURL";
 const char kValidPacScript2[] = "pac-script-v2-FindProxyForURL";
 
-class MockProxyConfigService: public ProxyConfigService {
+class MockProxyConfigService : public ProxyConfigService {
  public:
   explicit MockProxyConfigService(const ProxyConfig& config)
-      : availability_(CONFIG_VALID),
-        config_(config) {
-  }
+      : availability_(CONFIG_VALID), config_(config) {}
 
   explicit MockProxyConfigService(const std::string& pac_url)
       : availability_(CONFIG_VALID),
-        config_(ProxyConfig::CreateFromCustomPacURL(GURL(pac_url))) {
-  }
+        config_(ProxyConfig::CreateFromCustomPacURL(GURL(pac_url))) {}
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* results)
-      OVERRIDE {
+  virtual ConfigAvailability GetLatestProxyConfig(
+      ProxyConfig* results) OVERRIDE {
     if (availability_ == CONFIG_VALID)
       *results = config_;
     return availability_;
   }
 
   void SetConfig(const ProxyConfig& config) {
     availability_ = CONFIG_VALID;
     config_ = config;
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnProxyConfigChanged(config_, availability_));
+    FOR_EACH_OBSERVER(
+        Observer, observers_, OnProxyConfigChanged(config_, availability_));
   }
 
  private:
   ConfigAvailability availability_;
   ProxyConfig config_;
   ObserverList<Observer, true> observers_;
 };
 
 }  // namespace
 
 TEST_F(ProxyServiceTest, Direct) {
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
-  ProxyService service(new MockProxyConfigService(
-          ProxyConfig::CreateDirect()), resolver, NULL);
+  ProxyService service(
+      new MockProxyConfigService(ProxyConfig::CreateDirect()), resolver, NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   CapturingBoundNetLog log;
-  int rv = service.ResolveProxy(
-      url, &info, callback.callback(), NULL, log.bound());
+  int rv =
+      service.ResolveProxy(url, &info, callback.callback(), NULL, log.bound());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   EXPECT_TRUE(info.is_direct());
   EXPECT_TRUE(info.proxy_resolve_start_time().is_null());
   EXPECT_TRUE(info.proxy_resolve_end_time().is_null());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 0, NetLog::TYPE_PROXY_SERVICE));
-  EXPECT_TRUE(LogContainsEvent(
-      entries, 1, NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
-      NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      entries, 2, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsEvent(entries,
+                               1,
+                               NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
+                               NetLog::PHASE_NONE));
+  EXPECT_TRUE(LogContainsEndEvent(entries, 2, NetLog::TYPE_PROXY_SERVICE));
 }
 
 TEST_F(ProxyServiceTest, PAC) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
@@ skipping 28 matching lines @@
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(5u, entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 0, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
-  EXPECT_TRUE(LogContainsEndEvent(
-      entries, 4, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsEndEvent(entries, 4, NetLog::TYPE_PROXY_SERVICE));
 }
 
 // Test that the proxy resolver does not see the URL's username/password
 // or its reference section.
 TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   GURL url("http://username:password@www.google.com/?ref#hash#hash");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(
       url, &info, callback.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             resolver->pending_set_pac_script_request()->script_data()->url());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   // The URL should have been simplified, stripping the username/password/hash.
   EXPECT_EQ(GURL("http://www.google.com/?ref"),
-                 resolver->pending_requests()[0]->url());
+            resolver->pending_requests()[0]->url());
 
   // We end here without ever completing the request -- destruction of
   // ProxyService will cancel the outstanding request.
 }
 
 TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
@@ skipping 120 matching lines @@
   // Set the result in proxy resolver.
   resolver->pending_requests()[0]->results()->UsePacString(
       "DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info.is_direct());
 
   // Fallback 1.
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foobar:10", info.proxy_server().ToURI());
 
   // Fallback 2.
   TestCompletionCallback callback3;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback3.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info.is_direct());
 
   // Fallback 3.
   TestCompletionCallback callback4;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback4.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foobar:20", info.proxy_server().ToURI());
 
   // Fallback 4 -- Nothing to fall back to!
   TestCompletionCallback callback5;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback5.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback5.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_FAILED, rv);
   EXPECT_TRUE(info.is_empty());
 }
 
 TEST_F(ProxyServiceTest, PAC_ConfigSourcePropagates) {
   // Test whether the ProxyConfigSource set by the ProxyConfigService is applied
   // to ProxyInfo after the proxy is resolved via a PAC script.
   ProxyConfig config =
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
   config.set_source(PROXY_CONFIG_SOURCE_TEST);
@@ skipping 163 matching lines @@
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
 
   EXPECT_FALSE(fetcher->has_pending_request());
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // Since ProxyScriptDecider failed to identify a valid PAC and PAC was
   // mandatory for this configuration, the ProxyService must not implicitly
   // fall-back to DIRECT.
-  EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
-            callback.WaitForResult());
+  EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(info.is_direct());
 }
 
 TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
   // Test what happens when the ProxyResolver fails that is configured to use a
   // mandatory PAC script. The download and setting of the PAC script have
   // already succeeded, so this corresponds with a javascript runtime error
   // while calling FindProxyForURL().
 
   ProxyConfig config(
@@ skipping 88 matching lines @@
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
   base::TimeTicks proxy_resolve_start_time = info.proxy_resolve_start_time();
   base::TimeTicks proxy_resolve_end_time = info.proxy_resolve_end_time();
 
   // Fake an error on the proxy.
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // Proxy times should not have been modified by fallback.
   EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
   EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
 
   // The second proxy should be specified.
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
   // Report back that the second proxy worked.  This will globally mark the
   // first proxy as bad.
@@ skipping 20 matching lines @@
   // Proxy times should have been updated, so get them again.
   EXPECT_LE(proxy_resolve_end_time, info.proxy_resolve_start_time());
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
   proxy_resolve_start_time = info.proxy_resolve_start_time();
   proxy_resolve_end_time = info.proxy_resolve_end_time();
 
   // We fake another error. It should now try the third one.
   TestCompletionCallback callback4;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback4.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // We fake another error. At this point we have tried all of the
   // proxy servers we thought were valid; next we try the proxy server
   // that was in our bad proxies map (foopy1:8080).
   TestCompletionCallback callback5;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback5.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback5.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake another error, the last proxy is gone, the list should now be empty,
   // so there is nothing left to try.
   TestCompletionCallback callback6;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback6.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback6.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_FAILED, rv);
   EXPECT_FALSE(info.is_direct());
   EXPECT_TRUE(info.is_empty());
 
   // Proxy times should not have been modified by fallback.
   EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
   EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
 
   // Look up proxies again
   TestCompletionCallback callback7;
-  rv = service.ResolveProxy(url, &info, callback7.callback(), NULL,
-                            BoundNetLog());
+  rv = service.ResolveProxy(
+      url, &info, callback7.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // This time, the first 3 results have been found to be bad, but only the
   // first proxy has been confirmed ...
   resolver->pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy3:7070;foopy2:9090;foopy4:9091");
   resolver->pending_requests()[0]->CompleteNow(OK);
@@ skipping 40 matching lines @@
       "PROXY foopy1:8080; PROXY foopy2:9090; DIRECT");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // Get the first result.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy.
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // Now we get back the second proxy.
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Fake an error on this proxy as well.
   TestCompletionCallback callback3;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback3.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // Finally, we get back DIRECT.
   EXPECT_TRUE(info.is_direct());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // Now we tell the proxy service that even DIRECT failed.
   TestCompletionCallback callback4;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback4.callback(), NULL, BoundNetLog());
   // There was nothing left to try after DIRECT, so we are out of
   // choices.
   EXPECT_EQ(ERR_FAILED, rv);
 }
 
 TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
   // Test proxy failover when new settings are available.
 
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
@@ skipping 26 matching lines @@
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy, and also a new configuration on the proxy.
   config_service->SetConfig(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy-new/proxy.pac")));
 
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy-new/proxy.pac"),
             resolver->pending_set_pac_script_request()->script_data()->url());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   resolver->pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is still there since the configuration changed.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // We fake another error. It should now ignore the first one.
   TestCompletionCallback callback3;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback3.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback3.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // We simulate a new configuration.
   config_service->SetConfig(
-      ProxyConfig::CreateFromCustomPacURL(
-          GURL("http://foopy-new2/proxy.pac")));
+      ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy-new2/proxy.pac")));
 
   // We fake another error. It should go back to the first proxy.
   TestCompletionCallback callback4;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback4.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy-new2/proxy.pac"),
             resolver->pending_set_pac_script_request()->script_data()->url());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   resolver->pending_requests()[0]->results()->UseNamedProxy(
@@ skipping 37 matching lines @@
       "foopy1:8080;foopy2:9090");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // The first proxy is ignored, and the second one is selected.
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Fake a PAC failure.
   ProxyInfo info2;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(
@@ skipping 10 matching lines @@
   // to a DIRECT connection.
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_TRUE(info2.is_direct());
   EXPECT_FALSE(info2.is_empty());
 
   // The PAC script will work properly next time and successfully return a
   // proxy list. Since we have not marked the configuration as bad, it should
   // "just work" the next time we call it.
   ProxyInfo info3;
   TestCompletionCallback callback4;
-  rv = service.ReconsiderProxyAfterError(url, &info3, callback4.callback(),
-                                         NULL, BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info3, callback4.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   resolver->pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is not there since the it was added to the bad proxies
@@ skipping 39 matching lines @@
       "foopy1:8080;foopy2:9090");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   TestCompletionCallback callback2;
-  rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
-                                         BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info, callback2.callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // The first proxy is ignored, and the second one is selected.
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Fake a PAC failure.
   ProxyInfo info2;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(
@@ skipping 11 matching lines @@
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
             callback3.WaitForResult());
   EXPECT_FALSE(info2.is_direct());
   EXPECT_TRUE(info2.is_empty());
 
   // The PAC script will work properly next time and successfully return a
   // proxy list. Since we have not marked the configuration as bad, it should
   // "just work" the next time we call it.
   ProxyInfo info3;
   TestCompletionCallback callback4;
-  rv = service.ReconsiderProxyAfterError(url, &info3, callback4.callback(),
-                                         NULL, BoundNetLog());
+  rv = service.ReconsiderProxyAfterError(
+      url, &info3, callback4.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   resolver->pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is not there since the it was added to the bad proxies
@@ skipping 26 matching lines @@
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info[0].is_direct());
 
   // Request for a .com domain hits the proxy.
   rv = service.ResolveProxy(
       url2, &info[1], callback[1].callback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy1:8080", info[1].proxy_server().ToURI());
 }
 
-
 TEST_F(ProxyServiceTest, PerProtocolProxyTests) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("http=foopy1:8080;https=foopy2:8080");
   config.set_auto_detect(false);
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(info.is_direct());
     EXPECT_EQ("direct://", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
   }
   {
     config.proxy_rules().ParseFromString("foopy1:8080");
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.microsoft.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
 }
 
 TEST_F(ProxyServiceTest, ProxyConfigSourcePropagates) {
   // Test that the proxy config source is set correctly when resolving proxies
   // using manual proxy rules. Namely, the config source should only be set if
   // any of the rules were applied.
   {
     ProxyConfig config;
     config.set_source(PROXY_CONFIG_SOURCE_TEST);
     config.proxy_rules().ParseFromString("https=foopy2:8080");
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     ASSERT_EQ(OK, rv);
     // Should be SOURCE_TEST, even if there are no HTTP proxies configured.
     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   }
   {
     ProxyConfig config;
     config.set_source(PROXY_CONFIG_SOURCE_TEST);
     config.proxy_rules().ParseFromString("https=foopy2:8080");
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("https://www.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     ASSERT_EQ(OK, rv);
     // Used the HTTPS proxy. So source should be TEST.
     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   }
   {
     ProxyConfig config;
     config.set_source(PROXY_CONFIG_SOURCE_TEST);
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     ASSERT_EQ(OK, rv);
     // ProxyConfig is empty. Source should still be TEST.
     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   }
 }
 
 // If only HTTP and a SOCKS proxy are specified, check if ftp/https queries
 // fall back to the SOCKS proxy.
 TEST_F(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("http=foopy1:8080;socks=foopy2:1080");
   config.set_auto_detect(false);
   EXPECT_EQ(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
             config.proxy_rules().type);
 
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
   {
     ProxyService service(
         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
     GURL test_url("unknown://www.microsoft.com");
     ProxyInfo info;
     TestCompletionCallback callback;
-    int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
-                                  BoundNetLog());
+    int rv = service.ResolveProxy(
+        test_url, &info, callback.callback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, rv);
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   }
 }
 
 // Test cancellation of an in-progress request.
 TEST_F(ProxyServiceTest, CancelInProgressRequest) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
 
   ProxyService service(config_service, resolver, NULL);
 
   // Start 3 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Nothing has been sent to the proxy resolver yet, since the proxy
   // resolver has not been configured yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // Successfully initialize the PAC script.
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             resolver->pending_set_pac_script_request()->script_data()->url());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            &request2,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   ASSERT_EQ(2u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
-  rv = service.ResolveProxy(GURL("http://request3"), &info3,
-                            callback3.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request3"),
+                            &info3,
+                            callback3.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   ASSERT_EQ(3u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[2]->url());
 
   // Cancel the second request
   service.CancelPacRequest(request2);
 
   ASSERT_EQ(2u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[1]->url());
@@ skipping 30 matching lines @@
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   ProxyService::PacRequest* request1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), &request1, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                &request1,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            &request2,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
   ProxyService::PacRequest* request3;
-  rv = service.ResolveProxy(GURL("http://request3"), &info3,
-                            callback3.callback(), &request3, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request3"),
+                            &info3,
+                            callback3.callback(),
+                            &request3,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
             service.GetLoadState(request1));
   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
             service.GetLoadState(request2));
   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
@@ skipping 62 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
 
   // We now change out the ProxyService's script fetcher. We should restart
   // the initialization with the new fetcher.
 
   fetcher = new MockProxyScriptFetcher;
@@ skipping 28 matching lines @@
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
   ProxyInfo info1;
   TestCompletionCallback callback1;
   ProxyService::PacRequest* request1;
   CapturingBoundNetLog log1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), &request1, log1.bound());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                &request1,
+                                log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            &request2,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
-  rv = service.ResolveProxy(GURL("http://request3"), &info3,
-                            callback3.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request3"),
+                            &info3,
+                            callback3.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // Cancel the first 2 requests.
   service.CancelPacRequest(request1);
   service.CancelPacRequest(request2);
 
   // At this point the ProxyService should be waiting for the
@@ skipping 20 matching lines @@
   EXPECT_TRUE(resolver->cancelled_requests().empty());
 
   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
 
   CapturingNetLog::CapturedEntryList entries1;
   log1.GetEntries(&entries1);
 
   // Check the NetLog for request 1 (which was cancelled) got filled properly.
   EXPECT_EQ(4u, entries1.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      entries1, 0, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsBeginEvent(entries1, 0, NetLog::TYPE_PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries1, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   // Note that TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC is never completed before
   // the cancellation occured.
   EXPECT_TRUE(LogContainsEvent(
       entries1, 2, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      entries1, 3, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsEndEvent(entries1, 3, NetLog::TYPE_PROXY_SERVICE));
 }
 
 // Test that if auto-detect fails, we fall-back to the custom pac.
 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");  // Won't be used.
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            &request2,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that nothing has been sent to the proxy resolver yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // It should be trying to auto-detect first -- FAIL the autodetect during
   // the script download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
@@ skipping 48 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            &request2,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that nothing has been sent to the proxy resolver yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // It should be trying to auto-detect first -- succeed the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
 
@@ skipping 44 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), &request2, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            &request2,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that nothing has been sent to the proxy resolver yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // It should be trying to auto-detect first -- fail the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
@@ skipping 29 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://www.google.com"), &info1, callback1.callback(), NULL,
-      BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://www.google.com"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that nothing has been sent to the proxy resolver yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // It should be trying to auto-detect first -- succeed the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             resolver->pending_set_pac_script_request()->script_data()->utf16());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://www.google.com"),
             resolver->pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Start another request, it should pickup the bypass item.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(GURL("http://www.google.com"), &info2,
-                            callback2.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://www.google.com"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://www.google.com"),
             resolver->pending_requests()[0]->url());
 
   // Complete the pending request.
   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 }
 
 // Delete the ProxyService while InitProxyResolver has an outstanding
 // request to the script fetcher. When run under valgrind, should not
 // have any memory errors (used to be that the ProxyScriptFetcher was
 // being deleted prior to the InitProxyResolver).
 TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
   ProxyConfig config =
-    ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
+      ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://www.google.com"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://www.google.com"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that nothing has been sent to the proxy resolver yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // InitProxyResolver should have issued a request to the ProxyScriptFetcher
   // and be waiting on that to complete.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 }
@@ skipping 19 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             resolver->pending_set_pac_script_request()->script_data()->url());
 }
 
 TEST_F(ProxyServiceTest, ResetProxyConfigService) {
   ProxyConfig config1;
   config1.proxy_rules().ParseFromString("foopy1:8080");
   config1.set_auto_detect(false);
-  ProxyService service(
-      new MockProxyConfigService(config1),
-      new MockAsyncProxyResolverExpectsBytes, NULL);
+  ProxyService service(new MockProxyConfigService(config1),
+                       new MockAsyncProxyResolverExpectsBytes,
+                       NULL);
 
   ProxyInfo info;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   ProxyConfig config2;
   config2.proxy_rules().ParseFromString("foopy2:8080");
   config2.set_auto_detect(false);
   service.ResetConfigService(new MockProxyConfigService(config2));
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info,
-                            callback2.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
 }
 
 // Test that when going from a configuration that required PAC to one
 // that does NOT, we unset the variable |should_use_proxy_resolver_|.
 TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   ProxyConfig config = ProxyConfig::CreateAutoDetect();
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   ProxyService service(config_service, resolver, NULL);
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://www.google.com"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://www.google.com"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that nothing has been sent to the proxy resolver yet.
   ASSERT_EQ(0u, resolver->pending_requests().size());
 
   // Successfully set the autodetect script.
   EXPECT_EQ(ProxyResolverScriptData::TYPE_AUTO_DETECT,
             resolver->pending_set_pac_script_request()->script_data()->type());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   // Complete the pending request.
   ASSERT_EQ(1u, resolver->pending_requests().size());
   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Force the ProxyService to pull down a new proxy configuration.
   // (Even though the configuration isn't old/bad).
   //
   // This new configuration no longer has auto_detect set, so
   // requests should complete synchronously now as direct-connect.
   config_service->SetConfig(ProxyConfig::CreateDirect());
 
   // Start another request -- the effective configuration has changed.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(GURL("http://www.google.com"), &info2,
-                            callback2.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://www.google.com"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(info2.is_direct());
 }
 
 TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes* resolver =
       new MockAsyncProxyResolverExpectsBytes;
 
   CapturingNetLog log;
 
   ProxyService service(config_service, resolver, &log);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Disable the "wait after IP address changes" hack, so this unit-test can
   // complete quickly.
   service.set_stall_proxy_auto_config_delay(base::TimeDelta());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(GURL("http://request1"), &info1,
-                                callback1.callback(), NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 20 matching lines @@
 
   // Now simluate a change in the network. The ProxyConfigService is still
   // going to return the same PAC URL as before, but this URL needs to be
   // refetched on the new network.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(GURL("http://request2"), &info2,
-                            callback2.callback(), NULL, BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // This second request should have triggered the re-download of the PAC
   // script (since we marked the network as having changed).
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
@@ skipping 17 matching lines @@
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 
   // Check that the expected events were output to the log stream. In particular
   // PROXY_CONFIG_CHANGED should have only been emitted once (for the initial
   // setup), and NOT a second time when the IP address changed.
   CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
-  EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
-                                       NetLog::TYPE_PROXY_CONFIG_CHANGED));
+  EXPECT_TRUE(
+      LogContainsEntryWithType(entries, 0, NetLog::TYPE_PROXY_CONFIG_CHANGED));
   ASSERT_EQ(9u, entries.size());
   for (size_t i = 1; i < entries.size(); ++i)
     EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, entries[i].type);
 }
 
 // This test verifies that the PAC script specified by the settings is
 // periodically polled for changes. Specifically, if the initial fetch fails due
 // to a network error, we will eventually re-configure the service to use the
 // script once it becomes available.
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
@@ skipping 11 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, callback1.callback(),
-      NULL, BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 38 matching lines @@
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   // At this point the ProxyService should have re-configured itself to use the
   // PAC script (thereby recovering from the initial fetch failure). We will
   // verify that the next Resolve request uses the resolver rather than
   // DIRECT.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, callback2.callback(), NULL,
-      BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
 
   // Complete the pending second request.
   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
@@ skipping 21 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, callback1.callback(), NULL,
-      BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 43 matching lines @@
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
             resolver->pending_set_pac_script_request()->script_data()->utf16());
   resolver->pending_set_pac_script_request()->CompleteNow(OK);
 
   // At this point the ProxyService should have re-configured itself to use the
   // new PAC script.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, callback2.callback(), NULL,
-      BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
 
   // Complete the pending second request.
   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
@@ skipping 21 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, callback1.callback(), NULL,
-      BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 39 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_FALSE(resolver->has_pending_set_pac_script_request());
 
   // At this point the ProxyService is still running the same PAC script as
   // before.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, callback2.callback(), NULL,
-      BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
 
   // Complete the pending second request.
   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
@@ skipping 21 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, callback1.callback(), NULL,
-      BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 37 matching lines @@
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // At this point the ProxyService should have re-configured itself to use
   // DIRECT connections rather than the given proxy resolver.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, callback2.callback(), NULL,
-      BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info2.is_direct());
 }
 
 // Tests that the code which decides at what times to poll the PAC
 // script follows the expected policy.
 TEST_F(ProxyServiceTest, PACScriptPollingPolicy) {
   // Retrieve the internal polling policy implementation used by ProxyService.
   scoped_ptr<ProxyService::PacPollPolicy> policy =
       ProxyService::CreateDefaultPacPollPolicy();
@@ skipping 69 matching lines @@
   ProxyService service(config_service, resolver, NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
-  int rv = service.ResolveProxy(
-      GURL("http://request1"), &info1, callback1.callback(), NULL,
-      BoundNetLog());
+  int rv = service.ResolveProxy(GURL("http://request1"),
+                                &info1,
+                                callback1.callback(),
+                                NULL,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered initial download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // Nothing has been sent to the resolver yet.
   EXPECT_TRUE(resolver->pending_requests().empty());
 
   // At this point the ProxyService should be waiting for the
@@ skipping 21 matching lines @@
   // At this point we have initialized the proxy service using a PAC script.
   // Our PAC poller is set to update ONLY in response to network activity,
   // (i.e. another call to ResolveProxy()).
 
   ASSERT_FALSE(fetcher->has_pending_request());
   ASSERT_TRUE(resolver->pending_requests().empty());
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
-  rv = service.ResolveProxy(
-      GURL("http://request2"), &info2, callback2.callback(), NULL,
-      BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request2"),
+                            &info2,
+                            callback2.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // This request should have sent work to the resolver; complete it.
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver->pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 
   // In response to getting that resolve request, the poller should have
   // started the next poll, and made it as far as to request the download.
 
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   // This time we will fail the download, to simulate a PAC script change.
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   // Drain the message loop, so ProxyService is notified of the change
   // and has a chance to re-configure itself.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Start a third request -- this time we expect to get a direct connection
   // since the PAC script poller experienced a failure.
   ProxyInfo info3;
   TestCompletionCallback callback3;
-  rv = service.ResolveProxy(
-      GURL("http://request3"), &info3, callback3.callback(), NULL,
-      BoundNetLog());
+  rv = service.ResolveProxy(GURL("http://request3"),
+                            &info3,
+                            callback3.callback(),
+                            NULL,
+                            BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info3.is_direct());
 }
 
 }  // namespace net