src/net/proxy/proxy_script_decider_unittest.cc

   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 <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/memory/weak_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/time/time.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/base/net_log.h"
  16 #include "net/base/net_log_unittest.h"
  17 #include "net/base/test_completion_callback.h"
  18 #include "net/dns/mock_host_resolver.h"
  19 #include "net/proxy/dhcp_proxy_script_fetcher.h"
  20 #include "net/proxy/proxy_config.h"
  21 #include "net/proxy/proxy_resolver.h"
  22 #include "net/proxy/proxy_script_decider.h"
  23 #include "net/proxy/proxy_script_fetcher.h"
  24 #include "net/url_request/url_request_context.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 namespace net {
  28 namespace {
  29
  30 enum Error {
  31   kFailedDownloading = -100,
  32   kFailedParsing = ERR_PAC_SCRIPT_FAILED,
  33 };
  34
  35 class Rules {
  36  public:
  37   struct Rule {
  38     Rule(const GURL& url, int fetch_error, bool is_valid_script)
  39         : url(url),
  40           fetch_error(fetch_error),
  41           is_valid_script(is_valid_script) {
  42     }
  43
  44     base::string16 text() const {
  45       if (is_valid_script)
  46         return UTF8ToUTF16(url.spec() + "!FindProxyForURL");
  47       if (fetch_error == OK)
  48         return UTF8ToUTF16(url.spec() + "!invalid-script");
  49       return base::string16();
  50     }
  51
  52     GURL url;
  53     int fetch_error;
  54     bool is_valid_script;
  55   };
  56
  57   Rule AddSuccessRule(const char* url) {
  58     Rule rule(GURL(url), OK /*fetch_error*/, true);
  59     rules_.push_back(rule);
  60     return rule;
  61   }
  62
  63   void AddFailDownloadRule(const char* url) {
  64     rules_.push_back(Rule(GURL(url), kFailedDownloading /*fetch_error*/,
  65         false));
  66   }
  67
  68   void AddFailParsingRule(const char* url) {
  69     rules_.push_back(Rule(GURL(url), OK /*fetch_error*/, false));
  70   }
  71
  72   const Rule& GetRuleByUrl(const GURL& url) const {
  73     for (RuleList::const_iterator it = rules_.begin(); it != rules_.end();
  74          ++it) {
  75       if (it->url == url)
  76         return *it;
  77     }
  78     LOG(FATAL) << "Rule not found for " << url;
  79     return rules_[0];
  80   }
  81
  82   const Rule& GetRuleByText(const base::string16& text) const {
  83     for (RuleList::const_iterator it = rules_.begin(); it != rules_.end();
  84          ++it) {
  85       if (it->text() == text)
  86         return *it;
  87     }
  88     LOG(FATAL) << "Rule not found for " << text;
  89     return rules_[0];
  90   }
  91
  92  private:
  93   typedef std::vector<Rule> RuleList;
  94   RuleList rules_;
  95 };
  96
  97 class RuleBasedProxyScriptFetcher : public ProxyScriptFetcher {
  98  public:
  99   explicit RuleBasedProxyScriptFetcher(const Rules* rules)
 100       : rules_(rules), request_context_(NULL) {}
 101
 102   virtual void SetRequestContext(URLRequestContext* context) {
 103     request_context_ = context;
 104   }
 105
 106   // ProxyScriptFetcher implementation.
 107   virtual int Fetch(const GURL& url,
 108                     base::string16* text,
 109                     const CompletionCallback& callback) OVERRIDE {
 110     const Rules::Rule& rule = rules_->GetRuleByUrl(url);
 111     int rv = rule.fetch_error;
 112     EXPECT_NE(ERR_UNEXPECTED, rv);
 113     if (rv == OK)
 114       *text = rule.text();
 115     return rv;
 116   }
 117
 118   virtual void Cancel() OVERRIDE {}
 119
 120   virtual URLRequestContext* GetRequestContext() const OVERRIDE {
 121     return request_context_;
 122   }
 123
 124  private:
 125   const Rules* rules_;
 126   URLRequestContext* request_context_;
 127 };
 128
 129 // Succeed using custom PAC script.
 130 TEST(ProxyScriptDeciderTest, CustomPacSucceeds) {
 131   Rules rules;
 132   RuleBasedProxyScriptFetcher fetcher(&rules);
 133   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 134
 135   ProxyConfig config;
 136   config.set_pac_url(GURL("http://custom/proxy.pac"));
 137
 138   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 139
 140   TestCompletionCallback callback;
 141   CapturingNetLog log;
 142   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
 143   EXPECT_EQ(OK, decider.Start(
 144       config, base::TimeDelta(), true, callback.callback()));
 145   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 146
 147   // Check the NetLog was filled correctly.
 148   CapturingNetLog::CapturedEntryList entries;
 149   log.GetEntries(&entries);
 150
 151   EXPECT_EQ(4u, entries.size());
 152   EXPECT_TRUE(LogContainsBeginEvent(
 153       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 154   EXPECT_TRUE(LogContainsBeginEvent(
 155       entries, 1, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 156   EXPECT_TRUE(LogContainsEndEvent(
 157       entries, 2, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 158   EXPECT_TRUE(LogContainsEndEvent(
 159       entries, 3, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 160
 161   EXPECT_TRUE(decider.effective_config().has_pac_url());
 162   EXPECT_EQ(config.pac_url(), decider.effective_config().pac_url());
 163 }
 164
 165 // Fail downloading the custom PAC script.
 166 TEST(ProxyScriptDeciderTest, CustomPacFails1) {
 167   Rules rules;
 168   RuleBasedProxyScriptFetcher fetcher(&rules);
 169   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 170
 171   ProxyConfig config;
 172   config.set_pac_url(GURL("http://custom/proxy.pac"));
 173
 174   rules.AddFailDownloadRule("http://custom/proxy.pac");
 175
 176   TestCompletionCallback callback;
 177   CapturingNetLog log;
 178   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
 179   EXPECT_EQ(kFailedDownloading,
 180             decider.Start(config, base::TimeDelta(), true,
 181                           callback.callback()));
 182   EXPECT_EQ(NULL, decider.script_data());
 183
 184   // Check the NetLog was filled correctly.
 185   CapturingNetLog::CapturedEntryList entries;
 186   log.GetEntries(&entries);
 187
 188   EXPECT_EQ(4u, entries.size());
 189   EXPECT_TRUE(LogContainsBeginEvent(
 190       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 191   EXPECT_TRUE(LogContainsBeginEvent(
 192       entries, 1, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 193   EXPECT_TRUE(LogContainsEndEvent(
 194       entries, 2, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 195   EXPECT_TRUE(LogContainsEndEvent(
 196       entries, 3, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 197
 198   EXPECT_FALSE(decider.effective_config().has_pac_url());
 199 }
 200
 201 // Fail parsing the custom PAC script.
 202 TEST(ProxyScriptDeciderTest, CustomPacFails2) {
 203   Rules rules;
 204   RuleBasedProxyScriptFetcher fetcher(&rules);
 205   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 206
 207   ProxyConfig config;
 208   config.set_pac_url(GURL("http://custom/proxy.pac"));
 209
 210   rules.AddFailParsingRule("http://custom/proxy.pac");
 211
 212   TestCompletionCallback callback;
 213   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 214   EXPECT_EQ(kFailedParsing,
 215             decider.Start(config, base::TimeDelta(), true,
 216                           callback.callback()));
 217   EXPECT_EQ(NULL, decider.script_data());
 218 }
 219
 220 // Fail downloading the custom PAC script, because the fetcher was NULL.
 221 TEST(ProxyScriptDeciderTest, HasNullProxyScriptFetcher) {
 222   Rules rules;
 223   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 224
 225   ProxyConfig config;
 226   config.set_pac_url(GURL("http://custom/proxy.pac"));
 227
 228   TestCompletionCallback callback;
 229   ProxyScriptDecider decider(NULL, &dhcp_fetcher, NULL);
 230   EXPECT_EQ(ERR_UNEXPECTED,
 231             decider.Start(config, base::TimeDelta(), true,
 232                           callback.callback()));
 233   EXPECT_EQ(NULL, decider.script_data());
 234 }
 235
 236 // Succeeds in choosing autodetect (WPAD DNS).
 237 TEST(ProxyScriptDeciderTest, AutodetectSuccess) {
 238   Rules rules;
 239   RuleBasedProxyScriptFetcher fetcher(&rules);
 240   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 241
 242   ProxyConfig config;
 243   config.set_auto_detect(true);
 244
 245   Rules::Rule rule = rules.AddSuccessRule("http://wpad/wpad.dat");
 246
 247   TestCompletionCallback callback;
 248   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 249   EXPECT_EQ(OK, decider.Start(
 250       config, base::TimeDelta(), true, callback.callback()));
 251   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 252
 253   EXPECT_TRUE(decider.effective_config().has_pac_url());
 254   EXPECT_EQ(rule.url, decider.effective_config().pac_url());
 255 }
 256
 257 class ProxyScriptDeciderQuickCheckTest : public ::testing::Test {
 258  public:
 259   ProxyScriptDeciderQuickCheckTest()
 260       : rule_(rules_.AddSuccessRule("http://wpad/wpad.dat")),
 261         fetcher_(&rules_) { }
 262
 263   virtual void SetUp() OVERRIDE {
 264     request_context_.set_host_resolver(&resolver_);
 265     fetcher_.SetRequestContext(&request_context_);
 266     config_.set_auto_detect(true);
 267     decider_.reset(new ProxyScriptDecider(&fetcher_, &dhcp_fetcher_, NULL));
 268   }
 269
 270   int StartDecider() {
 271     return decider_->Start(config_, base::TimeDelta(), true,
 272                             callback_.callback());
 273   }
 274
 275  protected:
 276   scoped_ptr<ProxyScriptDecider> decider_;
 277   MockHostResolver resolver_;
 278   Rules rules_;
 279   Rules::Rule rule_;
 280   TestCompletionCallback callback_;
 281
 282  private:
 283   URLRequestContext request_context_;
 284
 285   RuleBasedProxyScriptFetcher fetcher_;
 286   DoNothingDhcpProxyScriptFetcher dhcp_fetcher_;
 287
 288   ProxyConfig config_;
 289 };
 290
 291 // Fails if a synchronous DNS lookup success for wpad causes QuickCheck to fail.
 292 TEST_F(ProxyScriptDeciderQuickCheckTest, SyncSuccess) {
 293   resolver_.set_synchronous_mode(true);
 294   resolver_.rules()->AddRule("wpad", "1.2.3.4");
 295
 296   EXPECT_EQ(OK, StartDecider());
 297   EXPECT_EQ(rule_.text(), decider_->script_data()->utf16());
 298
 299   EXPECT_TRUE(decider_->effective_config().has_pac_url());
 300   EXPECT_EQ(rule_.url, decider_->effective_config().pac_url());
 301 }
 302
 303 // Fails if an asynchronous DNS lookup success for wpad causes QuickCheck to
 304 // fail.
 305 TEST_F(ProxyScriptDeciderQuickCheckTest, AsyncSuccess) {
 306   resolver_.set_ondemand_mode(true);
 307   resolver_.rules()->AddRule("wpad", "1.2.3.4");
 308
 309   EXPECT_EQ(ERR_IO_PENDING, StartDecider());
 310   ASSERT_TRUE(resolver_.has_pending_requests());
 311   resolver_.ResolveAllPending();
 312   callback_.WaitForResult();
 313   EXPECT_FALSE(resolver_.has_pending_requests());
 314   EXPECT_EQ(rule_.text(), decider_->script_data()->utf16());
 315   EXPECT_TRUE(decider_->effective_config().has_pac_url());
 316   EXPECT_EQ(rule_.url, decider_->effective_config().pac_url());
 317 }
 318
 319 // Fails if an asynchronous DNS lookup failure (i.e. an NXDOMAIN) still causes
 320 // ProxyScriptDecider to yield a PAC URL.
 321 TEST_F(ProxyScriptDeciderQuickCheckTest, AsyncFail) {
 322   resolver_.set_ondemand_mode(true);
 323   resolver_.rules()->AddSimulatedFailure("wpad");
 324   EXPECT_EQ(ERR_IO_PENDING, StartDecider());
 325   ASSERT_TRUE(resolver_.has_pending_requests());
 326   resolver_.ResolveAllPending();
 327   callback_.WaitForResult();
 328   EXPECT_FALSE(decider_->effective_config().has_pac_url());
 329 }
 330
 331 // Fails if a DNS lookup timeout either causes ProxyScriptDecider to yield a PAC
 332 // URL or causes ProxyScriptDecider not to cancel its pending resolution.
 333 TEST_F(ProxyScriptDeciderQuickCheckTest, AsyncTimeout) {
 334   resolver_.set_ondemand_mode(true);
 335   EXPECT_EQ(ERR_IO_PENDING, StartDecider());
 336   ASSERT_TRUE(resolver_.has_pending_requests());
 337   callback_.WaitForResult();
 338   EXPECT_FALSE(resolver_.has_pending_requests());
 339   EXPECT_FALSE(decider_->effective_config().has_pac_url());
 340 }
 341
 342 // Fails at WPAD (downloading), but succeeds in choosing the custom PAC.
 343 TEST(ProxyScriptDeciderTest, AutodetectFailCustomSuccess1) {
 344   Rules rules;
 345   RuleBasedProxyScriptFetcher fetcher(&rules);
 346   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 347
 348   ProxyConfig config;
 349   config.set_auto_detect(true);
 350   config.set_pac_url(GURL("http://custom/proxy.pac"));
 351
 352   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 353   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 354
 355   TestCompletionCallback callback;
 356   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 357   EXPECT_EQ(OK, decider.Start(
 358       config, base::TimeDelta(), true, callback.callback()));
 359   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 360
 361   EXPECT_TRUE(decider.effective_config().has_pac_url());
 362   EXPECT_EQ(rule.url, decider.effective_config().pac_url());
 363 }
 364
 365 // Fails at WPAD (no DHCP config, DNS PAC fails parsing), but succeeds in
 366 // choosing the custom PAC.
 367 TEST(ProxyScriptDeciderTest, AutodetectFailCustomSuccess2) {
 368   Rules rules;
 369   RuleBasedProxyScriptFetcher fetcher(&rules);
 370   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 371
 372   ProxyConfig config;
 373   config.set_auto_detect(true);
 374   config.set_pac_url(GURL("http://custom/proxy.pac"));
 375   config.proxy_rules().ParseFromString("unused-manual-proxy:99");
 376
 377   rules.AddFailParsingRule("http://wpad/wpad.dat");
 378   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 379
 380   TestCompletionCallback callback;
 381   CapturingNetLog log;
 382
 383   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
 384   EXPECT_EQ(OK, decider.Start(config, base::TimeDelta(),
 385                           true, callback.callback()));
 386   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 387
 388   // Verify that the effective configuration no longer contains auto detect or
 389   // any of the manual settings.
 390   EXPECT_TRUE(decider.effective_config().Equals(
 391       ProxyConfig::CreateFromCustomPacURL(GURL("http://custom/proxy.pac"))));
 392
 393   // Check the NetLog was filled correctly.
 394   // (Note that various states are repeated since both WPAD and custom
 395   // PAC scripts are tried).
 396   CapturingNetLog::CapturedEntryList entries;
 397   log.GetEntries(&entries);
 398
 399   EXPECT_EQ(10u, entries.size());
 400   EXPECT_TRUE(LogContainsBeginEvent(
 401       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 402   // This is the DHCP phase, which fails fetching rather than parsing, so
 403   // there is no pair of SET_PAC_SCRIPT events.
 404   EXPECT_TRUE(LogContainsBeginEvent(
 405       entries, 1, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 406   EXPECT_TRUE(LogContainsEndEvent(
 407       entries, 2, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 408   EXPECT_TRUE(LogContainsEvent(
 409       entries, 3,
 410       NetLog::TYPE_PROXY_SCRIPT_DECIDER_FALLING_BACK_TO_NEXT_PAC_SOURCE,
 411       NetLog::PHASE_NONE));
 412   // This is the DNS phase, which attempts a fetch but fails.
 413   EXPECT_TRUE(LogContainsBeginEvent(
 414       entries, 4, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 415   EXPECT_TRUE(LogContainsEndEvent(
 416       entries, 5, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 417   EXPECT_TRUE(LogContainsEvent(
 418       entries, 6,
 419       NetLog::TYPE_PROXY_SCRIPT_DECIDER_FALLING_BACK_TO_NEXT_PAC_SOURCE,
 420       NetLog::PHASE_NONE));
 421   // Finally, the custom PAC URL phase.
 422   EXPECT_TRUE(LogContainsBeginEvent(
 423       entries, 7, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 424   EXPECT_TRUE(LogContainsEndEvent(
 425       entries, 8, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 426   EXPECT_TRUE(LogContainsEndEvent(
 427       entries, 9, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 428 }
 429
 430 // Fails at WPAD (downloading), and fails at custom PAC (downloading).
 431 TEST(ProxyScriptDeciderTest, AutodetectFailCustomFails1) {
 432   Rules rules;
 433   RuleBasedProxyScriptFetcher fetcher(&rules);
 434   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 435
 436   ProxyConfig config;
 437   config.set_auto_detect(true);
 438   config.set_pac_url(GURL("http://custom/proxy.pac"));
 439
 440   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 441   rules.AddFailDownloadRule("http://custom/proxy.pac");
 442
 443   TestCompletionCallback callback;
 444   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 445   EXPECT_EQ(kFailedDownloading,
 446             decider.Start(config, base::TimeDelta(), true,
 447                           callback.callback()));
 448   EXPECT_EQ(NULL, decider.script_data());
 449 }
 450
 451 // Fails at WPAD (downloading), and fails at custom PAC (parsing).
 452 TEST(ProxyScriptDeciderTest, AutodetectFailCustomFails2) {
 453   Rules rules;
 454   RuleBasedProxyScriptFetcher fetcher(&rules);
 455   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 456
 457   ProxyConfig config;
 458   config.set_auto_detect(true);
 459   config.set_pac_url(GURL("http://custom/proxy.pac"));
 460
 461   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 462   rules.AddFailParsingRule("http://custom/proxy.pac");
 463
 464   TestCompletionCallback callback;
 465   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 466   EXPECT_EQ(kFailedParsing,
 467             decider.Start(config, base::TimeDelta(), true,
 468                           callback.callback()));
 469   EXPECT_EQ(NULL, decider.script_data());
 470 }
 471
 472 // This is a copy-paste of CustomPacFails1, with the exception that we give it
 473 // a 1 millisecond delay. This means it will now complete asynchronously.
 474 // Moreover, we test the NetLog to make sure it logged the pause.
 475 TEST(ProxyScriptDeciderTest, CustomPacFails1_WithPositiveDelay) {
 476   Rules rules;
 477   RuleBasedProxyScriptFetcher fetcher(&rules);
 478   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 479
 480   ProxyConfig config;
 481   config.set_pac_url(GURL("http://custom/proxy.pac"));
 482
 483   rules.AddFailDownloadRule("http://custom/proxy.pac");
 484
 485   TestCompletionCallback callback;
 486   CapturingNetLog log;
 487   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
 488   EXPECT_EQ(ERR_IO_PENDING,
 489             decider.Start(config, base::TimeDelta::FromMilliseconds(1),
 490                       true, callback.callback()));
 491
 492   EXPECT_EQ(kFailedDownloading, callback.WaitForResult());
 493   EXPECT_EQ(NULL, decider.script_data());
 494
 495   // Check the NetLog was filled correctly.
 496   CapturingNetLog::CapturedEntryList entries;
 497   log.GetEntries(&entries);
 498
 499   EXPECT_EQ(6u, entries.size());
 500   EXPECT_TRUE(LogContainsBeginEvent(
 501       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 502   EXPECT_TRUE(LogContainsBeginEvent(
 503       entries, 1, NetLog::TYPE_PROXY_SCRIPT_DECIDER_WAIT));
 504   EXPECT_TRUE(LogContainsEndEvent(
 505       entries, 2, NetLog::TYPE_PROXY_SCRIPT_DECIDER_WAIT));
 506   EXPECT_TRUE(LogContainsBeginEvent(
 507       entries, 3, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 508   EXPECT_TRUE(LogContainsEndEvent(
 509       entries, 4, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 510   EXPECT_TRUE(LogContainsEndEvent(
 511       entries, 5, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 512 }
 513
 514 // This is a copy-paste of CustomPacFails1, with the exception that we give it
 515 // a -5 second delay instead of a 0 ms delay. This change should have no effect
 516 // so the rest of the test is unchanged.
 517 TEST(ProxyScriptDeciderTest, CustomPacFails1_WithNegativeDelay) {
 518   Rules rules;
 519   RuleBasedProxyScriptFetcher fetcher(&rules);
 520   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 521
 522   ProxyConfig config;
 523   config.set_pac_url(GURL("http://custom/proxy.pac"));
 524
 525   rules.AddFailDownloadRule("http://custom/proxy.pac");
 526
 527   TestCompletionCallback callback;
 528   CapturingNetLog log;
 529   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
 530   EXPECT_EQ(kFailedDownloading,
 531             decider.Start(config, base::TimeDelta::FromSeconds(-5),
 532                           true, callback.callback()));
 533   EXPECT_EQ(NULL, decider.script_data());
 534
 535   // Check the NetLog was filled correctly.
 536   CapturingNetLog::CapturedEntryList entries;
 537   log.GetEntries(&entries);
 538
 539   EXPECT_EQ(4u, entries.size());
 540   EXPECT_TRUE(LogContainsBeginEvent(
 541       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 542   EXPECT_TRUE(LogContainsBeginEvent(
 543       entries, 1, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 544   EXPECT_TRUE(LogContainsEndEvent(
 545       entries, 2, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
 546   EXPECT_TRUE(LogContainsEndEvent(
 547       entries, 3, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 548 }
 549
 550 class SynchronousSuccessDhcpFetcher : public DhcpProxyScriptFetcher {
 551  public:
 552   explicit SynchronousSuccessDhcpFetcher(const base::string16& expected_text)
 553       : gurl_("http://dhcppac/"), expected_text_(expected_text) {
 554   }
 555
 556   virtual int Fetch(base::string16* utf16_text,
 557                     const CompletionCallback& callback) OVERRIDE {
 558     *utf16_text = expected_text_;
 559     return OK;
 560   }
 561
 562   virtual void Cancel() OVERRIDE {
 563   }
 564
 565   virtual const GURL& GetPacURL() const OVERRIDE {
 566     return gurl_;
 567   }
 568
 569   const base::string16& expected_text() const {
 570     return expected_text_;
 571   }
 572
 573  private:
 574   GURL gurl_;
 575   base::string16 expected_text_;
 576
 577   DISALLOW_COPY_AND_ASSIGN(SynchronousSuccessDhcpFetcher);
 578 };
 579
 580 // All of the tests above that use ProxyScriptDecider have tested
 581 // failure to fetch a PAC file via DHCP configuration, so we now test
 582 // success at downloading and parsing, and then success at downloading,
 583 // failure at parsing.
 584
 585 TEST(ProxyScriptDeciderTest, AutodetectDhcpSuccess) {
 586   Rules rules;
 587   RuleBasedProxyScriptFetcher fetcher(&rules);
 588   SynchronousSuccessDhcpFetcher dhcp_fetcher(
 589       WideToUTF16(L"http://bingo/!FindProxyForURL"));
 590
 591   ProxyConfig config;
 592   config.set_auto_detect(true);
 593
 594   rules.AddSuccessRule("http://bingo/");
 595   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 596
 597   TestCompletionCallback callback;
 598   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 599   EXPECT_EQ(OK, decider.Start(
 600       config, base::TimeDelta(), true, callback.callback()));
 601   EXPECT_EQ(dhcp_fetcher.expected_text(),
 602             decider.script_data()->utf16());
 603
 604   EXPECT_TRUE(decider.effective_config().has_pac_url());
 605   EXPECT_EQ(GURL("http://dhcppac/"), decider.effective_config().pac_url());
 606 }
 607
 608 TEST(ProxyScriptDeciderTest, AutodetectDhcpFailParse) {
 609   Rules rules;
 610   RuleBasedProxyScriptFetcher fetcher(&rules);
 611   SynchronousSuccessDhcpFetcher dhcp_fetcher(
 612       WideToUTF16(L"http://bingo/!invalid-script"));
 613
 614   ProxyConfig config;
 615   config.set_auto_detect(true);
 616
 617   rules.AddFailParsingRule("http://bingo/");
 618   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 619
 620   TestCompletionCallback callback;
 621   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
 622   // Since there is fallback to DNS-based WPAD, the final error will be that
 623   // it failed downloading, not that it failed parsing.
 624   EXPECT_EQ(kFailedDownloading,
 625       decider.Start(config, base::TimeDelta(), true, callback.callback()));
 626   EXPECT_EQ(NULL, decider.script_data());
 627
 628   EXPECT_FALSE(decider.effective_config().has_pac_url());
 629 }
 630
 631 class AsyncFailDhcpFetcher
 632     : public DhcpProxyScriptFetcher,
 633       public base::SupportsWeakPtr<AsyncFailDhcpFetcher> {
 634  public:
 635   AsyncFailDhcpFetcher() {}
 636   virtual ~AsyncFailDhcpFetcher() {}
 637
 638   virtual int Fetch(base::string16* utf16_text,
 639                     const CompletionCallback& callback) OVERRIDE {
 640     callback_ = callback;
 641     base::MessageLoop::current()->PostTask(
 642         FROM_HERE,
 643         base::Bind(&AsyncFailDhcpFetcher::CallbackWithFailure, AsWeakPtr()));
 644     return ERR_IO_PENDING;
 645   }
 646
 647   virtual void Cancel() OVERRIDE {
 648     callback_.Reset();
 649   }
 650
 651   virtual const GURL& GetPacURL() const OVERRIDE {
 652     return dummy_gurl_;
 653   }
 654
 655   void CallbackWithFailure() {
 656     if (!callback_.is_null())
 657       callback_.Run(ERR_PAC_NOT_IN_DHCP);
 658   }
 659
 660  private:
 661   GURL dummy_gurl_;
 662   CompletionCallback callback_;
 663 };
 664
 665 TEST(ProxyScriptDeciderTest, DhcpCancelledByDestructor) {
 666   // This regression test would crash before
 667   // http://codereview.chromium.org/7044058/
 668   // Thus, we don't care much about actual results (hence no EXPECT or ASSERT
 669   // macros below), just that it doesn't crash.
 670   Rules rules;
 671   RuleBasedProxyScriptFetcher fetcher(&rules);
 672
 673   scoped_ptr<AsyncFailDhcpFetcher> dhcp_fetcher(new AsyncFailDhcpFetcher());
 674
 675   ProxyConfig config;
 676   config.set_auto_detect(true);
 677   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 678
 679   TestCompletionCallback callback;
 680
 681   // Scope so ProxyScriptDecider gets destroyed early.
 682   {
 683     ProxyScriptDecider decider(&fetcher, dhcp_fetcher.get(), NULL);
 684     decider.Start(config, base::TimeDelta(), true, callback.callback());
 685   }
 686
 687   // Run the message loop to let the DHCP fetch complete and post the results
 688   // back. Before the fix linked to above, this would try to invoke on
 689   // the callback object provided by ProxyScriptDecider after it was
 690   // no longer valid.
 691   base::MessageLoop::current()->RunUntilIdle();
 692 }
 693
 694 }  // namespace
 695 }  // namespace net