Add a mechanism to disable IPv6....

net/base/mock_host_resolver.h

 // 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.
 
 #ifndef NET_BASE_MOCK_HOST_RESOLVER_H_
 #define NET_BASE_MOCK_HOST_RESOLVER_H_
 
 #include <list>
 
 #include "base/waitable_event.h"
@@ skipping 103 matching lines @@
                           int latency_ms);
 
   // Make sure that |host| will not be re-mapped or even processed by underlying
   // host resolver procedures. It can also be a pattern.
   void AllowDirectLookup(const std::string& host);
 
   // Simulate a lookup failure for |host| (it also can be a pattern).
   void AddSimulatedFailure(const std::string& host);
 
   // HostResolverProc methods:
-  virtual int Resolve(const std::string& host, AddressList* addrlist);
+  virtual int Resolve(const std::string& host,
+                      AddressFamily address_family,
+                      AddressList* addrlist);
 
  private:
   struct Rule;
   typedef std::list<Rule> RuleList;
 
   RuleList rules_;
 };
 
 // Using WaitingHostResolverProc you can simulate very long lookups.
 class WaitingHostResolverProc : public HostResolverProc {
  public:
   explicit WaitingHostResolverProc(HostResolverProc* previous)
       : HostResolverProc(previous), event_(false, false) {}
 
   void Signal() {
     event_.Signal();
   }
 
   // HostResolverProc methods:
-  virtual int Resolve(const std::string& host, AddressList* addrlist) {
+  virtual int Resolve(const std::string& host,
+                      AddressFamily address_family,
+                      AddressList* addrlist) {
     event_.Wait();
-    return ResolveUsingPrevious(host, addrlist);
+    return ResolveUsingPrevious(host, address_family, addrlist);
   }
 
   base::WaitableEvent event_;
 };
 
 // This class sets the HostResolverProc for a particular scope. If there are
 // multiple ScopedDefaultHostResolverProc in existence, then the last one
 // allocated will be used. However, if it does not provide a matching rule,
 // then it should delegate to the previously set HostResolverProc.
 //
 // NOTE: Only use this as a catch-all safety net. Individual tests should use
 // MockHostResolver.
 class ScopedDefaultHostResolverProc {
  public:
   ScopedDefaultHostResolverProc() {}
   explicit ScopedDefaultHostResolverProc(HostResolverProc* proc);
 
   ~ScopedDefaultHostResolverProc();
 
   void Init(HostResolverProc* proc);
 
  private:
   scoped_refptr<HostResolverProc> current_proc_;
   scoped_refptr<HostResolverProc> previous_proc_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_MOCK_HOST_RESOLVER_H_