Disable IPv6 results for the PAC bindings:...

net/base/mock_host_resolver.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/mock_host_resolver.h"
 
 #include "base/string_util.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "googleurl/src/url_canon_ip.h"
@@ skipping 92 matching lines @@
 
 struct RuleBasedHostResolverProc::Rule {
   enum ResolverType {
     kResolverTypeFail,
     kResolverTypeSystem,
     kResolverTypeIPV6Literal,
   };
 
   ResolverType resolver_type;
   std::string host_pattern;
+  AddressFamily address_family;
   std::string replacement;
   int latency_ms;  // In milliseconds.
 
   Rule(ResolverType resolver_type,
        const std::string& host_pattern,
+       AddressFamily address_family,
        const std::string& replacement,
        int latency_ms)
       : resolver_type(resolver_type),
         host_pattern(host_pattern),
+        address_family(address_family),
         replacement(replacement),
         latency_ms(latency_ms) {}
 };
 
 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
     : HostResolverProc(previous) {
 }
 
 RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 }
 
 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
                                         const std::string& replacement) {
+  AddRuleForFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED, replacement);
+}
+
+void RuleBasedHostResolverProc::AddRuleForFamily(
+    const std::string& host_pattern,
+    AddressFamily address_family,
+    const std::string& replacement) {
   DCHECK(!replacement.empty());
-  Rule rule(Rule::kResolverTypeSystem, host_pattern, replacement, 0);
+  Rule rule(Rule::kResolverTypeSystem, host_pattern,
+            address_family, replacement, 0);
   rules_.push_back(rule);
 }
 
+

[wtc, 2009/10/22 21:53:54]

Nit: delete one blank line here.

 void RuleBasedHostResolverProc::AddIPv6Rule(const std::string& host_pattern,
                                             const std::string& ipv6_literal) {
-  Rule rule(Rule::kResolverTypeIPV6Literal, host_pattern, ipv6_literal, 0);
+  Rule rule(Rule::kResolverTypeIPV6Literal, host_pattern,
+            ADDRESS_FAMILY_UNSPECIFIED, ipv6_literal, 0);

[wtc, 2009/10/22 21:53:54]

Why do you pass ADDRESS_FAMILY_UNSPECIFIED here?
I was expecting ADDRESS_FAMILY_IPV6.

   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddRuleWithLatency(
     const std::string& host_pattern,
     const std::string& replacement,
     int latency_ms) {
   DCHECK(!replacement.empty());
-  Rule rule(Rule::kResolverTypeSystem, host_pattern, replacement, latency_ms);
+  Rule rule(Rule::kResolverTypeSystem, host_pattern,
+            ADDRESS_FAMILY_UNSPECIFIED, replacement, latency_ms);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AllowDirectLookup(
     const std::string& host_pattern) {
-  Rule rule(Rule::kResolverTypeSystem, host_pattern, "", 0);
+  Rule rule(Rule::kResolverTypeSystem, host_pattern,
+            ADDRESS_FAMILY_UNSPECIFIED, "", 0);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddSimulatedFailure(
     const std::string& host_pattern) {
-  Rule rule(Rule::kResolverTypeFail, host_pattern, "", 0);
+  Rule rule(Rule::kResolverTypeFail, host_pattern,
+            ADDRESS_FAMILY_UNSPECIFIED, "", 0);
   rules_.push_back(rule);
 }
 
 int RuleBasedHostResolverProc::Resolve(const std::string& host,
                                        AddressFamily address_family,
                                        AddressList* addrlist) {
   RuleList::iterator r;
   for (r = rules_.begin(); r != rules_.end(); ++r) {
-    if (MatchPattern(host, r->host_pattern)) {
+    bool matches_address_family =
+        r->address_family == ADDRESS_FAMILY_UNSPECIFIED ||
+        r->address_family == address_family;
+
+    if (matches_address_family && MatchPattern(host, r->host_pattern)) {
       if (r->latency_ms != 0)
         PlatformThread::Sleep(r->latency_ms);
 
       // Remap to a new host.
       const std::string& effective_host =
           r->replacement.empty() ? host : r->replacement;
 
       // Apply the resolving function to the remapped hostname.
       switch (r->resolver_type) {
         case Rule::kResolverTypeFail:
@@ skipping 27 matching lines @@
   CHECK(old_proc == current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->set_previous_proc(previous_proc_);
 }
 
 }  // namespace net