Don't resolve IP literals.

net/base/mock_host_resolver.cc

 // Copyright (c) 2010 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 "net/base/net_errors.h"
 #include "net/base/net_util.h"
+#include "net/base/sys_addrinfo.h"
 
 namespace net {
 
 namespace {
 
+char* do_strdup(const char* src) {
+#if defined(OS_WIN)
+  return _strdup(src);
+#else
+  return strdup(src);
+#endif
+}
+
 // Fills |*addrlist| with a socket address for |host| which should be an
 // IPv4 or IPv6 literal without enclosing brackets. If |canonical_name| is
 // non-empty it is used as the DNS canonical name for the host. Returns OK on
 // success, ERR_UNEXPECTED otherwise.
 int CreateIPAddress(const std::string& host,
                     const std::string& canonical_name,
                     AddressList* addrlist) {
   IPAddressNumber ip_number;
   if (!ParseIPLiteralToNumber(host, &ip_number)) {
     LOG(WARNING) << "Not a supported IP literal: " << host;
     return ERR_UNEXPECTED;
   }
 
-  if (ip_number.size() == 4) {
-    *addrlist = AddressList::CreateIPv4Address(&ip_number[0], canonical_name);
-  } else if (ip_number.size() == 16) {
-    *addrlist = AddressList::CreateIPv6Address(&ip_number[0], canonical_name);
-  } else {
-    NOTREACHED();
-    return ERR_UNEXPECTED;
-  }
-
+  AddressList result(ip_number, -1, false);
+  struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
+  ai->ai_canonname = do_strdup(canonical_name.c_str());
+  *addrlist = result;
   return OK;
 }
 
 }  // namespace
 
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
     : use_caching_(use_caching) {
   Reset(NULL);
 }
 
@@ skipping 105 matching lines @@
   DCHECK(!replacement.empty());
   Rule rule(Rule::kResolverTypeSystem, host_pattern,
             address_family, 0, replacement, "", 0);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddIPLiteralRule(
     const std::string& host_pattern,
     const std::string& ip_literal,
     const std::string& canonical_name) {
+  // Literals are always resolved to themselves by HostResolverImpl,
+  // consequently we do not support remapping them.
+  IPAddressNumber ip_number;
+  DCHECK(!ParseIPLiteralToNumber(host_pattern, &ip_number));
   Rule rule(Rule::kResolverTypeIPLiteral,
             host_pattern,
             ADDRESS_FAMILY_UNSPECIFIED,
             canonical_name.empty() ? 0 : HOST_RESOLVER_CANONNAME,
             ip_literal,
             canonical_name,
             0);
   rules_.push_back(rule);
 }
 
@@ skipping 80 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net