Cache failed DNS resolutions for 1 second....

net/base/host_resolver_impl.cc

 // Copyright (c) 2006-2008 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 <ws2tcpip.h>
 #include <wspiapi.h>  // Needed for Win2k compat.
 #elif defined(OS_POSIX)
@@ skipping 17 matching lines @@
 #include "net/base/net_errors.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
 namespace net {
 
 HostResolver* CreateSystemHostResolver() {
   static const size_t kMaxHostCacheEntries = 100;
-  static const size_t kHostCacheExpirationMs = 60000;  // 1 minute.
-  return new HostResolverImpl(
-      NULL, kMaxHostCacheEntries, kHostCacheExpirationMs);
+
+  HostCache* cache = new HostCache(
+      kMaxHostCacheEntries,
+      base::TimeDelta::FromMinutes(1),
+      base::TimeDelta::FromSeconds(1));
+
+  return new HostResolverImpl(NULL, cache);
 }
 
 static int ResolveAddrInfo(HostResolverProc* resolver_proc,
                            const std::string& host,
                            AddressFamily address_family,
                            AddressList* out) {
   if (resolver_proc) {
     // Use the custom procedure.
     return resolver_proc->Resolve(host, address_family, out);
   } else {
@@ skipping 229 matching lines @@
   // Assigned on the worker thread, read on the origin thread.
   int error_;
   AddressList results_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 //-----------------------------------------------------------------------------
 
 HostResolverImpl::HostResolverImpl(HostResolverProc* resolver_proc,
-                                   int max_cache_entries,
-                                   int cache_duration_ms)
-    : cache_(max_cache_entries, cache_duration_ms),
+                                   HostCache* cache)
+    : cache_(cache),
       next_request_id_(0),
       resolver_proc_(resolver_proc),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       shutdown_(false) {
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
 }
 
 HostResolverImpl::~HostResolverImpl() {
@@ skipping 23 matching lines @@
   // Update the load log and notify registered observers.
   OnStartRequest(load_log, request_id, info);
 
   // Build a key that identifies the request in the cache and in the
   // outstanding jobs map.
   Key key(info.hostname(), info.address_family());
   if (key.address_family == ADDRESS_FAMILY_UNSPECIFIED)
     key.address_family = default_address_family_;
 
   // If we have an unexpired cache entry, use it.
-  if (info.allow_cached_response()) {
-    const HostCache::Entry* cache_entry = cache_.Lookup(
+  if (info.allow_cached_response() && cache_.get()) {
+    const HostCache::Entry* cache_entry = cache_->Lookup(
         key, base::TimeTicks::Now());
     if (cache_entry) {
-      addresses->SetFrom(cache_entry->addrlist, info.port());
       int error = cache_entry->error;
+      if (error == OK)
+        addresses->SetFrom(cache_entry->addrlist, info.port());
 
       // Update the load log and notify registered observers.
       OnFinishRequest(load_log, request_id, info, error);
 
       return error;
     }
   }
 
   // If no callback was specified, do a synchronous resolution.
   if (!callback) {
     AddressList addrlist;
     int error = ResolveAddrInfo(
         effective_resolver_proc(), key.hostname, key.address_family, &addrlist);
     if (error == OK) {
       addrlist.SetPort(info.port());
       *addresses = addrlist;
     }
 
     // Write to cache.
-    cache_.Set(key, error, addrlist, base::TimeTicks::Now());
+    if (cache_.get())
+      cache_->Set(key, error, addrlist, base::TimeTicks::Now());
 
     // Update the load log and notify registered observers.
     OnFinishRequest(load_log, request_id, info, error);
 
     return error;
   }
 
   // Create a handle for this request, and pass it back to the user if they
   // asked for it (out_req != NULL).
   Request* req = new Request(load_log, request_id, info, callback, addresses);
@@ skipping 50 matching lines @@
   ObserversList::iterator it =
       std::find(observers_.begin(), observers_.end(), observer);
 
   // Observer must exist.
   DCHECK(it != observers_.end());
 
   observers_.erase(it);
 }
 
 HostCache* HostResolverImpl::GetHostCache() {
-  return &cache_;
+  return cache_.get();
 }
 
 void HostResolverImpl::Shutdown() {
   shutdown_ = true;
 
   // Cancel the outstanding jobs.
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->Cancel();
   jobs_.clear();
 }
@@ skipping 17 matching lines @@
   DCHECK_EQ(it->second.get(), job);
   jobs_.erase(it);
 }
 
 void HostResolverImpl::OnJobComplete(Job* job,
                                      int error,
                                      const AddressList& addrlist) {
   RemoveOutstandingJob(job);
 
   // Write result to the cache.
-  cache_.Set(job->key(), error, addrlist, base::TimeTicks::Now());
+  if (cache_.get())
+    cache_->Set(job->key(), error, addrlist, base::TimeTicks::Now());
 
   // Make a note that we are executing within OnJobComplete() in case the
   // HostResolver is deleted by a callback invocation.
   DCHECK(!cur_completing_job_);
   cur_completing_job_ = job;
 
   // Complete all of the requests that were attached to the job.
   for (RequestsList::const_iterator it = job->requests().begin();
        it != job->requests().end(); ++it) {
     Request* req = *it;
@@ skipping 73 matching lines @@
     }
 
     LoadLog::EndEvent(
         load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONCANCEL);
   }
 
   LoadLog::EndEvent(load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL);
 }
 
 }  // namespace net