Use manually constructed IPv6 socket addresses for tests, rather than system ...

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"
 #include "net/base/net_errors.h"
 
 namespace net {
 
+namespace {
+// Fills |addrlist| with a socket address for |host| which should be an
+// IPv6 literal. Returns OK on success.
+int ResolveIPV6LiteralUsingGURL(const std::string& host,
+                                AddressList* addrlist) {
+  // GURL expects the hostname to be surrounded with brackets.
+  std::string host_brackets = "[" + host + "]";
+  url_parse::Component host_comp(0, host_brackets.size());
+
+  // Try parsing the hostname as an IPv6 literal.
+  unsigned char ipv6_addr[16];  // 128 bits.
+  bool ok = url_canon::IPv6AddressToNumber(host_brackets.data(),
+                                           host_comp,
+                                           ipv6_addr);
+  if (!ok) {
+    LOG(WARNING) << "Not an IPv6 literal: " << host;
+    return ERR_UNEXPECTED;
+  }
+
+  *addrlist = AddressList::CreateIPv6Address(ipv6_addr);
+  return OK;
+}
+
+}  // namespace
+
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
     : use_caching_(use_caching) {
   Reset(NULL);
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   AddressList* addresses,
                                   CompletionCallback* callback,
                                   RequestHandle* out_req) {
   if (synchronous_mode_) {
@@ skipping 40 matching lines @@
 
   int max_cache_entries = use_caching_ ? 100 : 0;
   int max_cache_age_ms = use_caching_ ? 60000 : 0;
 
   impl_ = new HostResolverImpl(proc, max_cache_entries, max_cache_age_ms);
 }
 
 //-----------------------------------------------------------------------------
 
 struct RuleBasedHostResolverProc::Rule {
+  enum ResolverType {
+    kResolverTypeFail,
+    kResolverTypeSystem,
+    kResolverTypeIPV6Literal,
+  };
+
+  ResolverType resolver_type;
   std::string host_pattern;
   std::string replacement;
   int latency_ms;  // In milliseconds.
-  bool direct;     // if true, don't mangle hostname and ignore replacement
-  Rule(const std::string& host_pattern, const std::string& replacement)
-      : host_pattern(host_pattern),
+
+  Rule(ResolverType resolver_type,
+       const std::string& host_pattern,
+       const std::string& replacement,
+       int latency_ms)
+      : resolver_type(resolver_type),
+        host_pattern(host_pattern),
         replacement(replacement),
-        latency_ms(0),
-        direct(false) {}
-  Rule(const std::string& host_pattern, const std::string& replacement,
-       const int latency_ms)
-      : host_pattern(host_pattern),
-        replacement(replacement),
-        latency_ms(latency_ms),
-        direct(false) {}
-  Rule(const std::string& host_pattern, const std::string& replacement,
-       const bool direct)
-      : host_pattern(host_pattern),
-        replacement(replacement),
-        latency_ms(0),
-        direct(direct) {}
+        latency_ms(latency_ms) {}
 };
 
 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
     : HostResolverProc(previous) {
 }
 
 RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 }
 
 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
                                         const std::string& replacement) {
-  rules_.push_back(Rule(host_pattern, replacement));
+  DCHECK(!replacement.empty());
+  Rule rule(Rule::kResolverTypeSystem, host_pattern, replacement, 0);
+  rules_.push_back(rule);
+}
+
+void RuleBasedHostResolverProc::AddIPv6Rule(const std::string& host_pattern,
+                                            const std::string& ipv6_literal) {
+  Rule rule(Rule::kResolverTypeIPV6Literal, host_pattern, ipv6_literal, 0);
+  rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddRuleWithLatency(
     const std::string& host_pattern,
-    const std::string& replacement, int latency_ms) {
-  rules_.push_back(Rule(host_pattern, replacement, latency_ms));
+    const std::string& replacement,
+    int latency_ms) {
+  DCHECK(!replacement.empty());
+  Rule rule(Rule::kResolverTypeSystem, host_pattern, replacement, latency_ms);
+  rules_.push_back(rule);
 }
 
-void RuleBasedHostResolverProc::AllowDirectLookup(const std::string& host) {
-  rules_.push_back(Rule(host, "", true));
+void RuleBasedHostResolverProc::AllowDirectLookup(
+    const std::string& host_pattern) {
+  Rule rule(Rule::kResolverTypeSystem, host_pattern, "", 0);
+  rules_.push_back(rule);
 }
 
-void RuleBasedHostResolverProc::AddSimulatedFailure(const std::string& host) {
-  AddRule(host, "");
+void RuleBasedHostResolverProc::AddSimulatedFailure(
+    const std::string& host_pattern) {
+  Rule rule(Rule::kResolverTypeFail, host_pattern, "", 0);
+  rules_.push_back(rule);
 }
 
 int RuleBasedHostResolverProc::Resolve(const std::string& host,
                                        AddressList* addrlist) {
   RuleList::iterator r;
   for (r = rules_.begin(); r != rules_.end(); ++r) {
     if (MatchPattern(host, r->host_pattern)) {
       if (r->latency_ms != 0) {
         PlatformThread::Sleep(r->latency_ms);
         // Hmm, this seems unecessary.
         r->latency_ms = 1;
       }
-      const std::string& effective_host = r->direct ? host : r->replacement;
-      if (effective_host.empty())
-        return ERR_NAME_NOT_RESOLVED;
-      return SystemHostResolverProc(effective_host, addrlist);
+
+      // 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:
+          return ERR_NAME_NOT_RESOLVED;
+        case Rule::kResolverTypeSystem:
+          return SystemHostResolverProc(effective_host, addrlist);
+        case Rule::kResolverTypeIPV6Literal:
+          return ResolveIPV6LiteralUsingGURL(effective_host, addrlist);
+        default:
+          NOTREACHED();
+          return ERR_UNEXPECTED;
+      }
     }
   }
   return ResolveUsingPrevious(host, addrlist);
 }
 
 //-----------------------------------------------------------------------------
 
 ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc(
     HostResolverProc* proc) : current_proc_(proc) {
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->set_previous_proc(previous_proc_);
 }
 
 ScopedDefaultHostResolverProc::~ScopedDefaultHostResolverProc() {
   HostResolverProc* old_proc = HostResolverProc::SetDefault(previous_proc_);
   // The lifetimes of multiple instances must be nested.
   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