Home | History | Annotate | Download | only in proxy 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/proxy/proxy_service.h"
      6 
      7 #include <vector>
      8 
      9 #include "base/format_macros.h"
     10 #include "base/logging.h"
     11 #include "base/strings/string_util.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "net/base/net_errors.h"
     14 #include "net/base/net_log.h"
     15 #include "net/base/net_log_unittest.h"
     16 #include "net/base/test_completion_callback.h"
     17 #include "net/proxy/dhcp_proxy_script_fetcher.h"
     18 #include "net/proxy/mock_proxy_resolver.h"
     19 #include "net/proxy/mock_proxy_script_fetcher.h"
     20 #include "net/proxy/proxy_config_service.h"
     21 #include "net/proxy/proxy_resolver.h"
     22 #include "net/proxy/proxy_script_fetcher.h"
     23 #include "testing/gtest/include/gtest/gtest.h"
     24 #include "url/gurl.h"
     25 
     26 // TODO(eroman): Write a test which exercises
     27 //              ProxyService::SuspendAllPendingRequests().
     28 namespace net {
     29 namespace {
     30 
     31 // This polling policy will decide to poll every 1 ms.
     32 class ImmediatePollPolicy : public ProxyService::PacPollPolicy {
     33  public:
     34   ImmediatePollPolicy() {}
     35 
     36   virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
     37                             base::TimeDelta* next_delay) const OVERRIDE {
     38     *next_delay = base::TimeDelta::FromMilliseconds(1);
     39     return MODE_USE_TIMER;
     40   }
     41 
     42  private:
     43   DISALLOW_COPY_AND_ASSIGN(ImmediatePollPolicy);
     44 };
     45 
     46 // This polling policy chooses a fantastically large delay. In other words, it
     47 // will never trigger a poll
     48 class NeverPollPolicy : public ProxyService::PacPollPolicy {
     49  public:
     50   NeverPollPolicy() {}
     51 
     52   virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
     53                             base::TimeDelta* next_delay) const OVERRIDE {
     54     *next_delay = base::TimeDelta::FromDays(60);
     55     return MODE_USE_TIMER;
     56   }
     57 
     58  private:
     59   DISALLOW_COPY_AND_ASSIGN(NeverPollPolicy);
     60 };
     61 
     62 // This polling policy starts a poll immediately after network activity.
     63 class ImmediateAfterActivityPollPolicy : public ProxyService::PacPollPolicy {
     64  public:
     65   ImmediateAfterActivityPollPolicy() {}
     66 
     67   virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
     68                             base::TimeDelta* next_delay) const OVERRIDE {
     69     *next_delay = base::TimeDelta();
     70     return MODE_START_AFTER_ACTIVITY;
     71   }
     72 
     73  private:
     74   DISALLOW_COPY_AND_ASSIGN(ImmediateAfterActivityPollPolicy);
     75 };
     76 
     77 // This test fixture is used to partially disable the background polling done by
     78 // the ProxyService (which it uses to detect whenever its PAC script contents or
     79 // WPAD results have changed).
     80 //
     81 // We disable the feature by setting the poll interval to something really
     82 // large, so it will never actually be reached even on the slowest bots that run
     83 // these tests.
     84 //
     85 // We disable the polling in order to avoid any timing dependencies in the
     86 // tests. If the bot were to run the tests very slowly and we hadn't disabled
     87 // polling, then it might start a background re-try in the middle of our test
     88 // and confuse our expectations leading to flaky failures.
     89 //
     90 // The tests which verify the polling code re-enable the polling behavior but
     91 // are careful to avoid timing problems.
     92 class ProxyServiceTest : public testing::Test {
     93  protected:
     94   virtual void SetUp() OVERRIDE {
     95     testing::Test::SetUp();
     96     previous_policy_ =
     97         ProxyService::set_pac_script_poll_policy(&never_poll_policy_);
     98   }
     99 
    100   virtual void TearDown() OVERRIDE {
    101     // Restore the original policy.
    102     ProxyService::set_pac_script_poll_policy(previous_policy_);
    103     testing::Test::TearDown();
    104   }
    105 
    106  private:
    107   NeverPollPolicy never_poll_policy_;
    108   const ProxyService::PacPollPolicy* previous_policy_;
    109 };
    110 
    111 const char kValidPacScript1[] = "pac-script-v1-FindProxyForURL";
    112 const char kValidPacScript2[] = "pac-script-v2-FindProxyForURL";
    113 
    114 class MockProxyConfigService: public ProxyConfigService {
    115  public:
    116   explicit MockProxyConfigService(const ProxyConfig& config)
    117       : availability_(CONFIG_VALID),
    118         config_(config) {
    119   }
    120 
    121   explicit MockProxyConfigService(const std::string& pac_url)
    122       : availability_(CONFIG_VALID),
    123         config_(ProxyConfig::CreateFromCustomPacURL(GURL(pac_url))) {
    124   }
    125 
    126   virtual void AddObserver(Observer* observer) OVERRIDE {
    127     observers_.AddObserver(observer);
    128   }
    129 
    130   virtual void RemoveObserver(Observer* observer) OVERRIDE {
    131     observers_.RemoveObserver(observer);
    132   }
    133 
    134   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* results)
    135       OVERRIDE {
    136     if (availability_ == CONFIG_VALID)
    137       *results = config_;
    138     return availability_;
    139   }
    140 
    141   void SetConfig(const ProxyConfig& config) {
    142     availability_ = CONFIG_VALID;
    143     config_ = config;
    144     FOR_EACH_OBSERVER(Observer, observers_,
    145                       OnProxyConfigChanged(config_, availability_));
    146   }
    147 
    148  private:
    149   ConfigAvailability availability_;
    150   ProxyConfig config_;
    151   ObserverList<Observer, true> observers_;
    152 };
    153 
    154 }  // namespace
    155 
    156 TEST_F(ProxyServiceTest, Direct) {
    157   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    158   ProxyService service(new MockProxyConfigService(
    159           ProxyConfig::CreateDirect()), resolver, NULL);
    160 
    161   GURL url("http://www.google.com/");
    162 
    163   ProxyInfo info;
    164   TestCompletionCallback callback;
    165   CapturingBoundNetLog log;
    166   int rv = service.ResolveProxy(
    167       url, &info, callback.callback(), NULL, log.bound());
    168   EXPECT_EQ(OK, rv);
    169   EXPECT_TRUE(resolver->pending_requests().empty());
    170 
    171   EXPECT_TRUE(info.is_direct());
    172   EXPECT_TRUE(info.proxy_resolve_start_time().is_null());
    173   EXPECT_TRUE(info.proxy_resolve_end_time().is_null());
    174 
    175   // Check the NetLog was filled correctly.
    176   CapturingNetLog::CapturedEntryList entries;
    177   log.GetEntries(&entries);
    178 
    179   EXPECT_EQ(3u, entries.size());
    180   EXPECT_TRUE(LogContainsBeginEvent(
    181       entries, 0, NetLog::TYPE_PROXY_SERVICE));
    182   EXPECT_TRUE(LogContainsEvent(
    183       entries, 1, NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
    184       NetLog::PHASE_NONE));
    185   EXPECT_TRUE(LogContainsEndEvent(
    186       entries, 2, NetLog::TYPE_PROXY_SERVICE));
    187 }
    188 
    189 TEST_F(ProxyServiceTest, PAC) {
    190   MockProxyConfigService* config_service =
    191       new MockProxyConfigService("http://foopy/proxy.pac");
    192 
    193   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    194 
    195   ProxyService service(config_service, resolver, NULL);
    196 
    197   GURL url("http://www.google.com/");
    198 
    199   ProxyInfo info;
    200   TestCompletionCallback callback;
    201   ProxyService::PacRequest* request;
    202   CapturingBoundNetLog log;
    203 
    204   int rv = service.ResolveProxy(
    205       url, &info, callback.callback(), &request, log.bound());
    206   EXPECT_EQ(ERR_IO_PENDING, rv);
    207 
    208   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request));
    209 
    210   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    211             resolver->pending_set_pac_script_request()->script_data()->url());
    212   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    213 
    214   ASSERT_EQ(1u, resolver->pending_requests().size());
    215   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    216 
    217   // Set the result in proxy resolver.
    218   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy");
    219   resolver->pending_requests()[0]->CompleteNow(OK);
    220 
    221   EXPECT_EQ(OK, callback.WaitForResult());
    222   EXPECT_FALSE(info.is_direct());
    223   EXPECT_EQ("foopy:80", info.proxy_server().ToURI());
    224   EXPECT_TRUE(info.did_use_pac_script());
    225 
    226   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    227   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    228   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    229 
    230   // Check the NetLog was filled correctly.
    231   CapturingNetLog::CapturedEntryList entries;
    232   log.GetEntries(&entries);
    233 
    234   EXPECT_EQ(5u, entries.size());
    235   EXPECT_TRUE(LogContainsBeginEvent(
    236       entries, 0, NetLog::TYPE_PROXY_SERVICE));
    237   EXPECT_TRUE(LogContainsBeginEvent(
    238       entries, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
    239   EXPECT_TRUE(LogContainsEndEvent(
    240       entries, 2, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
    241   EXPECT_TRUE(LogContainsEndEvent(
    242       entries, 4, NetLog::TYPE_PROXY_SERVICE));
    243 }
    244 
    245 // Test that the proxy resolver does not see the URL's username/password
    246 // or its reference section.
    247 TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
    248   MockProxyConfigService* config_service =
    249       new MockProxyConfigService("http://foopy/proxy.pac");
    250 
    251   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    252 
    253   ProxyService service(config_service, resolver, NULL);
    254 
    255   GURL url("http://username:password@www.google.com/?ref#hash#hash");
    256 
    257   ProxyInfo info;
    258   TestCompletionCallback callback;
    259   int rv = service.ResolveProxy(
    260       url, &info, callback.callback(), NULL, BoundNetLog());
    261   EXPECT_EQ(ERR_IO_PENDING, rv);
    262 
    263   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    264             resolver->pending_set_pac_script_request()->script_data()->url());
    265   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    266 
    267   ASSERT_EQ(1u, resolver->pending_requests().size());
    268   // The URL should have been simplified, stripping the username/password/hash.
    269   EXPECT_EQ(GURL("http://www.google.com/?ref"),
    270                  resolver->pending_requests()[0]->url());
    271 
    272   // We end here without ever completing the request -- destruction of
    273   // ProxyService will cancel the outstanding request.
    274 }
    275 
    276 TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
    277   MockProxyConfigService* config_service =
    278       new MockProxyConfigService("http://foopy/proxy.pac");
    279   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    280 
    281   ProxyService service(config_service, resolver, NULL);
    282 
    283   GURL url("http://www.google.com/");
    284 
    285   ProxyInfo info;
    286   TestCompletionCallback callback1;
    287   int rv = service.ResolveProxy(
    288       url, &info, callback1.callback(), NULL, BoundNetLog());
    289   EXPECT_EQ(ERR_IO_PENDING, rv);
    290 
    291   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    292             resolver->pending_set_pac_script_request()->script_data()->url());
    293   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    294 
    295   ASSERT_EQ(1u, resolver->pending_requests().size());
    296   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    297 
    298   // Set the result in proxy resolver.
    299   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy:8080");
    300   resolver->pending_requests()[0]->CompleteNow(OK);
    301 
    302   EXPECT_EQ(OK, callback1.WaitForResult());
    303   EXPECT_FALSE(info.is_direct());
    304   EXPECT_EQ("foopy:8080", info.proxy_server().ToURI());
    305   EXPECT_TRUE(info.did_use_pac_script());
    306 
    307   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    308   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    309   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    310 
    311   // Now, imagine that connecting to foopy:8080 fails: there is nothing
    312   // left to fallback to, since our proxy list was NOT terminated by
    313   // DIRECT.
    314   TestCompletionCallback callback2;
    315   rv = service.ReconsiderProxyAfterError(
    316       url, &info, callback2.callback(), NULL, BoundNetLog());
    317   // ReconsiderProxyAfterError returns error indicating nothing left.
    318   EXPECT_EQ(ERR_FAILED, rv);
    319   EXPECT_TRUE(info.is_empty());
    320 }
    321 
    322 // Test that if the execution of the PAC script fails (i.e. javascript runtime
    323 // error), and the PAC settings are non-mandatory, that we fall-back to direct.
    324 TEST_F(ProxyServiceTest, PAC_RuntimeError) {
    325   MockProxyConfigService* config_service =
    326       new MockProxyConfigService("http://foopy/proxy.pac");
    327   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    328 
    329   ProxyService service(config_service, resolver, NULL);
    330 
    331   GURL url("http://this-causes-js-error/");
    332 
    333   ProxyInfo info;
    334   TestCompletionCallback callback1;
    335   int rv = service.ResolveProxy(
    336       url, &info, callback1.callback(), NULL, BoundNetLog());
    337   EXPECT_EQ(ERR_IO_PENDING, rv);
    338 
    339   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    340             resolver->pending_set_pac_script_request()->script_data()->url());
    341   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    342 
    343   ASSERT_EQ(1u, resolver->pending_requests().size());
    344   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    345 
    346   // Simulate a failure in the PAC executor.
    347   resolver->pending_requests()[0]->CompleteNow(ERR_PAC_SCRIPT_FAILED);
    348 
    349   EXPECT_EQ(OK, callback1.WaitForResult());
    350 
    351   // Since the PAC script was non-mandatory, we should have fallen-back to
    352   // DIRECT.
    353   EXPECT_TRUE(info.is_direct());
    354   EXPECT_TRUE(info.did_use_pac_script());
    355   EXPECT_EQ(1, info.config_id());
    356 
    357   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    358   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    359   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    360 }
    361 
    362 // The proxy list could potentially contain the DIRECT fallback choice
    363 // in a location other than the very end of the list, and could even
    364 // specify it multiple times.
    365 //
    366 // This is not a typical usage, but we will obey it.
    367 // (If we wanted to disallow this type of input, the right place to
    368 // enforce it would be in parsing the PAC result string).
    369 //
    370 // This test will use the PAC result string:
    371 //
    372 //   "DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20"
    373 //
    374 // For which we expect it to try DIRECT, then foobar:10, then DIRECT again,
    375 // then foobar:20, and then give up and error.
    376 //
    377 // The important check of this test is to make sure that DIRECT is not somehow
    378 // cached as being a bad proxy.
    379 TEST_F(ProxyServiceTest, PAC_FailoverAfterDirect) {
    380   MockProxyConfigService* config_service =
    381       new MockProxyConfigService("http://foopy/proxy.pac");
    382   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    383 
    384   ProxyService service(config_service, resolver, NULL);
    385 
    386   GURL url("http://www.google.com/");
    387 
    388   ProxyInfo info;
    389   TestCompletionCallback callback1;
    390   int rv = service.ResolveProxy(
    391       url, &info, callback1.callback(), NULL, BoundNetLog());
    392   EXPECT_EQ(ERR_IO_PENDING, rv);
    393 
    394   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    395             resolver->pending_set_pac_script_request()->script_data()->url());
    396   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    397 
    398   ASSERT_EQ(1u, resolver->pending_requests().size());
    399   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    400 
    401   // Set the result in proxy resolver.
    402   resolver->pending_requests()[0]->results()->UsePacString(
    403       "DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20");
    404   resolver->pending_requests()[0]->CompleteNow(OK);
    405 
    406   EXPECT_EQ(OK, callback1.WaitForResult());
    407   EXPECT_TRUE(info.is_direct());
    408 
    409   // Fallback 1.
    410   TestCompletionCallback callback2;
    411   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
    412                                          BoundNetLog());
    413   EXPECT_EQ(OK, rv);
    414   EXPECT_FALSE(info.is_direct());
    415   EXPECT_EQ("foobar:10", info.proxy_server().ToURI());
    416 
    417   // Fallback 2.
    418   TestCompletionCallback callback3;
    419   rv = service.ReconsiderProxyAfterError(url, &info, callback3.callback(), NULL,
    420                                          BoundNetLog());
    421   EXPECT_EQ(OK, rv);
    422   EXPECT_TRUE(info.is_direct());
    423 
    424   // Fallback 3.
    425   TestCompletionCallback callback4;
    426   rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
    427                                          BoundNetLog());
    428   EXPECT_EQ(OK, rv);
    429   EXPECT_FALSE(info.is_direct());
    430   EXPECT_EQ("foobar:20", info.proxy_server().ToURI());
    431 
    432   // Fallback 4 -- Nothing to fall back to!
    433   TestCompletionCallback callback5;
    434   rv = service.ReconsiderProxyAfterError(url, &info, callback5.callback(), NULL,
    435                                          BoundNetLog());
    436   EXPECT_EQ(ERR_FAILED, rv);
    437   EXPECT_TRUE(info.is_empty());
    438 }
    439 
    440 TEST_F(ProxyServiceTest, PAC_ConfigSourcePropagates) {
    441   // Test whether the ProxyConfigSource set by the ProxyConfigService is applied
    442   // to ProxyInfo after the proxy is resolved via a PAC script.
    443   ProxyConfig config =
    444       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
    445   config.set_source(PROXY_CONFIG_SOURCE_TEST);
    446 
    447   MockProxyConfigService* config_service = new MockProxyConfigService(config);
    448   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    449   ProxyService service(config_service, resolver, NULL);
    450 
    451   // Resolve something.
    452   GURL url("http://www.google.com/");
    453   ProxyInfo info;
    454   TestCompletionCallback callback;
    455   int rv = service.ResolveProxy(
    456       url, &info, callback.callback(), NULL, BoundNetLog());
    457   ASSERT_EQ(ERR_IO_PENDING, rv);
    458   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    459   ASSERT_EQ(1u, resolver->pending_requests().size());
    460 
    461   // Set the result in proxy resolver.
    462   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy");
    463   resolver->pending_requests()[0]->CompleteNow(OK);
    464 
    465   EXPECT_EQ(OK, callback.WaitForResult());
    466   EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
    467   EXPECT_TRUE(info.did_use_pac_script());
    468 
    469   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    470   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    471   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    472 }
    473 
    474 TEST_F(ProxyServiceTest, ProxyResolverFails) {
    475   // Test what happens when the ProxyResolver fails. The download and setting
    476   // of the PAC script have already succeeded, so this corresponds with a
    477   // javascript runtime error while calling FindProxyForURL().
    478 
    479   MockProxyConfigService* config_service =
    480       new MockProxyConfigService("http://foopy/proxy.pac");
    481 
    482   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    483 
    484   ProxyService service(config_service, resolver, NULL);
    485 
    486   // Start first resolve request.
    487   GURL url("http://www.google.com/");
    488   ProxyInfo info;
    489   TestCompletionCallback callback1;
    490   int rv = service.ResolveProxy(
    491       url, &info, callback1.callback(), NULL, BoundNetLog());
    492   EXPECT_EQ(ERR_IO_PENDING, rv);
    493 
    494   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    495             resolver->pending_set_pac_script_request()->script_data()->url());
    496   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    497 
    498   ASSERT_EQ(1u, resolver->pending_requests().size());
    499   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    500 
    501   // Fail the first resolve request in MockAsyncProxyResolver.
    502   resolver->pending_requests()[0]->CompleteNow(ERR_FAILED);
    503 
    504   // Although the proxy resolver failed the request, ProxyService implicitly
    505   // falls-back to DIRECT.
    506   EXPECT_EQ(OK, callback1.WaitForResult());
    507   EXPECT_TRUE(info.is_direct());
    508 
    509   // Failed PAC executions still have proxy resolution times.
    510   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    511   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    512   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    513 
    514   // The second resolve request will try to run through the proxy resolver,
    515   // regardless of whether the first request failed in it.
    516   TestCompletionCallback callback2;
    517   rv = service.ResolveProxy(
    518       url, &info, callback2.callback(), NULL, BoundNetLog());
    519   EXPECT_EQ(ERR_IO_PENDING, rv);
    520 
    521   ASSERT_EQ(1u, resolver->pending_requests().size());
    522   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    523 
    524   // This time we will have the resolver succeed (perhaps the PAC script has
    525   // a dependency on the current time).
    526   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
    527   resolver->pending_requests()[0]->CompleteNow(OK);
    528 
    529   EXPECT_EQ(OK, callback2.WaitForResult());
    530   EXPECT_FALSE(info.is_direct());
    531   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
    532 }
    533 
    534 TEST_F(ProxyServiceTest, ProxyScriptFetcherFailsDownloadingMandatoryPac) {
    535   // Test what happens when the ProxyScriptResolver fails to download a
    536   // mandatory PAC script.
    537 
    538   ProxyConfig config(
    539       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
    540   config.set_pac_mandatory(true);
    541 
    542   MockProxyConfigService* config_service = new MockProxyConfigService(config);
    543 
    544   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    545 
    546   ProxyService service(config_service, resolver, NULL);
    547 
    548   // Start first resolve request.
    549   GURL url("http://www.google.com/");
    550   ProxyInfo info;
    551   TestCompletionCallback callback1;
    552   int rv = service.ResolveProxy(
    553       url, &info, callback1.callback(), NULL, BoundNetLog());
    554   EXPECT_EQ(ERR_IO_PENDING, rv);
    555 
    556   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    557             resolver->pending_set_pac_script_request()->script_data()->url());
    558   resolver->pending_set_pac_script_request()->CompleteNow(ERR_FAILED);
    559 
    560   ASSERT_EQ(0u, resolver->pending_requests().size());
    561 
    562   // As the proxy resolver failed the request and is configured for a mandatory
    563   // PAC script, ProxyService must not implicitly fall-back to DIRECT.
    564   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
    565             callback1.WaitForResult());
    566   EXPECT_FALSE(info.is_direct());
    567 
    568   // As the proxy resolver failed the request and is configured for a mandatory
    569   // PAC script, ProxyService must not implicitly fall-back to DIRECT.
    570   TestCompletionCallback callback2;
    571   rv = service.ResolveProxy(
    572       url, &info, callback2.callback(), NULL, BoundNetLog());
    573   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, rv);
    574   EXPECT_FALSE(info.is_direct());
    575 }
    576 
    577 TEST_F(ProxyServiceTest, ProxyResolverFailsParsingJavaScriptMandatoryPac) {
    578   // Test what happens when the ProxyResolver fails that is configured to use a
    579   // mandatory PAC script. The download of the PAC script has already
    580   // succeeded but the PAC script contains no valid javascript.
    581 
    582   ProxyConfig config(
    583       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
    584   config.set_pac_mandatory(true);
    585 
    586   MockProxyConfigService* config_service = new MockProxyConfigService(config);
    587 
    588   MockAsyncProxyResolverExpectsBytes* resolver =
    589       new MockAsyncProxyResolverExpectsBytes;
    590 
    591   ProxyService service(config_service, resolver, NULL);
    592 
    593   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
    594   DhcpProxyScriptFetcher* dhcp_fetcher = new DoNothingDhcpProxyScriptFetcher();
    595   service.SetProxyScriptFetchers(fetcher, dhcp_fetcher);
    596 
    597   // Start resolve request.
    598   GURL url("http://www.google.com/");
    599   ProxyInfo info;
    600   TestCompletionCallback callback;
    601   int rv = service.ResolveProxy(
    602       url, &info, callback.callback(), NULL, BoundNetLog());
    603   EXPECT_EQ(ERR_IO_PENDING, rv);
    604 
    605   // Check that nothing has been sent to the proxy resolver yet.
    606   ASSERT_EQ(0u, resolver->pending_requests().size());
    607 
    608   // Downloading the PAC script succeeds.
    609   EXPECT_TRUE(fetcher->has_pending_request());
    610   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
    611   fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
    612 
    613   EXPECT_FALSE(fetcher->has_pending_request());
    614   ASSERT_EQ(0u, resolver->pending_requests().size());
    615 
    616   // Since ProxyScriptDecider failed to identify a valid PAC and PAC was
    617   // mandatory for this configuration, the ProxyService must not implicitly
    618   // fall-back to DIRECT.
    619   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
    620             callback.WaitForResult());
    621   EXPECT_FALSE(info.is_direct());
    622 }
    623 
    624 TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
    625   // Test what happens when the ProxyResolver fails that is configured to use a
    626   // mandatory PAC script. The download and setting of the PAC script have
    627   // already succeeded, so this corresponds with a javascript runtime error
    628   // while calling FindProxyForURL().
    629 
    630   ProxyConfig config(
    631       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
    632   config.set_pac_mandatory(true);
    633 
    634   MockProxyConfigService* config_service = new MockProxyConfigService(config);
    635 
    636   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    637 
    638   ProxyService service(config_service, resolver, NULL);
    639 
    640   // Start first resolve request.
    641   GURL url("http://www.google.com/");
    642   ProxyInfo info;
    643   TestCompletionCallback callback1;
    644   int rv = service.ResolveProxy(
    645       url, &info, callback1.callback(), NULL, BoundNetLog());
    646   EXPECT_EQ(ERR_IO_PENDING, rv);
    647 
    648   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    649             resolver->pending_set_pac_script_request()->script_data()->url());
    650   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    651 
    652   ASSERT_EQ(1u, resolver->pending_requests().size());
    653   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    654 
    655   // Fail the first resolve request in MockAsyncProxyResolver.
    656   resolver->pending_requests()[0]->CompleteNow(ERR_FAILED);
    657 
    658   // As the proxy resolver failed the request and is configured for a mandatory
    659   // PAC script, ProxyService must not implicitly fall-back to DIRECT.
    660   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
    661             callback1.WaitForResult());
    662   EXPECT_FALSE(info.is_direct());
    663 
    664   // The second resolve request will try to run through the proxy resolver,
    665   // regardless of whether the first request failed in it.
    666   TestCompletionCallback callback2;
    667   rv = service.ResolveProxy(
    668       url, &info, callback2.callback(), NULL, BoundNetLog());
    669   EXPECT_EQ(ERR_IO_PENDING, rv);
    670 
    671   ASSERT_EQ(1u, resolver->pending_requests().size());
    672   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    673 
    674   // This time we will have the resolver succeed (perhaps the PAC script has
    675   // a dependency on the current time).
    676   resolver->pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
    677   resolver->pending_requests()[0]->CompleteNow(OK);
    678 
    679   EXPECT_EQ(OK, callback2.WaitForResult());
    680   EXPECT_FALSE(info.is_direct());
    681   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
    682 }
    683 
    684 TEST_F(ProxyServiceTest, ProxyFallback) {
    685   // Test what happens when we specify multiple proxy servers and some of them
    686   // are bad.
    687 
    688   MockProxyConfigService* config_service =
    689       new MockProxyConfigService("http://foopy/proxy.pac");
    690 
    691   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    692 
    693   ProxyService service(config_service, resolver, NULL);
    694 
    695   GURL url("http://www.google.com/");
    696 
    697   // Get the proxy information.
    698   ProxyInfo info;
    699   TestCompletionCallback callback1;
    700   int rv = service.ResolveProxy(
    701       url, &info, callback1.callback(), NULL, BoundNetLog());
    702   EXPECT_EQ(ERR_IO_PENDING, rv);
    703 
    704   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    705             resolver->pending_set_pac_script_request()->script_data()->url());
    706   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    707 
    708   ASSERT_EQ(1u, resolver->pending_requests().size());
    709   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    710 
    711   // Set the result in proxy resolver.
    712   resolver->pending_requests()[0]->results()->UseNamedProxy(
    713       "foopy1:8080;foopy2:9090");
    714   resolver->pending_requests()[0]->CompleteNow(OK);
    715 
    716   // The first item is valid.
    717   EXPECT_EQ(OK, callback1.WaitForResult());
    718   EXPECT_FALSE(info.is_direct());
    719   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
    720 
    721   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    722   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    723   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    724   base::TimeTicks proxy_resolve_start_time = info.proxy_resolve_start_time();
    725   base::TimeTicks proxy_resolve_end_time = info.proxy_resolve_end_time();
    726 
    727   // Fake an error on the proxy.
    728   TestCompletionCallback callback2;
    729   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
    730                                          BoundNetLog());
    731   EXPECT_EQ(OK, rv);
    732 
    733   // Proxy times should not have been modified by fallback.
    734   EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
    735   EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
    736 
    737   // The second proxy should be specified.
    738   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
    739   // Report back that the second proxy worked.  This will globally mark the
    740   // first proxy as bad.
    741   service.ReportSuccess(info);
    742 
    743   TestCompletionCallback callback3;
    744   rv = service.ResolveProxy(
    745       url, &info, callback3.callback(), NULL, BoundNetLog());
    746   EXPECT_EQ(ERR_IO_PENDING, rv);
    747 
    748   ASSERT_EQ(1u, resolver->pending_requests().size());
    749   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    750 
    751   // Set the result in proxy resolver -- the second result is already known
    752   // to be bad, so we will not try to use it initially.
    753   resolver->pending_requests()[0]->results()->UseNamedProxy(
    754       "foopy3:7070;foopy1:8080;foopy2:9090");
    755   resolver->pending_requests()[0]->CompleteNow(OK);
    756 
    757   EXPECT_EQ(OK, callback3.WaitForResult());
    758   EXPECT_FALSE(info.is_direct());
    759   EXPECT_EQ("foopy3:7070", info.proxy_server().ToURI());
    760 
    761   // Proxy times should have been updated, so get them again.
    762   EXPECT_LE(proxy_resolve_end_time, info.proxy_resolve_start_time());
    763   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    764   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    765   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    766   proxy_resolve_start_time = info.proxy_resolve_start_time();
    767   proxy_resolve_end_time = info.proxy_resolve_end_time();
    768 
    769   // We fake another error. It should now try the third one.
    770   TestCompletionCallback callback4;
    771   rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
    772                                          BoundNetLog());
    773   EXPECT_EQ(OK, rv);
    774   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
    775 
    776   // We fake another error. At this point we have tried all of the
    777   // proxy servers we thought were valid; next we try the proxy server
    778   // that was in our bad proxies map (foopy1:8080).
    779   TestCompletionCallback callback5;
    780   rv = service.ReconsiderProxyAfterError(url, &info, callback5.callback(), NULL,
    781                                          BoundNetLog());
    782   EXPECT_EQ(OK, rv);
    783   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
    784 
    785   // Fake another error, the last proxy is gone, the list should now be empty,
    786   // so there is nothing left to try.
    787   TestCompletionCallback callback6;
    788   rv = service.ReconsiderProxyAfterError(url, &info, callback6.callback(), NULL,
    789                                          BoundNetLog());
    790   EXPECT_EQ(ERR_FAILED, rv);
    791   EXPECT_FALSE(info.is_direct());
    792   EXPECT_TRUE(info.is_empty());
    793 
    794   // Proxy times should not have been modified by fallback.
    795   EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
    796   EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
    797 
    798   // Look up proxies again
    799   TestCompletionCallback callback7;
    800   rv = service.ResolveProxy(url, &info, callback7.callback(), NULL,
    801                             BoundNetLog());
    802   EXPECT_EQ(ERR_IO_PENDING, rv);
    803 
    804   ASSERT_EQ(1u, resolver->pending_requests().size());
    805   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    806 
    807   // This time, the first 3 results have been found to be bad, but only the
    808   // first proxy has been confirmed ...
    809   resolver->pending_requests()[0]->results()->UseNamedProxy(
    810       "foopy1:8080;foopy3:7070;foopy2:9090;foopy4:9091");
    811   resolver->pending_requests()[0]->CompleteNow(OK);
    812 
    813   // ... therefore, we should see the second proxy first.
    814   EXPECT_EQ(OK, callback7.WaitForResult());
    815   EXPECT_FALSE(info.is_direct());
    816   EXPECT_EQ("foopy3:7070", info.proxy_server().ToURI());
    817 
    818   EXPECT_LE(proxy_resolve_end_time, info.proxy_resolve_start_time());
    819   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    820   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    821   // TODO(nsylvain): Test that the proxy can be retried after the delay.
    822 }
    823 
    824 // This test is similar to ProxyFallback, but this time we have an explicit
    825 // fallback choice to DIRECT.
    826 TEST_F(ProxyServiceTest, ProxyFallbackToDirect) {
    827   MockProxyConfigService* config_service =
    828       new MockProxyConfigService("http://foopy/proxy.pac");
    829 
    830   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    831 
    832   ProxyService service(config_service, resolver, NULL);
    833 
    834   GURL url("http://www.google.com/");
    835 
    836   // Get the proxy information.
    837   ProxyInfo info;
    838   TestCompletionCallback callback1;
    839   int rv = service.ResolveProxy(
    840       url, &info, callback1.callback(), NULL, BoundNetLog());
    841   EXPECT_EQ(ERR_IO_PENDING, rv);
    842 
    843   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    844             resolver->pending_set_pac_script_request()->script_data()->url());
    845   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    846 
    847   ASSERT_EQ(1u, resolver->pending_requests().size());
    848   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    849 
    850   // Set the result in proxy resolver.
    851   resolver->pending_requests()[0]->results()->UsePacString(
    852       "PROXY foopy1:8080; PROXY foopy2:9090; DIRECT");
    853   resolver->pending_requests()[0]->CompleteNow(OK);
    854 
    855   // Get the first result.
    856   EXPECT_EQ(OK, callback1.WaitForResult());
    857   EXPECT_FALSE(info.is_direct());
    858   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
    859 
    860   // Fake an error on the proxy.
    861   TestCompletionCallback callback2;
    862   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
    863                                          BoundNetLog());
    864   EXPECT_EQ(OK, rv);
    865 
    866   // Now we get back the second proxy.
    867   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
    868 
    869   // Fake an error on this proxy as well.
    870   TestCompletionCallback callback3;
    871   rv = service.ReconsiderProxyAfterError(url, &info, callback3.callback(), NULL,
    872                                          BoundNetLog());
    873   EXPECT_EQ(OK, rv);
    874 
    875   // Finally, we get back DIRECT.
    876   EXPECT_TRUE(info.is_direct());
    877 
    878   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    879   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    880   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    881 
    882   // Now we tell the proxy service that even DIRECT failed.
    883   TestCompletionCallback callback4;
    884   rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
    885                                          BoundNetLog());
    886   // There was nothing left to try after DIRECT, so we are out of
    887   // choices.
    888   EXPECT_EQ(ERR_FAILED, rv);
    889 }
    890 
    891 TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
    892   // Test proxy failover when new settings are available.
    893 
    894   MockProxyConfigService* config_service =
    895       new MockProxyConfigService("http://foopy/proxy.pac");
    896 
    897   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    898 
    899   ProxyService service(config_service, resolver, NULL);
    900 
    901   GURL url("http://www.google.com/");
    902 
    903   // Get the proxy information.
    904   ProxyInfo info;
    905   TestCompletionCallback callback1;
    906   int rv = service.ResolveProxy(
    907       url, &info, callback1.callback(), NULL, BoundNetLog());
    908   EXPECT_EQ(ERR_IO_PENDING, rv);
    909 
    910   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
    911             resolver->pending_set_pac_script_request()->script_data()->url());
    912   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    913 
    914   ASSERT_EQ(1u, resolver->pending_requests().size());
    915   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    916 
    917   // Set the result in proxy resolver.
    918   resolver->pending_requests()[0]->results()->UseNamedProxy(
    919       "foopy1:8080;foopy2:9090");
    920   resolver->pending_requests()[0]->CompleteNow(OK);
    921 
    922   // The first item is valid.
    923   EXPECT_EQ(OK, callback1.WaitForResult());
    924   EXPECT_FALSE(info.is_direct());
    925   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
    926 
    927   // Fake an error on the proxy, and also a new configuration on the proxy.
    928   config_service->SetConfig(
    929       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy-new/proxy.pac")));
    930 
    931   TestCompletionCallback callback2;
    932   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
    933                                          BoundNetLog());
    934   EXPECT_EQ(ERR_IO_PENDING, rv);
    935 
    936   EXPECT_EQ(GURL("http://foopy-new/proxy.pac"),
    937             resolver->pending_set_pac_script_request()->script_data()->url());
    938   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    939 
    940   ASSERT_EQ(1u, resolver->pending_requests().size());
    941   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    942 
    943   resolver->pending_requests()[0]->results()->UseNamedProxy(
    944       "foopy1:8080;foopy2:9090");
    945   resolver->pending_requests()[0]->CompleteNow(OK);
    946 
    947   // The first proxy is still there since the configuration changed.
    948   EXPECT_EQ(OK, callback2.WaitForResult());
    949   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
    950 
    951   // We fake another error. It should now ignore the first one.
    952   TestCompletionCallback callback3;
    953   rv = service.ReconsiderProxyAfterError(url, &info, callback3.callback(), NULL,
    954                                          BoundNetLog());
    955   EXPECT_EQ(OK, rv);
    956   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
    957 
    958   // We simulate a new configuration.
    959   config_service->SetConfig(
    960       ProxyConfig::CreateFromCustomPacURL(
    961           GURL("http://foopy-new2/proxy.pac")));
    962 
    963   // We fake another error. It should go back to the first proxy.
    964   TestCompletionCallback callback4;
    965   rv = service.ReconsiderProxyAfterError(url, &info, callback4.callback(), NULL,
    966                                          BoundNetLog());
    967   EXPECT_EQ(ERR_IO_PENDING, rv);
    968 
    969   EXPECT_EQ(GURL("http://foopy-new2/proxy.pac"),
    970             resolver->pending_set_pac_script_request()->script_data()->url());
    971   resolver->pending_set_pac_script_request()->CompleteNow(OK);
    972 
    973   ASSERT_EQ(1u, resolver->pending_requests().size());
    974   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
    975 
    976   resolver->pending_requests()[0]->results()->UseNamedProxy(
    977       "foopy1:8080;foopy2:9090");
    978   resolver->pending_requests()[0]->CompleteNow(OK);
    979 
    980   EXPECT_EQ(OK, callback4.WaitForResult());
    981   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
    982 
    983   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
    984   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
    985   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
    986 }
    987 
    988 TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
    989   // Test proxy failover when the configuration is bad.
    990 
    991   MockProxyConfigService* config_service =
    992       new MockProxyConfigService("http://foopy/proxy.pac");
    993 
    994   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
    995 
    996   ProxyService service(config_service, resolver, NULL);
    997 
    998   GURL url("http://www.google.com/");
    999 
   1000   // Get the proxy information.
   1001   ProxyInfo info;
   1002   TestCompletionCallback callback1;
   1003   int rv = service.ResolveProxy(
   1004       url, &info, callback1.callback(), NULL, BoundNetLog());
   1005   EXPECT_EQ(ERR_IO_PENDING, rv);
   1006 
   1007   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
   1008             resolver->pending_set_pac_script_request()->script_data()->url());
   1009   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1010   ASSERT_EQ(1u, resolver->pending_requests().size());
   1011   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
   1012 
   1013   resolver->pending_requests()[0]->results()->UseNamedProxy(
   1014       "foopy1:8080;foopy2:9090");
   1015   resolver->pending_requests()[0]->CompleteNow(OK);
   1016 
   1017   // The first item is valid.
   1018   EXPECT_EQ(OK, callback1.WaitForResult());
   1019   EXPECT_FALSE(info.is_direct());
   1020   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   1021 
   1022   // Fake a proxy error.
   1023   TestCompletionCallback callback2;
   1024   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
   1025                                          BoundNetLog());
   1026   EXPECT_EQ(OK, rv);
   1027 
   1028   // The first proxy is ignored, and the second one is selected.
   1029   EXPECT_FALSE(info.is_direct());
   1030   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
   1031 
   1032   // Fake a PAC failure.
   1033   ProxyInfo info2;
   1034   TestCompletionCallback callback3;
   1035   rv = service.ResolveProxy(
   1036       url, &info2, callback3.callback(), NULL, BoundNetLog());
   1037   EXPECT_EQ(ERR_IO_PENDING, rv);
   1038 
   1039   ASSERT_EQ(1u, resolver->pending_requests().size());
   1040   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
   1041 
   1042   // This simulates a javascript runtime error in the PAC script.
   1043   resolver->pending_requests()[0]->CompleteNow(ERR_FAILED);
   1044 
   1045   // Although the resolver failed, the ProxyService will implicitly fall-back
   1046   // to a DIRECT connection.
   1047   EXPECT_EQ(OK, callback3.WaitForResult());
   1048   EXPECT_TRUE(info2.is_direct());
   1049   EXPECT_FALSE(info2.is_empty());
   1050 
   1051   // The PAC script will work properly next time and successfully return a
   1052   // proxy list. Since we have not marked the configuration as bad, it should
   1053   // "just work" the next time we call it.
   1054   ProxyInfo info3;
   1055   TestCompletionCallback callback4;
   1056   rv = service.ReconsiderProxyAfterError(url, &info3, callback4.callback(),
   1057                                          NULL, BoundNetLog());
   1058   EXPECT_EQ(ERR_IO_PENDING, rv);
   1059 
   1060   ASSERT_EQ(1u, resolver->pending_requests().size());
   1061   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
   1062 
   1063   resolver->pending_requests()[0]->results()->UseNamedProxy(
   1064       "foopy1:8080;foopy2:9090");
   1065   resolver->pending_requests()[0]->CompleteNow(OK);
   1066 
   1067   // The first proxy is not there since the it was added to the bad proxies
   1068   // list by the earlier ReconsiderProxyAfterError().
   1069   EXPECT_EQ(OK, callback4.WaitForResult());
   1070   EXPECT_FALSE(info3.is_direct());
   1071   EXPECT_EQ("foopy1:8080", info3.proxy_server().ToURI());
   1072 
   1073   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   1074   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   1075   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
   1076 }
   1077 
   1078 TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
   1079   // Test proxy failover when the configuration is bad.
   1080 
   1081   ProxyConfig config(
   1082       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
   1083 
   1084   config.set_pac_mandatory(true);
   1085   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   1086 
   1087   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   1088 
   1089   ProxyService service(config_service, resolver, NULL);
   1090 
   1091   GURL url("http://www.google.com/");
   1092 
   1093   // Get the proxy information.
   1094   ProxyInfo info;
   1095   TestCompletionCallback callback1;
   1096   int rv = service.ResolveProxy(
   1097       url, &info, callback1.callback(), NULL, BoundNetLog());
   1098   EXPECT_EQ(ERR_IO_PENDING, rv);
   1099 
   1100   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
   1101             resolver->pending_set_pac_script_request()->script_data()->url());
   1102   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1103   ASSERT_EQ(1u, resolver->pending_requests().size());
   1104   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
   1105 
   1106   resolver->pending_requests()[0]->results()->UseNamedProxy(
   1107       "foopy1:8080;foopy2:9090");
   1108   resolver->pending_requests()[0]->CompleteNow(OK);
   1109 
   1110   // The first item is valid.
   1111   EXPECT_EQ(OK, callback1.WaitForResult());
   1112   EXPECT_FALSE(info.is_direct());
   1113   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   1114 
   1115   // Fake a proxy error.
   1116   TestCompletionCallback callback2;
   1117   rv = service.ReconsiderProxyAfterError(url, &info, callback2.callback(), NULL,
   1118                                          BoundNetLog());
   1119   EXPECT_EQ(OK, rv);
   1120 
   1121   // The first proxy is ignored, and the second one is selected.
   1122   EXPECT_FALSE(info.is_direct());
   1123   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
   1124 
   1125   // Fake a PAC failure.
   1126   ProxyInfo info2;
   1127   TestCompletionCallback callback3;
   1128   rv = service.ResolveProxy(
   1129       url, &info2, callback3.callback(), NULL, BoundNetLog());
   1130   EXPECT_EQ(ERR_IO_PENDING, rv);
   1131 
   1132   ASSERT_EQ(1u, resolver->pending_requests().size());
   1133   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
   1134 
   1135   // This simulates a javascript runtime error in the PAC script.
   1136   resolver->pending_requests()[0]->CompleteNow(ERR_FAILED);
   1137 
   1138   // Although the resolver failed, the ProxyService will NOT fall-back
   1139   // to a DIRECT connection as it is configured as mandatory.
   1140   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
   1141             callback3.WaitForResult());
   1142   EXPECT_FALSE(info2.is_direct());
   1143   EXPECT_TRUE(info2.is_empty());
   1144 
   1145   // The PAC script will work properly next time and successfully return a
   1146   // proxy list. Since we have not marked the configuration as bad, it should
   1147   // "just work" the next time we call it.
   1148   ProxyInfo info3;
   1149   TestCompletionCallback callback4;
   1150   rv = service.ReconsiderProxyAfterError(url, &info3, callback4.callback(),
   1151                                          NULL, BoundNetLog());
   1152   EXPECT_EQ(ERR_IO_PENDING, rv);
   1153 
   1154   ASSERT_EQ(1u, resolver->pending_requests().size());
   1155   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
   1156 
   1157   resolver->pending_requests()[0]->results()->UseNamedProxy(
   1158       "foopy1:8080;foopy2:9090");
   1159   resolver->pending_requests()[0]->CompleteNow(OK);
   1160 
   1161   // The first proxy is not there since the it was added to the bad proxies
   1162   // list by the earlier ReconsiderProxyAfterError().
   1163   EXPECT_EQ(OK, callback4.WaitForResult());
   1164   EXPECT_FALSE(info3.is_direct());
   1165   EXPECT_EQ("foopy1:8080", info3.proxy_server().ToURI());
   1166 }
   1167 
   1168 TEST_F(ProxyServiceTest, ProxyBypassList) {
   1169   // Test that the proxy bypass rules are consulted.
   1170 
   1171   TestCompletionCallback callback[2];
   1172   ProxyInfo info[2];
   1173   ProxyConfig config;
   1174   config.proxy_rules().ParseFromString("foopy1:8080;foopy2:9090");
   1175   config.set_auto_detect(false);
   1176   config.proxy_rules().bypass_rules.ParseFromString("*.org");
   1177 
   1178   ProxyService service(
   1179       new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1180 
   1181   int rv;
   1182   GURL url1("http://www.webkit.org");
   1183   GURL url2("http://www.webkit.com");
   1184 
   1185   // Request for a .org domain should bypass proxy.
   1186   rv = service.ResolveProxy(
   1187       url1, &info[0], callback[0].callback(), NULL, BoundNetLog());
   1188   EXPECT_EQ(OK, rv);
   1189   EXPECT_TRUE(info[0].is_direct());
   1190 
   1191   // Request for a .com domain hits the proxy.
   1192   rv = service.ResolveProxy(
   1193       url2, &info[1], callback[1].callback(), NULL, BoundNetLog());
   1194   EXPECT_EQ(OK, rv);
   1195   EXPECT_EQ("foopy1:8080", info[1].proxy_server().ToURI());
   1196 }
   1197 
   1198 
   1199 TEST_F(ProxyServiceTest, PerProtocolProxyTests) {
   1200   ProxyConfig config;
   1201   config.proxy_rules().ParseFromString("http=foopy1:8080;https=foopy2:8080");
   1202   config.set_auto_detect(false);
   1203   {
   1204     ProxyService service(
   1205         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1206     GURL test_url("http://www.msn.com");
   1207     ProxyInfo info;
   1208     TestCompletionCallback callback;
   1209     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1210                                   BoundNetLog());
   1211     EXPECT_EQ(OK, rv);
   1212     EXPECT_FALSE(info.is_direct());
   1213     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   1214   }
   1215   {
   1216     ProxyService service(
   1217         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1218     GURL test_url("ftp://ftp.google.com");
   1219     ProxyInfo info;
   1220     TestCompletionCallback callback;
   1221     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1222                                   BoundNetLog());
   1223     EXPECT_EQ(OK, rv);
   1224     EXPECT_TRUE(info.is_direct());
   1225     EXPECT_EQ("direct://", info.proxy_server().ToURI());
   1226   }
   1227   {
   1228     ProxyService service(
   1229         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1230     GURL test_url("https://webbranch.techcu.com");
   1231     ProxyInfo info;
   1232     TestCompletionCallback callback;
   1233     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1234                                   BoundNetLog());
   1235     EXPECT_EQ(OK, rv);
   1236     EXPECT_FALSE(info.is_direct());
   1237     EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
   1238   }
   1239   {
   1240     config.proxy_rules().ParseFromString("foopy1:8080");
   1241     ProxyService service(
   1242         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1243     GURL test_url("http://www.microsoft.com");
   1244     ProxyInfo info;
   1245     TestCompletionCallback callback;
   1246     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1247                                   BoundNetLog());
   1248     EXPECT_EQ(OK, rv);
   1249     EXPECT_FALSE(info.is_direct());
   1250     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   1251   }
   1252 }
   1253 
   1254 TEST_F(ProxyServiceTest, ProxyConfigSourcePropagates) {
   1255   // Test that the proxy config source is set correctly when resolving proxies
   1256   // using manual proxy rules. Namely, the config source should only be set if
   1257   // any of the rules were applied.
   1258   {
   1259     ProxyConfig config;
   1260     config.set_source(PROXY_CONFIG_SOURCE_TEST);
   1261     config.proxy_rules().ParseFromString("https=foopy2:8080");
   1262     ProxyService service(
   1263         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1264     GURL test_url("http://www.google.com");
   1265     ProxyInfo info;
   1266     TestCompletionCallback callback;
   1267     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1268                                   BoundNetLog());
   1269     ASSERT_EQ(OK, rv);
   1270     // Should be SOURCE_TEST, even if there are no HTTP proxies configured.
   1271     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   1272   }
   1273   {
   1274     ProxyConfig config;
   1275     config.set_source(PROXY_CONFIG_SOURCE_TEST);
   1276     config.proxy_rules().ParseFromString("https=foopy2:8080");
   1277     ProxyService service(
   1278         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1279     GURL test_url("https://www.google.com");
   1280     ProxyInfo info;
   1281     TestCompletionCallback callback;
   1282     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1283                                   BoundNetLog());
   1284     ASSERT_EQ(OK, rv);
   1285     // Used the HTTPS proxy. So source should be TEST.
   1286     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   1287   }
   1288   {
   1289     ProxyConfig config;
   1290     config.set_source(PROXY_CONFIG_SOURCE_TEST);
   1291     ProxyService service(
   1292         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1293     GURL test_url("http://www.google.com");
   1294     ProxyInfo info;
   1295     TestCompletionCallback callback;
   1296     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1297                                   BoundNetLog());
   1298     ASSERT_EQ(OK, rv);
   1299     // ProxyConfig is empty. Source should still be TEST.
   1300     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   1301   }
   1302 }
   1303 
   1304 // If only HTTP and a SOCKS proxy are specified, check if ftp/https queries
   1305 // fall back to the SOCKS proxy.
   1306 TEST_F(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
   1307   ProxyConfig config;
   1308   config.proxy_rules().ParseFromString("http=foopy1:8080;socks=foopy2:1080");
   1309   config.set_auto_detect(false);
   1310   EXPECT_EQ(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
   1311             config.proxy_rules().type);
   1312 
   1313   {
   1314     ProxyService service(
   1315         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1316     GURL test_url("http://www.msn.com");
   1317     ProxyInfo info;
   1318     TestCompletionCallback callback;
   1319     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1320                                   BoundNetLog());
   1321     EXPECT_EQ(OK, rv);
   1322     EXPECT_FALSE(info.is_direct());
   1323     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   1324   }
   1325   {
   1326     ProxyService service(
   1327         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1328     GURL test_url("ftp://ftp.google.com");
   1329     ProxyInfo info;
   1330     TestCompletionCallback callback;
   1331     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1332                                   BoundNetLog());
   1333     EXPECT_EQ(OK, rv);
   1334     EXPECT_FALSE(info.is_direct());
   1335     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   1336   }
   1337   {
   1338     ProxyService service(
   1339         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1340     GURL test_url("https://webbranch.techcu.com");
   1341     ProxyInfo info;
   1342     TestCompletionCallback callback;
   1343     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1344                                   BoundNetLog());
   1345     EXPECT_EQ(OK, rv);
   1346     EXPECT_FALSE(info.is_direct());
   1347     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   1348   }
   1349   {
   1350     ProxyService service(
   1351         new MockProxyConfigService(config), new MockAsyncProxyResolver, NULL);
   1352     GURL test_url("unknown://www.microsoft.com");
   1353     ProxyInfo info;
   1354     TestCompletionCallback callback;
   1355     int rv = service.ResolveProxy(test_url, &info, callback.callback(), NULL,
   1356                                   BoundNetLog());
   1357     EXPECT_EQ(OK, rv);
   1358     EXPECT_FALSE(info.is_direct());
   1359     EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
   1360   }
   1361 }
   1362 
   1363 // Test cancellation of an in-progress request.
   1364 TEST_F(ProxyServiceTest, CancelInProgressRequest) {
   1365   MockProxyConfigService* config_service =
   1366       new MockProxyConfigService("http://foopy/proxy.pac");
   1367 
   1368   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   1369 
   1370   ProxyService service(config_service, resolver, NULL);
   1371 
   1372   // Start 3 requests.
   1373 
   1374   ProxyInfo info1;
   1375   TestCompletionCallback callback1;
   1376   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1377                                 callback1.callback(), NULL, BoundNetLog());
   1378   EXPECT_EQ(ERR_IO_PENDING, rv);
   1379 
   1380   // Nothing has been sent to the proxy resolver yet, since the proxy
   1381   // resolver has not been configured yet.
   1382   ASSERT_EQ(0u, resolver->pending_requests().size());
   1383 
   1384   // Successfully initialize the PAC script.
   1385   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
   1386             resolver->pending_set_pac_script_request()->script_data()->url());
   1387   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1388 
   1389   ASSERT_EQ(1u, resolver->pending_requests().size());
   1390   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   1391 
   1392   ProxyInfo info2;
   1393   TestCompletionCallback callback2;
   1394   ProxyService::PacRequest* request2;
   1395   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1396                             callback2.callback(), &request2, BoundNetLog());
   1397   EXPECT_EQ(ERR_IO_PENDING, rv);
   1398   ASSERT_EQ(2u, resolver->pending_requests().size());
   1399   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
   1400 
   1401   ProxyInfo info3;
   1402   TestCompletionCallback callback3;
   1403   rv = service.ResolveProxy(GURL("http://request3"), &info3,
   1404                             callback3.callback(), NULL, BoundNetLog());
   1405   EXPECT_EQ(ERR_IO_PENDING, rv);
   1406   ASSERT_EQ(3u, resolver->pending_requests().size());
   1407   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[2]->url());
   1408 
   1409   // Cancel the second request
   1410   service.CancelPacRequest(request2);
   1411 
   1412   ASSERT_EQ(2u, resolver->pending_requests().size());
   1413   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   1414   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[1]->url());
   1415 
   1416   // Complete the two un-cancelled requests.
   1417   // We complete the last one first, just to mix it up a bit.
   1418   resolver->pending_requests()[1]->results()->UseNamedProxy("request3:80");
   1419   resolver->pending_requests()[1]->CompleteNow(OK);
   1420 
   1421   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   1422   resolver->pending_requests()[0]->CompleteNow(OK);
   1423 
   1424   // Complete and verify that requests ran as expected.
   1425   EXPECT_EQ(OK, callback1.WaitForResult());
   1426   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   1427 
   1428   EXPECT_FALSE(callback2.have_result());  // Cancelled.
   1429   ASSERT_EQ(1u, resolver->cancelled_requests().size());
   1430   EXPECT_EQ(GURL("http://request2"), resolver->cancelled_requests()[0]->url());
   1431 
   1432   EXPECT_EQ(OK, callback3.WaitForResult());
   1433   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
   1434 }
   1435 
   1436 // Test the initial PAC download for resolver that expects bytes.
   1437 TEST_F(ProxyServiceTest, InitialPACScriptDownload) {
   1438   MockProxyConfigService* config_service =
   1439       new MockProxyConfigService("http://foopy/proxy.pac");
   1440 
   1441   MockAsyncProxyResolverExpectsBytes* resolver =
   1442       new MockAsyncProxyResolverExpectsBytes;
   1443 
   1444   ProxyService service(config_service, resolver, NULL);
   1445 
   1446   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1447   service.SetProxyScriptFetchers(fetcher,
   1448                                  new DoNothingDhcpProxyScriptFetcher());
   1449 
   1450   // Start 3 requests.
   1451 
   1452   ProxyInfo info1;
   1453   TestCompletionCallback callback1;
   1454   ProxyService::PacRequest* request1;
   1455   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1456                                 callback1.callback(), &request1, BoundNetLog());
   1457   EXPECT_EQ(ERR_IO_PENDING, rv);
   1458 
   1459   // The first request should have triggered download of PAC script.
   1460   EXPECT_TRUE(fetcher->has_pending_request());
   1461   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1462 
   1463   ProxyInfo info2;
   1464   TestCompletionCallback callback2;
   1465   ProxyService::PacRequest* request2;
   1466   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1467                             callback2.callback(), &request2, BoundNetLog());
   1468   EXPECT_EQ(ERR_IO_PENDING, rv);
   1469 
   1470   ProxyInfo info3;
   1471   TestCompletionCallback callback3;
   1472   ProxyService::PacRequest* request3;
   1473   rv = service.ResolveProxy(GURL("http://request3"), &info3,
   1474                             callback3.callback(), &request3, BoundNetLog());
   1475   EXPECT_EQ(ERR_IO_PENDING, rv);
   1476 
   1477   // Nothing has been sent to the resolver yet.
   1478   EXPECT_TRUE(resolver->pending_requests().empty());
   1479 
   1480   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
   1481             service.GetLoadState(request1));
   1482   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
   1483             service.GetLoadState(request2));
   1484   EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
   1485             service.GetLoadState(request3));
   1486 
   1487   // At this point the ProxyService should be waiting for the
   1488   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   1489   // PAC script download completion.
   1490   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   1491 
   1492   // Now that the PAC script is downloaded, it will have been sent to the proxy
   1493   // resolver.
   1494   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   1495             resolver->pending_set_pac_script_request()->script_data()->utf16());
   1496   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1497 
   1498   ASSERT_EQ(3u, resolver->pending_requests().size());
   1499   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   1500   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
   1501   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[2]->url());
   1502 
   1503   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request1));
   1504   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request2));
   1505   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request3));
   1506 
   1507   // Complete all the requests (in some order).
   1508   // Note that as we complete requests, they shift up in |pending_requests()|.
   1509 
   1510   resolver->pending_requests()[2]->results()->UseNamedProxy("request3:80");
   1511   resolver->pending_requests()[2]->CompleteNow(OK);
   1512 
   1513   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   1514   resolver->pending_requests()[0]->CompleteNow(OK);
   1515 
   1516   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   1517   resolver->pending_requests()[0]->CompleteNow(OK);
   1518 
   1519   // Complete and verify that requests ran as expected.
   1520   EXPECT_EQ(OK, callback1.WaitForResult());
   1521   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   1522   EXPECT_FALSE(info1.proxy_resolve_start_time().is_null());
   1523   EXPECT_FALSE(info1.proxy_resolve_end_time().is_null());
   1524   EXPECT_LE(info1.proxy_resolve_start_time(), info1.proxy_resolve_end_time());
   1525 
   1526   EXPECT_EQ(OK, callback2.WaitForResult());
   1527   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   1528   EXPECT_FALSE(info2.proxy_resolve_start_time().is_null());
   1529   EXPECT_FALSE(info2.proxy_resolve_end_time().is_null());
   1530   EXPECT_LE(info2.proxy_resolve_start_time(), info2.proxy_resolve_end_time());
   1531 
   1532   EXPECT_EQ(OK, callback3.WaitForResult());
   1533   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
   1534   EXPECT_FALSE(info3.proxy_resolve_start_time().is_null());
   1535   EXPECT_FALSE(info3.proxy_resolve_end_time().is_null());
   1536   EXPECT_LE(info3.proxy_resolve_start_time(), info3.proxy_resolve_end_time());
   1537 }
   1538 
   1539 // Test changing the ProxyScriptFetcher while PAC download is in progress.
   1540 TEST_F(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
   1541   MockProxyConfigService* config_service =
   1542       new MockProxyConfigService("http://foopy/proxy.pac");
   1543 
   1544   MockAsyncProxyResolverExpectsBytes* resolver =
   1545       new MockAsyncProxyResolverExpectsBytes;
   1546 
   1547   ProxyService service(config_service, resolver, NULL);
   1548 
   1549   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1550   service.SetProxyScriptFetchers(fetcher,
   1551                                  new DoNothingDhcpProxyScriptFetcher());
   1552 
   1553   // Start 2 requests.
   1554 
   1555   ProxyInfo info1;
   1556   TestCompletionCallback callback1;
   1557   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1558                                 callback1.callback(), NULL, BoundNetLog());
   1559   EXPECT_EQ(ERR_IO_PENDING, rv);
   1560 
   1561   // The first request should have triggered download of PAC script.
   1562   EXPECT_TRUE(fetcher->has_pending_request());
   1563   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1564 
   1565   ProxyInfo info2;
   1566   TestCompletionCallback callback2;
   1567   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1568                             callback2.callback(), NULL, BoundNetLog());
   1569   EXPECT_EQ(ERR_IO_PENDING, rv);
   1570 
   1571   // At this point the ProxyService should be waiting for the
   1572   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   1573   // PAC script download completion.
   1574 
   1575   // We now change out the ProxyService's script fetcher. We should restart
   1576   // the initialization with the new fetcher.
   1577 
   1578   fetcher = new MockProxyScriptFetcher;
   1579   service.SetProxyScriptFetchers(fetcher,
   1580                                  new DoNothingDhcpProxyScriptFetcher());
   1581 
   1582   // Nothing has been sent to the resolver yet.
   1583   EXPECT_TRUE(resolver->pending_requests().empty());
   1584 
   1585   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   1586 
   1587   // Now that the PAC script is downloaded, it will have been sent to the proxy
   1588   // resolver.
   1589   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   1590             resolver->pending_set_pac_script_request()->script_data()->utf16());
   1591   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1592 
   1593   ASSERT_EQ(2u, resolver->pending_requests().size());
   1594   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   1595   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
   1596 }
   1597 
   1598 // Test cancellation of a request, while the PAC script is being fetched.
   1599 TEST_F(ProxyServiceTest, CancelWhilePACFetching) {
   1600   MockProxyConfigService* config_service =
   1601       new MockProxyConfigService("http://foopy/proxy.pac");
   1602 
   1603   MockAsyncProxyResolverExpectsBytes* resolver =
   1604       new MockAsyncProxyResolverExpectsBytes;
   1605 
   1606   ProxyService service(config_service, resolver, NULL);
   1607 
   1608   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1609   service.SetProxyScriptFetchers(fetcher,
   1610                                  new DoNothingDhcpProxyScriptFetcher());
   1611 
   1612   // Start 3 requests.
   1613   ProxyInfo info1;
   1614   TestCompletionCallback callback1;
   1615   ProxyService::PacRequest* request1;
   1616   CapturingBoundNetLog log1;
   1617   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1618                                 callback1.callback(), &request1, log1.bound());
   1619   EXPECT_EQ(ERR_IO_PENDING, rv);
   1620 
   1621   // The first request should have triggered download of PAC script.
   1622   EXPECT_TRUE(fetcher->has_pending_request());
   1623   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1624 
   1625   ProxyInfo info2;
   1626   TestCompletionCallback callback2;
   1627   ProxyService::PacRequest* request2;
   1628   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1629                             callback2.callback(), &request2, BoundNetLog());
   1630   EXPECT_EQ(ERR_IO_PENDING, rv);
   1631 
   1632   ProxyInfo info3;
   1633   TestCompletionCallback callback3;
   1634   rv = service.ResolveProxy(GURL("http://request3"), &info3,
   1635                             callback3.callback(), NULL, BoundNetLog());
   1636   EXPECT_EQ(ERR_IO_PENDING, rv);
   1637 
   1638   // Nothing has been sent to the resolver yet.
   1639   EXPECT_TRUE(resolver->pending_requests().empty());
   1640 
   1641   // Cancel the first 2 requests.
   1642   service.CancelPacRequest(request1);
   1643   service.CancelPacRequest(request2);
   1644 
   1645   // At this point the ProxyService should be waiting for the
   1646   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   1647   // PAC script download completion.
   1648   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   1649 
   1650   // Now that the PAC script is downloaded, it will have been sent to the
   1651   // proxy resolver.
   1652   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   1653             resolver->pending_set_pac_script_request()->script_data()->utf16());
   1654   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1655 
   1656   ASSERT_EQ(1u, resolver->pending_requests().size());
   1657   EXPECT_EQ(GURL("http://request3"), resolver->pending_requests()[0]->url());
   1658 
   1659   // Complete all the requests.
   1660   resolver->pending_requests()[0]->results()->UseNamedProxy("request3:80");
   1661   resolver->pending_requests()[0]->CompleteNow(OK);
   1662 
   1663   EXPECT_EQ(OK, callback3.WaitForResult());
   1664   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
   1665 
   1666   EXPECT_TRUE(resolver->cancelled_requests().empty());
   1667 
   1668   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   1669   EXPECT_FALSE(callback2.have_result());  // Cancelled.
   1670 
   1671   CapturingNetLog::CapturedEntryList entries1;
   1672   log1.GetEntries(&entries1);
   1673 
   1674   // Check the NetLog for request 1 (which was cancelled) got filled properly.
   1675   EXPECT_EQ(4u, entries1.size());
   1676   EXPECT_TRUE(LogContainsBeginEvent(
   1677       entries1, 0, NetLog::TYPE_PROXY_SERVICE));
   1678   EXPECT_TRUE(LogContainsBeginEvent(
   1679       entries1, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   1680   // Note that TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC is never completed before
   1681   // the cancellation occured.
   1682   EXPECT_TRUE(LogContainsEvent(
   1683       entries1, 2, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE));
   1684   EXPECT_TRUE(LogContainsEndEvent(
   1685       entries1, 3, NetLog::TYPE_PROXY_SERVICE));
   1686 }
   1687 
   1688 // Test that if auto-detect fails, we fall-back to the custom pac.
   1689 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
   1690   ProxyConfig config;
   1691   config.set_auto_detect(true);
   1692   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   1693   config.proxy_rules().ParseFromString("http=foopy:80");  // Won't be used.
   1694 
   1695   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   1696   MockAsyncProxyResolverExpectsBytes* resolver =
   1697       new MockAsyncProxyResolverExpectsBytes;
   1698   ProxyService service(config_service, resolver, NULL);
   1699 
   1700   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1701   service.SetProxyScriptFetchers(fetcher,
   1702                                  new DoNothingDhcpProxyScriptFetcher());
   1703 
   1704   // Start 2 requests.
   1705 
   1706   ProxyInfo info1;
   1707   TestCompletionCallback callback1;
   1708   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1709                                 callback1.callback(), NULL, BoundNetLog());
   1710   EXPECT_EQ(ERR_IO_PENDING, rv);
   1711 
   1712   ProxyInfo info2;
   1713   TestCompletionCallback callback2;
   1714   ProxyService::PacRequest* request2;
   1715   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1716                             callback2.callback(), &request2, BoundNetLog());
   1717   EXPECT_EQ(ERR_IO_PENDING, rv);
   1718 
   1719   // Check that nothing has been sent to the proxy resolver yet.
   1720   ASSERT_EQ(0u, resolver->pending_requests().size());
   1721 
   1722   // It should be trying to auto-detect first -- FAIL the autodetect during
   1723   // the script download.
   1724   EXPECT_TRUE(fetcher->has_pending_request());
   1725   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   1726   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
   1727 
   1728   // Next it should be trying the custom PAC url.
   1729   EXPECT_TRUE(fetcher->has_pending_request());
   1730   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1731   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   1732 
   1733   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   1734             resolver->pending_set_pac_script_request()->script_data()->utf16());
   1735   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1736 
   1737   // Now finally, the pending requests should have been sent to the resolver
   1738   // (which was initialized with custom PAC script).
   1739 
   1740   ASSERT_EQ(2u, resolver->pending_requests().size());
   1741   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   1742   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
   1743 
   1744   // Complete the pending requests.
   1745   resolver->pending_requests()[1]->results()->UseNamedProxy("request2:80");
   1746   resolver->pending_requests()[1]->CompleteNow(OK);
   1747   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   1748   resolver->pending_requests()[0]->CompleteNow(OK);
   1749 
   1750   // Verify that requests ran as expected.
   1751   EXPECT_EQ(OK, callback1.WaitForResult());
   1752   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   1753   EXPECT_FALSE(info1.proxy_resolve_start_time().is_null());
   1754   EXPECT_FALSE(info1.proxy_resolve_end_time().is_null());
   1755   EXPECT_LE(info1.proxy_resolve_start_time(), info1.proxy_resolve_end_time());
   1756 
   1757   EXPECT_EQ(OK, callback2.WaitForResult());
   1758   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   1759   EXPECT_FALSE(info2.proxy_resolve_start_time().is_null());
   1760   EXPECT_FALSE(info2.proxy_resolve_end_time().is_null());
   1761   EXPECT_LE(info2.proxy_resolve_start_time(), info2.proxy_resolve_end_time());
   1762 }
   1763 
   1764 // This is the same test as FallbackFromAutodetectToCustomPac, except
   1765 // the auto-detect script fails parsing rather than downloading.
   1766 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac2) {
   1767   ProxyConfig config;
   1768   config.set_auto_detect(true);
   1769   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   1770   config.proxy_rules().ParseFromString("http=foopy:80");  // Won't be used.
   1771 
   1772   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   1773   MockAsyncProxyResolverExpectsBytes* resolver =
   1774       new MockAsyncProxyResolverExpectsBytes;
   1775   ProxyService service(config_service, resolver, NULL);
   1776 
   1777   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1778   service.SetProxyScriptFetchers(fetcher,
   1779                                  new DoNothingDhcpProxyScriptFetcher());
   1780 
   1781   // Start 2 requests.
   1782 
   1783   ProxyInfo info1;
   1784   TestCompletionCallback callback1;
   1785   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1786                                 callback1.callback(), NULL, BoundNetLog());
   1787   EXPECT_EQ(ERR_IO_PENDING, rv);
   1788 
   1789   ProxyInfo info2;
   1790   TestCompletionCallback callback2;
   1791   ProxyService::PacRequest* request2;
   1792   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1793                             callback2.callback(), &request2, BoundNetLog());
   1794   EXPECT_EQ(ERR_IO_PENDING, rv);
   1795 
   1796   // Check that nothing has been sent to the proxy resolver yet.
   1797   ASSERT_EQ(0u, resolver->pending_requests().size());
   1798 
   1799   // It should be trying to auto-detect first -- succeed the download.
   1800   EXPECT_TRUE(fetcher->has_pending_request());
   1801   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   1802   fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
   1803 
   1804   // The script contents passed failed basic verification step (since didn't
   1805   // contain token FindProxyForURL), so it was never passed to the resolver.
   1806 
   1807   // Next it should be trying the custom PAC url.
   1808   EXPECT_TRUE(fetcher->has_pending_request());
   1809   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1810   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   1811 
   1812   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   1813             resolver->pending_set_pac_script_request()->script_data()->utf16());
   1814   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1815 
   1816   // Now finally, the pending requests should have been sent to the resolver
   1817   // (which was initialized with custom PAC script).
   1818 
   1819   ASSERT_EQ(2u, resolver->pending_requests().size());
   1820   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   1821   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[1]->url());
   1822 
   1823   // Complete the pending requests.
   1824   resolver->pending_requests()[1]->results()->UseNamedProxy("request2:80");
   1825   resolver->pending_requests()[1]->CompleteNow(OK);
   1826   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   1827   resolver->pending_requests()[0]->CompleteNow(OK);
   1828 
   1829   // Verify that requests ran as expected.
   1830   EXPECT_EQ(OK, callback1.WaitForResult());
   1831   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   1832 
   1833   EXPECT_EQ(OK, callback2.WaitForResult());
   1834   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   1835 }
   1836 
   1837 // Test that if all of auto-detect, a custom PAC script, and manual settings
   1838 // are given, then we will try them in that order.
   1839 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
   1840   ProxyConfig config;
   1841   config.set_auto_detect(true);
   1842   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   1843   config.proxy_rules().ParseFromString("http=foopy:80");
   1844 
   1845   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   1846   MockAsyncProxyResolverExpectsBytes* resolver =
   1847       new MockAsyncProxyResolverExpectsBytes;
   1848   ProxyService service(config_service, resolver, NULL);
   1849 
   1850   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1851   service.SetProxyScriptFetchers(fetcher,
   1852                                  new DoNothingDhcpProxyScriptFetcher());
   1853 
   1854   // Start 2 requests.
   1855 
   1856   ProxyInfo info1;
   1857   TestCompletionCallback callback1;
   1858   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   1859                                 callback1.callback(), NULL, BoundNetLog());
   1860   EXPECT_EQ(ERR_IO_PENDING, rv);
   1861 
   1862   ProxyInfo info2;
   1863   TestCompletionCallback callback2;
   1864   ProxyService::PacRequest* request2;
   1865   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   1866                             callback2.callback(), &request2, BoundNetLog());
   1867   EXPECT_EQ(ERR_IO_PENDING, rv);
   1868 
   1869   // Check that nothing has been sent to the proxy resolver yet.
   1870   ASSERT_EQ(0u, resolver->pending_requests().size());
   1871 
   1872   // It should be trying to auto-detect first -- fail the download.
   1873   EXPECT_TRUE(fetcher->has_pending_request());
   1874   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   1875   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
   1876 
   1877   // Next it should be trying the custom PAC url -- fail the download.
   1878   EXPECT_TRUE(fetcher->has_pending_request());
   1879   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1880   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
   1881 
   1882   // Since we never managed to initialize a ProxyResolver, nothing should have
   1883   // been sent to it.
   1884   ASSERT_EQ(0u, resolver->pending_requests().size());
   1885 
   1886   // Verify that requests ran as expected -- they should have fallen back to
   1887   // the manual proxy configuration for HTTP urls.
   1888   EXPECT_EQ(OK, callback1.WaitForResult());
   1889   EXPECT_EQ("foopy:80", info1.proxy_server().ToURI());
   1890 
   1891   EXPECT_EQ(OK, callback2.WaitForResult());
   1892   EXPECT_EQ("foopy:80", info2.proxy_server().ToURI());
   1893 }
   1894 
   1895 // Test that the bypass rules are NOT applied when using autodetect.
   1896 TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
   1897   ProxyConfig config;
   1898   config.set_auto_detect(true);
   1899   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   1900   config.proxy_rules().ParseFromString("http=foopy:80");  // Not used.
   1901   config.proxy_rules().bypass_rules.ParseFromString("www.google.com");
   1902 
   1903   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   1904   MockAsyncProxyResolverExpectsBytes* resolver =
   1905       new MockAsyncProxyResolverExpectsBytes;
   1906   ProxyService service(config_service, resolver, NULL);
   1907 
   1908   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1909   service.SetProxyScriptFetchers(fetcher,
   1910                                  new DoNothingDhcpProxyScriptFetcher());
   1911 
   1912   // Start 1 requests.
   1913 
   1914   ProxyInfo info1;
   1915   TestCompletionCallback callback1;
   1916   int rv = service.ResolveProxy(
   1917       GURL("http://www.google.com"), &info1, callback1.callback(), NULL,
   1918       BoundNetLog());
   1919   EXPECT_EQ(ERR_IO_PENDING, rv);
   1920 
   1921   // Check that nothing has been sent to the proxy resolver yet.
   1922   ASSERT_EQ(0u, resolver->pending_requests().size());
   1923 
   1924   // It should be trying to auto-detect first -- succeed the download.
   1925   EXPECT_TRUE(fetcher->has_pending_request());
   1926   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   1927   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   1928 
   1929   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   1930             resolver->pending_set_pac_script_request()->script_data()->utf16());
   1931   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   1932 
   1933   ASSERT_EQ(1u, resolver->pending_requests().size());
   1934   EXPECT_EQ(GURL("http://www.google.com"),
   1935             resolver->pending_requests()[0]->url());
   1936 
   1937   // Complete the pending request.
   1938   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   1939   resolver->pending_requests()[0]->CompleteNow(OK);
   1940 
   1941   // Verify that request ran as expected.
   1942   EXPECT_EQ(OK, callback1.WaitForResult());
   1943   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   1944 
   1945   // Start another request, it should pickup the bypass item.
   1946   ProxyInfo info2;
   1947   TestCompletionCallback callback2;
   1948   rv = service.ResolveProxy(GURL("http://www.google.com"), &info2,
   1949                             callback2.callback(), NULL, BoundNetLog());
   1950   EXPECT_EQ(ERR_IO_PENDING, rv);
   1951 
   1952   ASSERT_EQ(1u, resolver->pending_requests().size());
   1953   EXPECT_EQ(GURL("http://www.google.com"),
   1954             resolver->pending_requests()[0]->url());
   1955 
   1956   // Complete the pending request.
   1957   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   1958   resolver->pending_requests()[0]->CompleteNow(OK);
   1959 
   1960   EXPECT_EQ(OK, callback2.WaitForResult());
   1961   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   1962 }
   1963 
   1964 // Delete the ProxyService while InitProxyResolver has an outstanding
   1965 // request to the script fetcher. When run under valgrind, should not
   1966 // have any memory errors (used to be that the ProxyScriptFetcher was
   1967 // being deleted prior to the InitProxyResolver).
   1968 TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
   1969   ProxyConfig config =
   1970     ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
   1971 
   1972   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   1973   MockAsyncProxyResolverExpectsBytes* resolver =
   1974       new MockAsyncProxyResolverExpectsBytes;
   1975   ProxyService service(config_service, resolver, NULL);
   1976 
   1977   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   1978   service.SetProxyScriptFetchers(fetcher,
   1979                                  new DoNothingDhcpProxyScriptFetcher());
   1980 
   1981   // Start 1 request.
   1982 
   1983   ProxyInfo info1;
   1984   TestCompletionCallback callback1;
   1985   int rv = service.ResolveProxy(GURL("http://www.google.com"), &info1,
   1986                                 callback1.callback(), NULL, BoundNetLog());
   1987   EXPECT_EQ(ERR_IO_PENDING, rv);
   1988 
   1989   // Check that nothing has been sent to the proxy resolver yet.
   1990   ASSERT_EQ(0u, resolver->pending_requests().size());
   1991 
   1992   // InitProxyResolver should have issued a request to the ProxyScriptFetcher
   1993   // and be waiting on that to complete.
   1994   EXPECT_TRUE(fetcher->has_pending_request());
   1995   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   1996 }
   1997 
   1998 // Delete the ProxyService while InitProxyResolver has an outstanding
   1999 // request to the proxy resolver. When run under valgrind, should not
   2000 // have any memory errors (used to be that the ProxyResolver was
   2001 // being deleted prior to the InitProxyResolver).
   2002 TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingSet) {
   2003   MockProxyConfigService* config_service =
   2004       new MockProxyConfigService("http://foopy/proxy.pac");
   2005 
   2006   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   2007 
   2008   ProxyService service(config_service, resolver, NULL);
   2009 
   2010   GURL url("http://www.google.com/");
   2011 
   2012   ProxyInfo info;
   2013   TestCompletionCallback callback;
   2014   int rv = service.ResolveProxy(
   2015       url, &info, callback.callback(), NULL, BoundNetLog());
   2016   EXPECT_EQ(ERR_IO_PENDING, rv);
   2017 
   2018   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
   2019             resolver->pending_set_pac_script_request()->script_data()->url());
   2020 }
   2021 
   2022 TEST_F(ProxyServiceTest, ResetProxyConfigService) {
   2023   ProxyConfig config1;
   2024   config1.proxy_rules().ParseFromString("foopy1:8080");
   2025   config1.set_auto_detect(false);
   2026   ProxyService service(
   2027       new MockProxyConfigService(config1),
   2028       new MockAsyncProxyResolverExpectsBytes, NULL);
   2029 
   2030   ProxyInfo info;
   2031   TestCompletionCallback callback1;
   2032   int rv = service.ResolveProxy(GURL("http://request1"), &info,
   2033                                 callback1.callback(), NULL, BoundNetLog());
   2034   EXPECT_EQ(OK, rv);
   2035   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   2036 
   2037   ProxyConfig config2;
   2038   config2.proxy_rules().ParseFromString("foopy2:8080");
   2039   config2.set_auto_detect(false);
   2040   service.ResetConfigService(new MockProxyConfigService(config2));
   2041   TestCompletionCallback callback2;
   2042   rv = service.ResolveProxy(GURL("http://request2"), &info,
   2043                             callback2.callback(), NULL, BoundNetLog());
   2044   EXPECT_EQ(OK, rv);
   2045   EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
   2046 }
   2047 
   2048 // Test that when going from a configuration that required PAC to one
   2049 // that does NOT, we unset the variable |should_use_proxy_resolver_|.
   2050 TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   2051   ProxyConfig config = ProxyConfig::CreateAutoDetect();
   2052 
   2053   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   2054   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
   2055   ProxyService service(config_service, resolver, NULL);
   2056 
   2057   // Start 1 request.
   2058 
   2059   ProxyInfo info1;
   2060   TestCompletionCallback callback1;
   2061   int rv = service.ResolveProxy(GURL("http://www.google.com"), &info1,
   2062                                 callback1.callback(), NULL, BoundNetLog());
   2063   EXPECT_EQ(ERR_IO_PENDING, rv);
   2064 
   2065   // Check that nothing has been sent to the proxy resolver yet.
   2066   ASSERT_EQ(0u, resolver->pending_requests().size());
   2067 
   2068   // Successfully set the autodetect script.
   2069   EXPECT_EQ(ProxyResolverScriptData::TYPE_AUTO_DETECT,
   2070             resolver->pending_set_pac_script_request()->script_data()->type());
   2071   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2072 
   2073   // Complete the pending request.
   2074   ASSERT_EQ(1u, resolver->pending_requests().size());
   2075   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   2076   resolver->pending_requests()[0]->CompleteNow(OK);
   2077 
   2078   // Verify that request ran as expected.
   2079   EXPECT_EQ(OK, callback1.WaitForResult());
   2080   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   2081 
   2082   // Force the ProxyService to pull down a new proxy configuration.
   2083   // (Even though the configuration isn't old/bad).
   2084   //
   2085   // This new configuration no longer has auto_detect set, so
   2086   // requests should complete synchronously now as direct-connect.
   2087   config_service->SetConfig(ProxyConfig::CreateDirect());
   2088 
   2089   // Start another request -- the effective configuration has changed.
   2090   ProxyInfo info2;
   2091   TestCompletionCallback callback2;
   2092   rv = service.ResolveProxy(GURL("http://www.google.com"), &info2,
   2093                             callback2.callback(), NULL, BoundNetLog());
   2094   EXPECT_EQ(OK, rv);
   2095 
   2096   EXPECT_TRUE(info2.is_direct());
   2097 }
   2098 
   2099 TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   2100   MockProxyConfigService* config_service =
   2101       new MockProxyConfigService("http://foopy/proxy.pac");
   2102 
   2103   MockAsyncProxyResolverExpectsBytes* resolver =
   2104       new MockAsyncProxyResolverExpectsBytes;
   2105 
   2106   CapturingNetLog log;
   2107 
   2108   ProxyService service(config_service, resolver, &log);
   2109 
   2110   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   2111   service.SetProxyScriptFetchers(fetcher,
   2112                                  new DoNothingDhcpProxyScriptFetcher());
   2113 
   2114   // Disable the "wait after IP address changes" hack, so this unit-test can
   2115   // complete quickly.
   2116   service.set_stall_proxy_auto_config_delay(base::TimeDelta());
   2117 
   2118   // Start 1 request.
   2119 
   2120   ProxyInfo info1;
   2121   TestCompletionCallback callback1;
   2122   int rv = service.ResolveProxy(GURL("http://request1"), &info1,
   2123                                 callback1.callback(), NULL, BoundNetLog());
   2124   EXPECT_EQ(ERR_IO_PENDING, rv);
   2125 
   2126   // The first request should have triggered initial download of PAC script.
   2127   EXPECT_TRUE(fetcher->has_pending_request());
   2128   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2129 
   2130   // Nothing has been sent to the resolver yet.
   2131   EXPECT_TRUE(resolver->pending_requests().empty());
   2132 
   2133   // At this point the ProxyService should be waiting for the
   2134   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   2135   // PAC script download completion.
   2136   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2137 
   2138   // Now that the PAC script is downloaded, the request will have been sent to
   2139   // the proxy resolver.
   2140   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   2141             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2142   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2143 
   2144   ASSERT_EQ(1u, resolver->pending_requests().size());
   2145   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   2146 
   2147   // Complete the pending request.
   2148   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   2149   resolver->pending_requests()[0]->CompleteNow(OK);
   2150 
   2151   // Wait for completion callback, and verify that the request ran as expected.
   2152   EXPECT_EQ(OK, callback1.WaitForResult());
   2153   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   2154 
   2155   // Now simluate a change in the network. The ProxyConfigService is still
   2156   // going to return the same PAC URL as before, but this URL needs to be
   2157   // refetched on the new network.
   2158   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   2159   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   2160 
   2161   // Start a second request.
   2162   ProxyInfo info2;
   2163   TestCompletionCallback callback2;
   2164   rv = service.ResolveProxy(GURL("http://request2"), &info2,
   2165                             callback2.callback(), NULL, BoundNetLog());
   2166   EXPECT_EQ(ERR_IO_PENDING, rv);
   2167 
   2168   // This second request should have triggered the re-download of the PAC
   2169   // script (since we marked the network as having changed).
   2170   EXPECT_TRUE(fetcher->has_pending_request());
   2171   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2172 
   2173   // Nothing has been sent to the resolver yet.
   2174   EXPECT_TRUE(resolver->pending_requests().empty());
   2175 
   2176   // Simulate the PAC script fetch as having completed (this time with
   2177   // different data).
   2178   fetcher->NotifyFetchCompletion(OK, kValidPacScript2);
   2179 
   2180   // Now that the PAC script is downloaded, the second request will have been
   2181   // sent to the proxy resolver.
   2182   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
   2183             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2184   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2185 
   2186   ASSERT_EQ(1u, resolver->pending_requests().size());
   2187   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
   2188 
   2189   // Complete the pending second request.
   2190   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   2191   resolver->pending_requests()[0]->CompleteNow(OK);
   2192 
   2193   // Wait for completion callback, and verify that the request ran as expected.
   2194   EXPECT_EQ(OK, callback2.WaitForResult());
   2195   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   2196 
   2197   // Check that the expected events were output to the log stream. In particular
   2198   // PROXY_CONFIG_CHANGED should have only been emitted once (for the initial
   2199   // setup), and NOT a second time when the IP address changed.
   2200   CapturingNetLog::CapturedEntryList entries;
   2201   log.GetEntries(&entries);
   2202 
   2203   EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
   2204                                        NetLog::TYPE_PROXY_CONFIG_CHANGED));
   2205   ASSERT_EQ(9u, entries.size());
   2206   for (size_t i = 1; i < entries.size(); ++i)
   2207     EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, entries[i].type);
   2208 }
   2209 
   2210 // This test verifies that the PAC script specified by the settings is
   2211 // periodically polled for changes. Specifically, if the initial fetch fails due
   2212 // to a network error, we will eventually re-configure the service to use the
   2213 // script once it becomes available.
   2214 TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
   2215   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   2216   // runs quickly.
   2217   ImmediatePollPolicy poll_policy;
   2218   ProxyService::set_pac_script_poll_policy(&poll_policy);
   2219 
   2220   MockProxyConfigService* config_service =
   2221       new MockProxyConfigService("http://foopy/proxy.pac");
   2222 
   2223   MockAsyncProxyResolverExpectsBytes* resolver =
   2224       new MockAsyncProxyResolverExpectsBytes;
   2225 
   2226   ProxyService service(config_service, resolver, NULL);
   2227 
   2228   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   2229   service.SetProxyScriptFetchers(fetcher,
   2230                                  new DoNothingDhcpProxyScriptFetcher());
   2231 
   2232   // Start 1 request.
   2233 
   2234   ProxyInfo info1;
   2235   TestCompletionCallback callback1;
   2236   int rv = service.ResolveProxy(
   2237       GURL("http://request1"), &info1, callback1.callback(),
   2238       NULL, BoundNetLog());
   2239   EXPECT_EQ(ERR_IO_PENDING, rv);
   2240 
   2241   // The first request should have triggered initial download of PAC script.
   2242   EXPECT_TRUE(fetcher->has_pending_request());
   2243   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2244 
   2245   // Nothing has been sent to the resolver yet.
   2246   EXPECT_TRUE(resolver->pending_requests().empty());
   2247 
   2248   // At this point the ProxyService should be waiting for the
   2249   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   2250   // PAC script download completion.
   2251   //
   2252   // We simulate a failed download attempt, the proxy service should now
   2253   // fall-back to DIRECT connections.
   2254   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
   2255 
   2256   ASSERT_TRUE(resolver->pending_requests().empty());
   2257 
   2258   // Wait for completion callback, and verify it used DIRECT.
   2259   EXPECT_EQ(OK, callback1.WaitForResult());
   2260   EXPECT_TRUE(info1.is_direct());
   2261 
   2262   // At this point we have initialized the proxy service using a PAC script,
   2263   // however it failed and fell-back to DIRECT.
   2264   //
   2265   // A background task to periodically re-check the PAC script for validity will
   2266   // have been started. We will now wait for the next download attempt to start.
   2267   //
   2268   // Note that we shouldn't have to wait long here, since our test enables a
   2269   // special unit-test mode.
   2270   fetcher->WaitUntilFetch();
   2271 
   2272   ASSERT_TRUE(resolver->pending_requests().empty());
   2273 
   2274   // Make sure that our background checker is trying to download the expected
   2275   // PAC script (same one as before). This time we will simulate a successful
   2276   // download of the script.
   2277   EXPECT_TRUE(fetcher->has_pending_request());
   2278   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2279   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2280 
   2281   base::MessageLoop::current()->RunUntilIdle();
   2282 
   2283   // Now that the PAC script is downloaded, it should be used to initialize the
   2284   // ProxyResolver. Simulate a successful parse.
   2285   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   2286             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2287   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2288 
   2289   // At this point the ProxyService should have re-configured itself to use the
   2290   // PAC script (thereby recovering from the initial fetch failure). We will
   2291   // verify that the next Resolve request uses the resolver rather than
   2292   // DIRECT.
   2293 
   2294   // Start a second request.
   2295   ProxyInfo info2;
   2296   TestCompletionCallback callback2;
   2297   rv = service.ResolveProxy(
   2298       GURL("http://request2"), &info2, callback2.callback(), NULL,
   2299       BoundNetLog());
   2300   EXPECT_EQ(ERR_IO_PENDING, rv);
   2301 
   2302   // Check that it was sent to the resolver.
   2303   ASSERT_EQ(1u, resolver->pending_requests().size());
   2304   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
   2305 
   2306   // Complete the pending second request.
   2307   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   2308   resolver->pending_requests()[0]->CompleteNow(OK);
   2309 
   2310   // Wait for completion callback, and verify that the request ran as expected.
   2311   EXPECT_EQ(OK, callback2.WaitForResult());
   2312   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   2313 }
   2314 
   2315 // This test verifies that the PAC script specified by the settings is
   2316 // periodically polled for changes. Specifically, if the initial fetch succeeds,
   2317 // however at a later time its *contents* change, we will eventually
   2318 // re-configure the service to use the new script.
   2319 TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
   2320   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   2321   // runs quickly.
   2322   ImmediatePollPolicy poll_policy;
   2323   ProxyService::set_pac_script_poll_policy(&poll_policy);
   2324 
   2325   MockProxyConfigService* config_service =
   2326       new MockProxyConfigService("http://foopy/proxy.pac");
   2327 
   2328   MockAsyncProxyResolverExpectsBytes* resolver =
   2329       new MockAsyncProxyResolverExpectsBytes;
   2330 
   2331   ProxyService service(config_service, resolver, NULL);
   2332 
   2333   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   2334   service.SetProxyScriptFetchers(fetcher,
   2335                                  new DoNothingDhcpProxyScriptFetcher());
   2336 
   2337   // Start 1 request.
   2338 
   2339   ProxyInfo info1;
   2340   TestCompletionCallback callback1;
   2341   int rv = service.ResolveProxy(
   2342       GURL("http://request1"), &info1, callback1.callback(), NULL,
   2343       BoundNetLog());
   2344   EXPECT_EQ(ERR_IO_PENDING, rv);
   2345 
   2346   // The first request should have triggered initial download of PAC script.
   2347   EXPECT_TRUE(fetcher->has_pending_request());
   2348   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2349 
   2350   // Nothing has been sent to the resolver yet.
   2351   EXPECT_TRUE(resolver->pending_requests().empty());
   2352 
   2353   // At this point the ProxyService should be waiting for the
   2354   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   2355   // PAC script download completion.
   2356   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2357 
   2358   // Now that the PAC script is downloaded, the request will have been sent to
   2359   // the proxy resolver.
   2360   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   2361             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2362   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2363 
   2364   ASSERT_EQ(1u, resolver->pending_requests().size());
   2365   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   2366 
   2367   // Complete the pending request.
   2368   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   2369   resolver->pending_requests()[0]->CompleteNow(OK);
   2370 
   2371   // Wait for completion callback, and verify that the request ran as expected.
   2372   EXPECT_EQ(OK, callback1.WaitForResult());
   2373   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   2374 
   2375   // At this point we have initialized the proxy service using a PAC script.
   2376   //
   2377   // A background task to periodically re-check the PAC script for validity will
   2378   // have been started. We will now wait for the next download attempt to start.
   2379   //
   2380   // Note that we shouldn't have to wait long here, since our test enables a
   2381   // special unit-test mode.
   2382   fetcher->WaitUntilFetch();
   2383 
   2384   ASSERT_TRUE(resolver->pending_requests().empty());
   2385 
   2386   // Make sure that our background checker is trying to download the expected
   2387   // PAC script (same one as before). This time we will simulate a successful
   2388   // download of a DIFFERENT script.
   2389   EXPECT_TRUE(fetcher->has_pending_request());
   2390   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2391   fetcher->NotifyFetchCompletion(OK, kValidPacScript2);
   2392 
   2393   base::MessageLoop::current()->RunUntilIdle();
   2394 
   2395   // Now that the PAC script is downloaded, it should be used to initialize the
   2396   // ProxyResolver. Simulate a successful parse.
   2397   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
   2398             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2399   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2400 
   2401   // At this point the ProxyService should have re-configured itself to use the
   2402   // new PAC script.
   2403 
   2404   // Start a second request.
   2405   ProxyInfo info2;
   2406   TestCompletionCallback callback2;
   2407   rv = service.ResolveProxy(
   2408       GURL("http://request2"), &info2, callback2.callback(), NULL,
   2409       BoundNetLog());
   2410   EXPECT_EQ(ERR_IO_PENDING, rv);
   2411 
   2412   // Check that it was sent to the resolver.
   2413   ASSERT_EQ(1u, resolver->pending_requests().size());
   2414   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
   2415 
   2416   // Complete the pending second request.
   2417   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   2418   resolver->pending_requests()[0]->CompleteNow(OK);
   2419 
   2420   // Wait for completion callback, and verify that the request ran as expected.
   2421   EXPECT_EQ(OK, callback2.WaitForResult());
   2422   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   2423 }
   2424 
   2425 // This test verifies that the PAC script specified by the settings is
   2426 // periodically polled for changes. Specifically, if the initial fetch succeeds
   2427 // and so does the next poll, however the contents of the downloaded script
   2428 // have NOT changed, then we do not bother to re-initialize the proxy resolver.
   2429 TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
   2430   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   2431   // runs quickly.
   2432   ImmediatePollPolicy poll_policy;
   2433   ProxyService::set_pac_script_poll_policy(&poll_policy);
   2434 
   2435   MockProxyConfigService* config_service =
   2436       new MockProxyConfigService("http://foopy/proxy.pac");
   2437 
   2438   MockAsyncProxyResolverExpectsBytes* resolver =
   2439       new MockAsyncProxyResolverExpectsBytes;
   2440 
   2441   ProxyService service(config_service, resolver, NULL);
   2442 
   2443   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   2444   service.SetProxyScriptFetchers(fetcher,
   2445                                  new DoNothingDhcpProxyScriptFetcher());
   2446 
   2447   // Start 1 request.
   2448 
   2449   ProxyInfo info1;
   2450   TestCompletionCallback callback1;
   2451   int rv = service.ResolveProxy(
   2452       GURL("http://request1"), &info1, callback1.callback(), NULL,
   2453       BoundNetLog());
   2454   EXPECT_EQ(ERR_IO_PENDING, rv);
   2455 
   2456   // The first request should have triggered initial download of PAC script.
   2457   EXPECT_TRUE(fetcher->has_pending_request());
   2458   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2459 
   2460   // Nothing has been sent to the resolver yet.
   2461   EXPECT_TRUE(resolver->pending_requests().empty());
   2462 
   2463   // At this point the ProxyService should be waiting for the
   2464   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   2465   // PAC script download completion.
   2466   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2467 
   2468   // Now that the PAC script is downloaded, the request will have been sent to
   2469   // the proxy resolver.
   2470   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   2471             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2472   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2473 
   2474   ASSERT_EQ(1u, resolver->pending_requests().size());
   2475   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   2476 
   2477   // Complete the pending request.
   2478   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   2479   resolver->pending_requests()[0]->CompleteNow(OK);
   2480 
   2481   // Wait for completion callback, and verify that the request ran as expected.
   2482   EXPECT_EQ(OK, callback1.WaitForResult());
   2483   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   2484 
   2485   // At this point we have initialized the proxy service using a PAC script.
   2486   //
   2487   // A background task to periodically re-check the PAC script for validity will
   2488   // have been started. We will now wait for the next download attempt to start.
   2489   //
   2490   // Note that we shouldn't have to wait long here, since our test enables a
   2491   // special unit-test mode.
   2492   fetcher->WaitUntilFetch();
   2493 
   2494   ASSERT_TRUE(resolver->pending_requests().empty());
   2495 
   2496   // Make sure that our background checker is trying to download the expected
   2497   // PAC script (same one as before). We will simulate the same response as
   2498   // last time (i.e. the script is unchanged).
   2499   EXPECT_TRUE(fetcher->has_pending_request());
   2500   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2501   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2502 
   2503   base::MessageLoop::current()->RunUntilIdle();
   2504 
   2505   ASSERT_FALSE(resolver->has_pending_set_pac_script_request());
   2506 
   2507   // At this point the ProxyService is still running the same PAC script as
   2508   // before.
   2509 
   2510   // Start a second request.
   2511   ProxyInfo info2;
   2512   TestCompletionCallback callback2;
   2513   rv = service.ResolveProxy(
   2514       GURL("http://request2"), &info2, callback2.callback(), NULL,
   2515       BoundNetLog());
   2516   EXPECT_EQ(ERR_IO_PENDING, rv);
   2517 
   2518   // Check that it was sent to the resolver.
   2519   ASSERT_EQ(1u, resolver->pending_requests().size());
   2520   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
   2521 
   2522   // Complete the pending second request.
   2523   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   2524   resolver->pending_requests()[0]->CompleteNow(OK);
   2525 
   2526   // Wait for completion callback, and verify that the request ran as expected.
   2527   EXPECT_EQ(OK, callback2.WaitForResult());
   2528   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   2529 }
   2530 
   2531 // This test verifies that the PAC script specified by the settings is
   2532 // periodically polled for changes. Specifically, if the initial fetch succeeds,
   2533 // however at a later time it starts to fail, we should re-configure the
   2534 // ProxyService to stop using that PAC script.
   2535 TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) {
   2536   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   2537   // runs quickly.
   2538   ImmediatePollPolicy poll_policy;
   2539   ProxyService::set_pac_script_poll_policy(&poll_policy);
   2540 
   2541   MockProxyConfigService* config_service =
   2542       new MockProxyConfigService("http://foopy/proxy.pac");
   2543 
   2544   MockAsyncProxyResolverExpectsBytes* resolver =
   2545       new MockAsyncProxyResolverExpectsBytes;
   2546 
   2547   ProxyService service(config_service, resolver, NULL);
   2548 
   2549   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   2550   service.SetProxyScriptFetchers(fetcher,
   2551                                  new DoNothingDhcpProxyScriptFetcher());
   2552 
   2553   // Start 1 request.
   2554 
   2555   ProxyInfo info1;
   2556   TestCompletionCallback callback1;
   2557   int rv = service.ResolveProxy(
   2558       GURL("http://request1"), &info1, callback1.callback(), NULL,
   2559       BoundNetLog());
   2560   EXPECT_EQ(ERR_IO_PENDING, rv);
   2561 
   2562   // The first request should have triggered initial download of PAC script.
   2563   EXPECT_TRUE(fetcher->has_pending_request());
   2564   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2565 
   2566   // Nothing has been sent to the resolver yet.
   2567   EXPECT_TRUE(resolver->pending_requests().empty());
   2568 
   2569   // At this point the ProxyService should be waiting for the
   2570   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   2571   // PAC script download completion.
   2572   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2573 
   2574   // Now that the PAC script is downloaded, the request will have been sent to
   2575   // the proxy resolver.
   2576   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   2577             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2578   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2579 
   2580   ASSERT_EQ(1u, resolver->pending_requests().size());
   2581   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   2582 
   2583   // Complete the pending request.
   2584   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   2585   resolver->pending_requests()[0]->CompleteNow(OK);
   2586 
   2587   // Wait for completion callback, and verify that the request ran as expected.
   2588   EXPECT_EQ(OK, callback1.WaitForResult());
   2589   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   2590 
   2591   // At this point we have initialized the proxy service using a PAC script.
   2592   //
   2593   // A background task to periodically re-check the PAC script for validity will
   2594   // have been started. We will now wait for the next download attempt to start.
   2595   //
   2596   // Note that we shouldn't have to wait long here, since our test enables a
   2597   // special unit-test mode.
   2598   fetcher->WaitUntilFetch();
   2599 
   2600   ASSERT_TRUE(resolver->pending_requests().empty());
   2601 
   2602   // Make sure that our background checker is trying to download the expected
   2603   // PAC script (same one as before). This time we will simulate a failure
   2604   // to download the script.
   2605   EXPECT_TRUE(fetcher->has_pending_request());
   2606   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2607   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
   2608 
   2609   base::MessageLoop::current()->RunUntilIdle();
   2610 
   2611   // At this point the ProxyService should have re-configured itself to use
   2612   // DIRECT connections rather than the given proxy resolver.
   2613 
   2614   // Start a second request.
   2615   ProxyInfo info2;
   2616   TestCompletionCallback callback2;
   2617   rv = service.ResolveProxy(
   2618       GURL("http://request2"), &info2, callback2.callback(), NULL,
   2619       BoundNetLog());
   2620   EXPECT_EQ(OK, rv);
   2621   EXPECT_TRUE(info2.is_direct());
   2622 }
   2623 
   2624 // Tests that the code which decides at what times to poll the PAC
   2625 // script follows the expected policy.
   2626 TEST_F(ProxyServiceTest, PACScriptPollingPolicy) {
   2627   // Retrieve the internal polling policy implementation used by ProxyService.
   2628   scoped_ptr<ProxyService::PacPollPolicy> policy =
   2629       ProxyService::CreateDefaultPacPollPolicy();
   2630 
   2631   int error;
   2632   ProxyService::PacPollPolicy::Mode mode;
   2633   const base::TimeDelta initial_delay = base::TimeDelta::FromMilliseconds(-1);
   2634   base::TimeDelta delay = initial_delay;
   2635 
   2636   // --------------------------------------------------
   2637   // Test the poll sequence in response to a failure.
   2638   // --------------------------------------------------
   2639   error = ERR_NAME_NOT_RESOLVED;
   2640 
   2641   // Poll #0
   2642   mode = policy->GetNextDelay(error, initial_delay, &delay);
   2643   EXPECT_EQ(8, delay.InSeconds());
   2644   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_USE_TIMER, mode);
   2645 
   2646   // Poll #1
   2647   mode = policy->GetNextDelay(error, delay, &delay);
   2648   EXPECT_EQ(32, delay.InSeconds());
   2649   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2650 
   2651   // Poll #2
   2652   mode = policy->GetNextDelay(error, delay, &delay);
   2653   EXPECT_EQ(120, delay.InSeconds());
   2654   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2655 
   2656   // Poll #3
   2657   mode = policy->GetNextDelay(error, delay, &delay);
   2658   EXPECT_EQ(14400, delay.InSeconds());
   2659   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2660 
   2661   // Poll #4
   2662   mode = policy->GetNextDelay(error, delay, &delay);
   2663   EXPECT_EQ(14400, delay.InSeconds());
   2664   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2665 
   2666   // --------------------------------------------------
   2667   // Test the poll sequence in response to a success.
   2668   // --------------------------------------------------
   2669   error = OK;
   2670 
   2671   // Poll #0
   2672   mode = policy->GetNextDelay(error, initial_delay, &delay);
   2673   EXPECT_EQ(43200, delay.InSeconds());
   2674   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2675 
   2676   // Poll #1
   2677   mode = policy->GetNextDelay(error, delay, &delay);
   2678   EXPECT_EQ(43200, delay.InSeconds());
   2679   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2680 
   2681   // Poll #2
   2682   mode = policy->GetNextDelay(error, delay, &delay);
   2683   EXPECT_EQ(43200, delay.InSeconds());
   2684   EXPECT_EQ(ProxyService::PacPollPolicy::MODE_START_AFTER_ACTIVITY, mode);
   2685 }
   2686 
   2687 // This tests the polling of the PAC script. Specifically, it tests that
   2688 // polling occurs in response to user activity.
   2689 TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
   2690   ImmediateAfterActivityPollPolicy poll_policy;
   2691   ProxyService::set_pac_script_poll_policy(&poll_policy);
   2692 
   2693   MockProxyConfigService* config_service =
   2694       new MockProxyConfigService("http://foopy/proxy.pac");
   2695 
   2696   MockAsyncProxyResolverExpectsBytes* resolver =
   2697       new MockAsyncProxyResolverExpectsBytes;
   2698 
   2699   ProxyService service(config_service, resolver, NULL);
   2700 
   2701   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   2702   service.SetProxyScriptFetchers(fetcher,
   2703                                  new DoNothingDhcpProxyScriptFetcher());
   2704 
   2705   // Start 1 request.
   2706 
   2707   ProxyInfo info1;
   2708   TestCompletionCallback callback1;
   2709   int rv = service.ResolveProxy(
   2710       GURL("http://request1"), &info1, callback1.callback(), NULL,
   2711       BoundNetLog());
   2712   EXPECT_EQ(ERR_IO_PENDING, rv);
   2713 
   2714   // The first request should have triggered initial download of PAC script.
   2715   EXPECT_TRUE(fetcher->has_pending_request());
   2716   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2717 
   2718   // Nothing has been sent to the resolver yet.
   2719   EXPECT_TRUE(resolver->pending_requests().empty());
   2720 
   2721   // At this point the ProxyService should be waiting for the
   2722   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   2723   // PAC script download completion.
   2724   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
   2725 
   2726   // Now that the PAC script is downloaded, the request will have been sent to
   2727   // the proxy resolver.
   2728   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
   2729             resolver->pending_set_pac_script_request()->script_data()->utf16());
   2730   resolver->pending_set_pac_script_request()->CompleteNow(OK);
   2731 
   2732   ASSERT_EQ(1u, resolver->pending_requests().size());
   2733   EXPECT_EQ(GURL("http://request1"), resolver->pending_requests()[0]->url());
   2734 
   2735   // Complete the pending request.
   2736   resolver->pending_requests()[0]->results()->UseNamedProxy("request1:80");
   2737   resolver->pending_requests()[0]->CompleteNow(OK);
   2738 
   2739   // Wait for completion callback, and verify that the request ran as expected.
   2740   EXPECT_EQ(OK, callback1.WaitForResult());
   2741   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   2742 
   2743   // At this point we have initialized the proxy service using a PAC script.
   2744   // Our PAC poller is set to update ONLY in response to network activity,
   2745   // (i.e. another call to ResolveProxy()).
   2746 
   2747   ASSERT_FALSE(fetcher->has_pending_request());
   2748   ASSERT_TRUE(resolver->pending_requests().empty());
   2749 
   2750   // Start a second request.
   2751   ProxyInfo info2;
   2752   TestCompletionCallback callback2;
   2753   rv = service.ResolveProxy(
   2754       GURL("http://request2"), &info2, callback2.callback(), NULL,
   2755       BoundNetLog());
   2756   EXPECT_EQ(ERR_IO_PENDING, rv);
   2757 
   2758   // This request should have sent work to the resolver; complete it.
   2759   ASSERT_EQ(1u, resolver->pending_requests().size());
   2760   EXPECT_EQ(GURL("http://request2"), resolver->pending_requests()[0]->url());
   2761   resolver->pending_requests()[0]->results()->UseNamedProxy("request2:80");
   2762   resolver->pending_requests()[0]->CompleteNow(OK);
   2763 
   2764   EXPECT_EQ(OK, callback2.WaitForResult());
   2765   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   2766 
   2767   // In response to getting that resolve request, the poller should have
   2768   // started the next poll, and made it as far as to request the download.
   2769 
   2770   EXPECT_TRUE(fetcher->has_pending_request());
   2771   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   2772 
   2773   // This time we will fail the download, to simulate a PAC script change.
   2774   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
   2775 
   2776   // Drain the message loop, so ProxyService is notified of the change
   2777   // and has a chance to re-configure itself.
   2778   base::MessageLoop::current()->RunUntilIdle();
   2779 
   2780   // Start a third request -- this time we expect to get a direct connection
   2781   // since the PAC script poller experienced a failure.
   2782   ProxyInfo info3;
   2783   TestCompletionCallback callback3;
   2784   rv = service.ResolveProxy(
   2785       GURL("http://request3"), &info3, callback3.callback(), NULL,
   2786       BoundNetLog());
   2787   EXPECT_EQ(OK, rv);
   2788   EXPECT_TRUE(info3.is_direct());
   2789 }
   2790 
   2791 }  // namespace net
   2792