Prevent making real DNS lookups by chrome tests.

net/base/host_resolver_unittest.h

 // Copyright (c) 2006-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_HOST_RESOLVER_UNITTEST_H_
 #define NET_BASE_HOST_RESOLVER_UNITTEST_H_
 
 #ifdef UNIT_TEST
 
 #include <list>
@@ skipping 33 matching lines @@
   // replacement value.  Usually, replacement should be an IP address literal.
   void AddRule(const char* host_pattern, const char* replacement) {
     rules_.push_back(Rule(host_pattern, replacement));
   }
 
   void AddRuleWithLatency(const char* host_pattern, const char* replacement,
                           int latency) {
     rules_.push_back(Rule(host_pattern, replacement, latency));
   }
 
- private:
-  std::string Map(const std::string& host) {
+  // Make sure that |host| will not be re-mapped or even processed by underlying
+  // host mappers. It can also be a pattern.
+  void AllowDirectLookup(const char* host) {
+    rules_.push_back(Rule(host, "", true));
+  }
+
+  // Simulate a lookup failure for |host| (it also can be a pattern).
+  void AddSimulatedFailure(const char* host) {
+    AddRule(host, "");
+  }
+
+  virtual std::string Map(const std::string& host) {
     RuleList::iterator r;
     for (r = rules_.begin(); r != rules_.end(); ++r) {
       if (MatchPattern(host, r->host_pattern)) {
         if (r->latency != 0) {
           PlatformThread::Sleep(r->latency);
           r->latency = 1;  // Simulate cache warmup.
         }
-        return r->replacement;
+        return r->direct ? host : r->replacement;
       }
     }
+
     return MapUsingPrevious(host);
   }
 
+ private:
   struct Rule {
     std::string host_pattern;
     std::string replacement;
     int latency;  // in milliseconds
+    bool direct;  // if true, don't mangle hostname and ignore replacement
     Rule(const char* h, const char* r)
         : host_pattern(h),
           replacement(r),
-          latency(0) {}
+          latency(0),
+          direct(false) {}
     Rule(const char* h, const char* r, const int l)
         : host_pattern(h),
           replacement(r),
-          latency(l) {}
+          latency(l),
+          direct(false) {}
+    Rule(const char* h, const char* r, const bool d)
+        : host_pattern(h),
+          replacement(r),
+          latency(0),
+          direct(d) {}
   };
   typedef std::list<Rule> RuleList;
-
   RuleList rules_;
 };
 
 // Using WaitingHostMapper you can simulate very long lookups, for example
 // to test code which cancels a request. Example usage:
 //
 //   scoped_refptr<WaitingHostMapper> mapper = new WaitingHostMapper();
 //   ScopedHostMapper scoped_mapper(mapper.get());
 //
 //   (start the lookup asynchronously)
 //   (cancel the lookup)
 //
 //   mapper->Signal();
 class WaitingHostMapper : public HostMapper {
  public:
   WaitingHostMapper() : event_(false, false) {
   }
 
   void Signal() {
     event_.Signal();
   }
 
  private:
-  std::string Map(const std::string& host) {
+  virtual std::string Map(const std::string& host) {
     event_.Wait();
     return MapUsingPrevious(host);
   }
 
   base::WaitableEvent event_;
 };
 
 // This class sets the HostMapper for a particular scope. If there are multiple
 // ScopedHostMappers in existence, then the last one allocated will be used.
 // However, if it does not provide a matching rule, then it should delegate
@@ skipping 24 matching lines @@
  private:
   scoped_refptr<HostMapper> current_host_mapper_;
   scoped_refptr<HostMapper> previous_host_mapper_;
 };
 
 }  // namespace net
 
 #endif  // UNIT_TEST
 
 #endif  // NET_BASE_HOST_RESOLVER_UNITTEST_H_