Reimplements net::AddressList without struct addrinfo.

net/base/host_resolver_impl.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/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 52 matching lines @@
 // Default TTL for unsuccessful resolutions with ProcTask.
 const unsigned kNegativeCacheEntryTTLSeconds = 0;
 
 // Maximum of 6 concurrent resolver threads (excluding retries).
 // Some routers (or resolvers) appear to start to provide host-not-found if
 // too many simultaneous resolutions are pending.  This number needs to be
 // further optimized, but 8 is what FF currently does. We found some routers
 // that limit this to 6, so we're temporarily holding it at that level.
 static const size_t kDefaultMaxProcTasks = 6u;
 
-// Helper to mutate the linked list contained by AddressList to the given
-// port. Note that in general this is dangerous since the AddressList's
-// data might be shared (and you should use AddressList::SetPort).
-//
-// However since we allocated the AddressList ourselves we can safely
-// do this optimization and avoid reallocating the list.
-void MutableSetPort(int port, AddressList* addr_list) {
-  struct addrinfo* mutable_head =
-      const_cast<struct addrinfo*>(addr_list->head());
-  SetPortForAllAddrinfos(mutable_head, port);
-}
-
 // We use a separate histogram name for each platform to facilitate the
 // display of error codes by their symbolic name (since each platform has
 // different mappings).
 const char kOSErrorsForGetAddrinfoHistogramName[] =
 #if defined(OS_WIN)
     "Net.OSErrorsForGetAddrinfo_Win";
 #elif defined(OS_MACOSX)
     "Net.OSErrorsForGetAddrinfo_Mac";
 #elif defined(OS_LINUX)
     "Net.OSErrorsForGetAddrinfo_Linux";
@@ skipping 78 matching lines @@
                                   address_family,
                                   host_resolver_flags,
                                   addr_list,
                                   os_error);
   }
 
  protected:
   virtual ~CallSystemHostResolverProc() {}
 };
 
+void EnsurePortOnAddressList(uint16 port, AddressList* list) {
+  DCHECK(list);
+  if (list->empty() || list->front().port() == port)
+    return;
+  SetPortOnAddressList(port, list);
+}
+
 // Extra parameters to attach to the NetLog when the resolve failed.
 class ProcTaskFailedParams : public NetLog::EventParameters {
  public:
   ProcTaskFailedParams(uint32 attempt_number, int net_error, int os_error)
       : attempt_number_(attempt_number),
         net_error_(net_error),
         os_error_(os_error) {
   }
 
   virtual Value* ToValue() const OVERRIDE {
@@ skipping 334 matching lines @@
   }
 
   void set_job(Job* job) {
     DCHECK(job);
     // Identify which job the request is waiting on.
     job_ = job;
   }
 
   // Prepare final AddressList and call completion callback.
   void OnComplete(int error, const AddressList& addr_list) {
-    if (error == OK)
-      *addresses_ = CreateAddressListUsingPort(addr_list, info_.port());
+    if (error == OK) {
+      *addresses_ = addr_list;
+      EnsurePortOnAddressList(info_.port(), addresses_);
+    }
     CompletionCallback callback = callback_;
     MarkAsCanceled();
     callback.Run(error);
   }
 
   Job* job() const {
     return job_;
   }
 
   // NetLog for the source, passed in HostResolver::Resolve.
@@ skipping 180 matching lines @@
     StartLookupAttempt();
   }
 
   // Callback for when DoLookup() completes (runs on origin thread).
   void OnLookupComplete(const AddressList& results,
                         const base::TimeTicks& start_time,
                         const uint32 attempt_number,
                         int error,
                         const int os_error) {
     DCHECK(origin_loop_->BelongsToCurrentThread());
-    DCHECK(error || results.head());
+    DCHECK(error || !results.empty());
 
     bool was_retry_attempt = attempt_number > 1;
 
     // Ideally the following code would be part of host_resolver_proc.cc,
     // however it isn't safe to call NetworkChangeNotifier from worker threads.
     // So we do it here on the IO thread instead.
     if (error != OK && NetworkChangeNotifier::IsOffline())
       error = ERR_INTERNET_DISCONNECTED;
 
     // If this is the first attempt that is finishing later, then record data
@@ skipping 670 matching lines @@
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                         OK);
       return;
     }
 
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                       net_error);
 
     DCHECK(!requests_.empty());
 
-    // We are the only consumer of |list|, so we can safely change the port
-    // without copy-on-write. This pays off, when job has only one request.
     if (net_error == OK)
-      MutableSetPort(requests_->front()->info().port(), &list);
+      SetPortOnAddressList(requests_->front()->info().port(), &list);
 
     if ((net_error != ERR_ABORTED) &&
         (net_error != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)) {
       resolver_->CacheResult(key_, net_error, list, ttl);
     }
 
     // Complete all of the requests that were attached to the job.
     for (RequestsList::const_iterator it = requests_.begin();
          it != requests_.end(); ++it) {
       Request* req = *it;
@@ skipping 307 matching lines @@
   DCHECK_EQ(key.host_resolver_flags &
       ~(HOST_RESOLVER_CANONNAME | HOST_RESOLVER_LOOPBACK_ONLY |
         HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6),
             0) << " Unhandled flag";
   bool ipv6_disabled = (default_address_family_ == ADDRESS_FAMILY_IPV4) &&
       !ipv6_probe_monitoring_;
   *net_error = OK;
   if ((ip_number.size() == kIPv6AddressSize) && ipv6_disabled) {
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else {
-    *addresses = AddressList::CreateFromIPAddressWithCname(
-        ip_number, info.port(),
-        (key.host_resolver_flags & HOST_RESOLVER_CANONNAME));
+    *addresses = AddressList::CreateFromIPAddress(ip_number, info.port());
+    if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
+      addresses->SetDefaultCanonicalName();
   }
   return true;
 }
 
 bool HostResolverImpl::ServeFromCache(const Key& key,
                                       const RequestInfo& info,
                                       int* net_error,
                                       AddressList* addresses) {
   DCHECK(addresses);
   DCHECK(net_error);
   if (!info.allow_cached_response() || !cache_.get())
     return false;
 
   const HostCache::Entry* cache_entry = cache_->Lookup(
       key, base::TimeTicks::Now());
   if (!cache_entry)
     return false;
 
   *net_error = cache_entry->error;
-  if (*net_error == OK)
-    *addresses = CreateAddressListUsingPort(cache_entry->addrlist, info.port());
+  if (*net_error == OK) {
+    *addresses = cache_entry->addrlist;
+    EnsurePortOnAddressList(info.port(), addresses);
+  }
   return true;
 }
 
 bool HostResolverImpl::ServeFromHosts(const Key& key,
                                       const RequestInfo& info,
                                       AddressList* addresses) {
   DCHECK(addresses);
   if (!HaveDnsConfig())
     return false;
 
@@ skipping 180 matching lines @@
 
   if (self && dns_config.IsValid())
     TryServingAllJobsFromHosts();
 }
 
 bool HostResolverImpl::HaveDnsConfig() const {
   return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL);
 }
 
 }  // namespace net