AsyncHostResolver: integrated HostCache, temporarily, until we have RR cache.

net/base/host_resolver_impl.cc

 // Copyright (c) 2011 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 26 matching lines @@
 #include "net/base/net_util.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
 namespace net {
 
 namespace {
 
-// Helper to create an AddressList that has a particular port. It has an
-// optimization to avoid allocating a new address linked list when the
-// port is already what we want.
-AddressList CreateAddressListUsingPort(const AddressList& src, int port) {
-  if (src.GetPort() == port)
-    return src;
-
-  AddressList out = src;
-  out.SetPort(port);
-  return out;
-}
-
 // 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* addrlist) {
   struct addrinfo* mutable_head =
       const_cast<struct addrinfo*>(addrlist->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";
 #else
     "Net.OSErrorsForGetAddrinfo";
 #endif
 
-HostCache* CreateDefaultCache() {
-  static const size_t kMaxHostCacheEntries = 100;
-
-  HostCache* cache = new HostCache(
-      kMaxHostCacheEntries,
-      base::TimeDelta::FromMinutes(1),
-      base::TimeDelta::FromSeconds(0));  // Disable caching of failed DNS.
-
-  return cache;
-}
-
 // Gets a list of the likely error codes that getaddrinfo() can return
 // (non-exhaustive). These are the error codes that we will track via
 // a histogram.
 std::vector<int> GetAllGetAddrinfoOSErrors() {
   int os_errors[] = {
 #if defined(OS_POSIX)
 #if !defined(OS_FREEBSD)
 #if !defined(OS_ANDROID)
     // EAI_ADDRFAMILY has been declared obsolete in Android's netdb.h.
     EAI_ADDRFAMILY,
@@ skipping 44 matching lines @@
   // Maximum of 8 concurrent resolver threads.
   // 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.
   static const size_t kDefaultMaxJobs = 8u;
 
   if (max_concurrent_resolves == HostResolver::kDefaultParallelism)
     max_concurrent_resolves = kDefaultMaxJobs;
 
   HostResolverImpl* resolver =
-      new HostResolverImpl(NULL, CreateDefaultCache(), max_concurrent_resolves,
-                           max_retry_attempts, net_log);
+      new HostResolverImpl(NULL, HostCache::CreateDefaultCache(),
+          max_concurrent_resolves, max_retry_attempts, net_log);
 
   return resolver;
 }
 
 static int ResolveAddrInfo(HostResolverProc* resolver_proc,
                            const std::string& host,
                            AddressFamily address_family,
                            HostResolverFlags host_resolver_flags,
                            AddressList* out,
                            int* os_error) {
@@ skipping 1455 matching lines @@
     additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
   } else {
     additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
   }
 #endif
   AbortAllInProgressJobs();
   // |this| may be deleted inside AbortAllInProgressJobs().
 }
 
 }  // namespace net