Adds support for the DHCP portion of the WPAD (proxy auto-discovery) protocol.

net/proxy/init_proxy_resolver_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/init_proxy_resolver.h"
+#include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 enum Error {
   kFailedDownloading = -100,
@@ skipping 76 matching lines @@
     const Rules::Rule& rule = rules_->GetRuleByUrl(url);
     int rv = rule.fetch_error;
     EXPECT_NE(ERR_UNEXPECTED, rv);
     if (rv == OK)
       *text = rule.text();
     return rv;
   }
 
   virtual void Cancel() {}
 
-  virtual URLRequestContext* GetRequestContext() { return NULL; }
+  virtual URLRequestContext* GetRequestContext() const { return NULL; }
 
  private:
   const Rules* rules_;
 };
 
 class RuleBasedProxyResolver : public ProxyResolver {
  public:
   RuleBasedProxyResolver(const Rules* rules, bool expects_pac_bytes)
       : ProxyResolver(expects_pac_bytes), rules_(rules) {}
 
@@ skipping 46 matching lines @@
  private:
   const Rules* rules_;
   scoped_refptr<ProxyResolverScriptData> script_data_;
 };
 
 // Succeed using custom PAC script.
 TEST(InitProxyResolverTest, CustomPacSucceeds) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
-  InitProxyResolver init(&resolver, &fetcher, &log);
-  EXPECT_EQ(OK, init.Init(config, base::TimeDelta(), NULL, &callback));
+  ProxyConfig effective_config;
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, &log);
+  EXPECT_EQ(OK, init.Init(
+      config, base::TimeDelta(), &effective_config, &callback));
   EXPECT_EQ(rule.text(), resolver.script_data()->utf16());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 4, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
+
+  EXPECT_TRUE(effective_config.has_pac_url());
+  EXPECT_EQ(config.pac_url(), effective_config.pac_url());
 }
 
 // Fail downloading the custom PAC script.
 TEST(InitProxyResolverTest, CustomPacFails1) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
-  InitProxyResolver init(&resolver, &fetcher, &log);
+  ProxyConfig effective_config;
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(kFailedDownloading,
-            init.Init(config, base::TimeDelta(), NULL, &callback));
+            init.Init(config, base::TimeDelta(), &effective_config, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER));
+
+  EXPECT_FALSE(effective_config.has_pac_url());
 }
 
 // Fail parsing the custom PAC script.
 TEST(InitProxyResolverTest, CustomPacFails2) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailParsingRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, &fetcher, NULL);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(kFailedParsing,
             init.Init(config, base::TimeDelta(), NULL, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 }
 
 // Fail downloading the custom PAC script, because the fetcher was NULL.
 TEST(InitProxyResolverTest, HasNullProxyScriptFetcher) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, NULL, NULL);
+  InitProxyResolver init(&resolver, NULL, &dhcp_fetcher, NULL);
   EXPECT_EQ(ERR_UNEXPECTED,
             init.Init(config, base::TimeDelta(), NULL, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 }
 
-// Succeeds in choosing autodetect (wpad).
+// Succeeds in choosing autodetect (WPAD DNS).
 TEST(InitProxyResolverTest, AutodetectSuccess) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
 
   Rules::Rule rule = rules.AddSuccessRule("http://wpad/wpad.dat");
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, &fetcher, NULL);
-  EXPECT_EQ(OK, init.Init(config, base::TimeDelta(), NULL, &callback));
+  ProxyConfig effective_config;
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
+  EXPECT_EQ(OK, init.Init(
+      config, base::TimeDelta(), &effective_config, &callback));
   EXPECT_EQ(rule.text(), resolver.script_data()->utf16());
+
+  EXPECT_TRUE(effective_config.has_pac_url());
+  EXPECT_EQ(rule.url, effective_config.pac_url());
 }
 
 // Fails at WPAD (downloading), but succeeds in choosing the custom PAC.
 TEST(InitProxyResolverTest, AutodetectFailCustomSuccess1) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, &fetcher, NULL);
-  EXPECT_EQ(OK, init.Init(config, base::TimeDelta(), NULL, &callback));
+  ProxyConfig effective_config;
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
+  EXPECT_EQ(OK, init.Init(
+      config, base::TimeDelta(), &effective_config, &callback));
   EXPECT_EQ(rule.text(), resolver.script_data()->utf16());
+
+  EXPECT_TRUE(effective_config.has_pac_url());
+  EXPECT_EQ(rule.url, effective_config.pac_url());
 }
 
-// Fails at WPAD (parsing), but succeeds in choosing the custom PAC.
+// Fails at WPAD (no DHCP config, DNS PAC fails parsing), but succeeds in
+// choosing the custom PAC.
 TEST(InitProxyResolverTest, AutodetectFailCustomSuccess2) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
   config.proxy_rules().ParseFromString("unused-manual-proxy:99");
 
   rules.AddFailParsingRule("http://wpad/wpad.dat");
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   ProxyConfig effective_config;
-  InitProxyResolver init(&resolver, &fetcher, &log);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(OK, init.Init(config, base::TimeDelta(),
                           &effective_config, &callback));
   EXPECT_EQ(rule.text(), resolver.script_data()->utf16());
 
   // Verify that the effective configuration no longer contains auto detect or
   // any of the manual settings.
   EXPECT_TRUE(effective_config.Equals(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://custom/proxy.pac"))));
 
   // Check the NetLog was filled correctly.
-  // (Note that the Fetch and Set states are repeated since both WPAD and custom
+  // (Note that various states are repeated since both WPAD and custom
   // PAC scripts are tried).
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
-  EXPECT_EQ(11u, entries.size());
+  EXPECT_EQ(14u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
+  // This is the DHCP phase, which fails fetching rather than parsing, so
+  // there is no pair of SET_PAC_SCRIPT events.
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+  EXPECT_TRUE(LogContainsEvent(
+      entries, 3,
+      NetLog::TYPE_INIT_PROXY_RESOLVER_FALLING_BACK_TO_NEXT_PAC_SOURCE,
+      NetLog::PHASE_NONE));
+  // This is the DNS phase, which attempts a fetch but fails.
   EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 4, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      entries, 4, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 5, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+  EXPECT_TRUE(LogContainsBeginEvent(
+      entries, 6, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+  EXPECT_TRUE(LogContainsEndEvent(
+      entries, 7, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEvent(
-      entries, 5,
-      NetLog::TYPE_INIT_PROXY_RESOLVER_FALLING_BACK_TO_NEXT_PAC_URL,
+      entries, 8,
+      NetLog::TYPE_INIT_PROXY_RESOLVER_FALLING_BACK_TO_NEXT_PAC_SOURCE,
       NetLog::PHASE_NONE));
+  // Finally, the custom PAC URL phase.
   EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 6, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 9, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      entries, 7, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 10, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 8, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 11, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      entries, 9, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 12, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      entries, 10, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 13, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fails at WPAD (downloading), and fails at custom PAC (downloading).
 TEST(InitProxyResolverTest, AutodetectFailCustomFails1) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, &fetcher, NULL);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(kFailedDownloading,
             init.Init(config, base::TimeDelta(), NULL, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 }
 
 // Fails at WPAD (downloading), and fails at custom PAC (parsing).
 TEST(InitProxyResolverTest, AutodetectFailCustomFails2) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
   rules.AddFailParsingRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, &fetcher, NULL);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(kFailedParsing,
             init.Init(config, base::TimeDelta(), NULL, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 }
 
 // Fails at WPAD (parsing), but succeeds in choosing the custom PAC.
 // This is the same as AutodetectFailCustomSuccess2, but using a ProxyResolver
 // that doesn't |expects_pac_bytes|.
 TEST(InitProxyResolverTest, AutodetectFailCustomSuccess2_NoFetch) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, false /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailParsingRule("");  // Autodetect.
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  InitProxyResolver init(&resolver, &fetcher, NULL);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(OK, init.Init(config, base::TimeDelta(), NULL, &callback));
   EXPECT_EQ(rule.url, resolver.script_data()->url());
 }
 
 // This is a copy-paste of CustomPacFails1, with the exception that we give it
 // a 1 millisecond delay. This means it will now complete asynchronously.
 // Moreover, we test the NetLog to make sure it logged the pause.
 TEST(InitProxyResolverTest, CustomPacFails1_WithPositiveDelay) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
-  InitProxyResolver init(&resolver, &fetcher, &log);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(ERR_IO_PENDING,
             init.Init(config, base::TimeDelta::FromMilliseconds(1),
                       NULL, &callback));
 
   EXPECT_EQ(kFailedDownloading, callback.WaitForResult());
   EXPECT_EQ(NULL, resolver.script_data());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
@@ skipping 13 matching lines @@
       entries, 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // This is a copy-paste of CustomPacFails1, with the exception that we give it
 // a -5 second delay instead of a 0 ms delay. This change should have no effect
 // so the rest of the test is unchanged.
 TEST(InitProxyResolverTest, CustomPacFails1_WithNegativeDelay) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
+  DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
-  InitProxyResolver init(&resolver, &fetcher, &log);
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(kFailedDownloading,
             init.Init(config, base::TimeDelta::FromSeconds(-5),
                       NULL, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
+class SynchronousSuccessDhcpFetcher : public DhcpProxyScriptFetcher {
+ public:
+  SynchronousSuccessDhcpFetcher(const string16& expected_text)
+      : expected_text_(expected_text) {
+  }
+
+  int Fetch(string16* utf16_text, CompletionCallback* callback) OVERRIDE {
+    *utf16_text = expected_text_;
+    return OK;
+  }
+
+  void Cancel() OVERRIDE {
+  }
+
+  URLRequestContext* GetRequestContext() const OVERRIDE {
+    return NULL;
+  }
+
+  GURL GetPacURL() const OVERRIDE {
+    return GURL("http://dhcppac/");
+  }
+
+  const string16& expected_text() const {
+    return expected_text_;
+  }
+
+ private:
+  string16 expected_text_;
+};
+
+// All of the tests above that use InitProxyResolver have tested
+// failure to fetch a PAC file via DHCP configuration, so we now test
+// success at downloading and parsing, and then success at downloading,
+// failure at parsing.
+
+TEST(InitProxyResolverTest, AutodetectDhcpSuccess) {
+  Rules rules;
+  RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
+  RuleBasedProxyScriptFetcher fetcher(&rules);
+  SynchronousSuccessDhcpFetcher dhcp_fetcher(
+      WideToUTF16(L"http://bingo/!valid-script"));
+
+  ProxyConfig config;
+  config.set_auto_detect(true);
+
+  rules.AddSuccessRule("http://bingo/");
+  rules.AddFailDownloadRule("http://wpad/wpad.dat");
+
+  TestCompletionCallback callback;
+  ProxyConfig effective_config;
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
+  EXPECT_EQ(OK, init.Init(
+      config, base::TimeDelta(), &effective_config, &callback));
+  EXPECT_EQ(dhcp_fetcher.expected_text(),
+            resolver.script_data()->utf16());
+
+  EXPECT_TRUE(effective_config.has_pac_url());
+  EXPECT_EQ(GURL("http://dhcppac/"), effective_config.pac_url());
+}
+
+TEST(InitProxyResolverTest, AutodetectDhcpFailParse) {
+  Rules rules;
+  RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
+  RuleBasedProxyScriptFetcher fetcher(&rules);
+  SynchronousSuccessDhcpFetcher dhcp_fetcher(
+      WideToUTF16(L"http://bingo/!invalid-script"));
+
+  ProxyConfig config;
+  config.set_auto_detect(true);
+
+  rules.AddFailParsingRule("http://bingo/");
+  rules.AddFailDownloadRule("http://wpad/wpad.dat");
+
+  TestCompletionCallback callback;
+  ProxyConfig effective_config;
+  InitProxyResolver init(&resolver, &fetcher, &dhcp_fetcher, NULL);
+  // Since there is fallback to DNS-based WPAD, the final error will be that
+  // it failed downloading, not that it failed parsing.
+  EXPECT_EQ(kFailedDownloading,
+      init.Init(config, base::TimeDelta(), &effective_config, &callback));
+  EXPECT_EQ(NULL, resolver.script_data());
+
+  EXPECT_FALSE(effective_config.has_pac_url());
+}
+
 }  // namespace
 }  // namespace net