Revert 56384 - 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 {
 
 // 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;
   }
 
-  AddressList result(ip_number, -1, false);
-  struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
-  ai->ai_canonname = strdup(canonical_name.c_str());
-  *addrlist = result;
+  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;
+  }
+
   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