Reimplements net::AddressList without struct addrinfo.

net/base/mock_host_resolver.cc

 // Copyright (c) 2012 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/host_cache.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 
 namespace net {
 
 namespace {
 
 // Cache size for the MockCachingHostResolver.
 const unsigned kMaxCacheEntries = 100;
 // TTL for the successful resolutions. Failures are not cached.
 const unsigned kCacheEntryTTLSeconds = 60;
 
 }  // namespace
 
 int ParseAddressList(const std::string& host_list,
                      const std::string& canonical_name,
                      AddressList* addrlist) {
   *addrlist = AddressList();
   std::vector<std::string> addresses;
   base::SplitString(host_list, ',', &addresses);
+  addrlist->set_canonical_name(canonical_name);
   for (size_t index = 0; index < addresses.size(); ++index) {
     IPAddressNumber ip_number;
     if (!ParseIPLiteralToNumber(addresses[index], &ip_number)) {
       LOG(WARNING) << "Not a supported IP literal: " << addresses[index];
       return ERR_UNEXPECTED;
     }
-
-    AddressList result = AddressList::CreateFromIPAddress(ip_number, -1);
-    struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
-    if (index == 0)
-      ai->ai_canonname = base::strdup(canonical_name.c_str());
-    if (!addrlist->head())
-      *addrlist = AddressList::CreateByCopyingFirstAddress(result.head());
-    else
-      addrlist->Append(result.head());
+    addrlist->push_back(IPEndPoint(ip_number, -1));
   }
   return OK;
 }
 
 struct MockHostResolverBase::Request {
   Request(const RequestInfo& req_info,
           AddressList* addr,
           const CompletionCallback& cb)
       : info(req_info), addresses(addr), callback(cb) {}
   RequestInfo info;
@@ skipping 65 matching lines @@
 
   if (use_caching) {
     cache_.reset(new HostCache(kMaxCacheEntries));
   }
 }
 
 int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                                       AddressList* addresses) {
   IPAddressNumber ip;
   if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
-    *addresses = AddressList::CreateFromIPAddressWithCname(
-        ip, info.port(), info.host_resolver_flags() & HOST_RESOLVER_CANONNAME);
+    *addresses = AddressList::CreateFromIPAddress(ip, info.port());
+    if (info.host_resolver_flags() & HOST_RESOLVER_CANONNAME)
+      addresses->SetDefaultCanonicalName();
     return OK;
   }
   int rv = ERR_DNS_CACHE_MISS;
   if (cache_.get() && info.allow_cached_response()) {
     HostCache::Key key(info.hostname(),
                        info.address_family(),
                        info.host_resolver_flags());
     const HostCache::Entry* entry = cache_->Lookup(key, base::TimeTicks::Now());
     if (entry) {
       rv = entry->error;
-      if (rv == OK)
-        *addresses = CreateAddressListUsingPort(entry->addrlist, info.port());
+      if (rv == OK) {
+        *addresses = entry->addrlist;
+        SetPortOnAddressList(info.port(), addresses);
+      }
     }
   }
   return rv;
 }
 
 int MockHostResolverBase::ResolveProc(size_t id,
                                       const RequestInfo& info,
                                       AddressList* addresses) {
   AddressList addr;
   int rv = proc_->Resolve(info.hostname(),
                           info.address_family(),
                           info.host_resolver_flags(),
                           &addr,
                           NULL);
   if (cache_.get()) {
     HostCache::Key key(info.hostname(),
                        info.address_family(),
                        info.host_resolver_flags());
     // Storing a failure with TTL 0 so that it overwrites previous value.
     base::TimeDelta ttl;
     if (rv == OK)
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
     cache_->Set(key, rv, addr, base::TimeTicks::Now(), ttl);
   }
-  if (rv == OK)
-    *addresses = CreateAddressListUsingPort(addr, info.port());
+  if (rv == OK) {
+    *addresses = addr;
+    SetPortOnAddressList(info.port(), addresses);
+  }
   return rv;
 }
 
 void MockHostResolverBase::ResolveNow(size_t id) {
   RequestMap::iterator it = requests_.find(id);
   if (it == requests_.end())
     return;  // was canceled
 
   scoped_ptr<Request> req(it->second);
   requests_.erase(it);
@@ skipping 203 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