Prevent making real DNS lookups by chrome tests.

- by default a test which makes external DNS lookup directly or indirectly will fail

- added a quite simple way to allow a test to make external queries

- added a way to make external queries fail (for tests which don't need them to succeed but it's hard to not make the query)

- made neccessary adjustments to existing tests so that they still pass

http://crbug.com/9109

Review URL: http://codereview.chromium.org/45026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@12653 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 36 insertions, 12 deletions

diff --git a/net/base/host_resolver.cc b/net/base/host_resolver.cc
index d5d97e7..a8580fd 100644
--- a/net/base/host_resolver.cc
+++ b/net/base/host_resolver.cc
@@ -52,13 +52,16 @@ static int HostResolverProc(
 
 static int ResolveAddrInfo(HostMapper* mapper, const std::string& host,
                            const std::string& port, struct addrinfo** out) {
-  int rv;
   if (mapper) {
-    rv = HostResolverProc(mapper->Map(host), port, out);
+    std::string mapped_host = mapper->Map(host);
+
+    if (mapped_host.empty())
+      return ERR_NAME_NOT_RESOLVED;
+
+    return HostResolverProc(mapped_host, port, out);
   } else {
-    rv = HostResolverProc(host, port, out);
+    return HostResolverProc(host, port, out);
   }
-  return rv;
 }
 
 //-----------------------------------------------------------------------------
diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h
index 6e61eb5..c730f76 100644
--- a/net/base/host_resolver.h
+++ b/net/base/host_resolver.h
@@ -59,6 +59,9 @@ class HostResolver {
 class HostMapper : public base::RefCountedThreadSafe<HostMapper> {
  public:
   virtual ~HostMapper() {}
+
+  // Returns possibly altered hostname, or empty string to simulate
+  // a failed lookup.
   virtual std::string Map(const std::string& host) = 0;
 
  protected:
diff --git a/net/base/host_resolver_unittest.h b/net/base/host_resolver_unittest.h
index e7a9c1a..f4c5854 100644
--- a/net/base/host_resolver_unittest.h
+++ b/net/base/host_resolver_unittest.h
@@ -51,8 +51,18 @@ class RuleBasedHostMapper : public HostMapper {
     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)) {
@@ -60,27 +70,36 @@ class RuleBasedHostMapper : public HostMapper {
           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_;
 };
 
@@ -104,7 +123,7 @@ class WaitingHostMapper : public HostMapper {
   }
 
  private:
-  std::string Map(const std::string& host) {
+  virtual std::string Map(const std::string& host) {
     event_.Wait();
     return MapUsingPrevious(host);
   }
diff --git a/net/base/ssl_client_socket_unittest.cc b/net/base/ssl_client_socket_unittest.cc
index 2148dfb..7b551fe 100644
--- a/net/base/ssl_client_socket_unittest.cc
+++ b/net/base/ssl_client_socket_unittest.cc
@@ -5,7 +5,6 @@
 #include "net/base/address_list.h"
 #include "net/base/client_socket_factory.h"
 #include "net/base/host_resolver.h"
-#include "net/base/host_resolver_unittest.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_client_socket.h"
 #include "net/base/ssl_config_service.h"