Cache failed DNS resolutions for 1 second....

net/base/host_resolver_impl.h

 // 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.
 
 #ifndef NET_BASE_HOST_RESOLVER_IMPL_H_
 #define NET_BASE_HOST_RESOLVER_IMPL_H_
 
 #include <string>
 #include <vector>
 
+#include "base/scoped_ptr.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_proc.h"
 
 namespace net {
 
 // For each hostname that is requested, HostResolver creates a
 // HostResolverImpl::Job. This job gets dispatched to a thread in the global
 // WorkerPool, where it runs SystemHostResolverProc(). If requests for that same
 // host are made while the job is already outstanding, then they are attached
@@ skipping 13 matching lines @@
 //
 //
 // When a HostResolverImpl::Job finishes its work in the threadpool, the
 // callbacks of each waiting request are run on the origin thread.
 //
 // Thread safety: This class is not threadsafe, and must only be called
 // from one thread!
 //
 class HostResolverImpl : public HostResolver {
  public:
-  // Creates a HostResolver that caches up to |max_cache_entries| for
-  // |cache_duration_ms| milliseconds. |resolver_proc| is used to perform
-  // the actual resolves; it must be thread-safe since it is run from
-  // multiple worker threads. If |resolver_proc| is NULL then the default
-  // host resolver procedure is used (which is SystemHostResolverProc except
-  // if overridden)
-  HostResolverImpl(HostResolverProc* resolver_proc,
-                   int max_cache_entries,
-                   int cache_duration_ms);
+  // Creates a HostResolver that first uses the local cache |cache|, and then
+  // falls back to |resolver_proc|.
+  //
+  // If |cache| is NULL, then no caching is used. Otherwise we take
+  // ownership of the |cache| pointer, and will free at during destructor.
+  //
+  // |resolver_proc| is used to perform the actual resolves; it must be
+  // thread-safe since it is run from multiple worker threads. If
+  // |resolver_proc| is NULL then the default host resolver procedure is
+  // used (which is SystemHostResolverProc except if overridden).
+  HostResolverImpl(HostResolverProc* resolver_proc, HostCache* cache);
 
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
                       CompletionCallback* callback,
                       RequestHandle* out_req,
                       LoadLog* load_log);
   virtual void CancelRequest(RequestHandle req);
   virtual void AddObserver(Observer* observer);
   virtual void RemoveObserver(Observer* observer);
@@ skipping 47 matching lines @@
                        int request_id,
                        const RequestInfo& info,
                        int error);
 
   // Called when a request has been cancelled.
   void OnCancelRequest(LoadLog* load_log,
                        int request_id,
                        const RequestInfo& info);
 
   // Cache of host resolution results.
-  HostCache cache_;
+  scoped_ptr<HostCache> cache_;
 
   // Map from hostname to outstanding job.
   JobMap jobs_;
 
   // The job that OnJobComplete() is currently processing (needed in case
   // HostResolver gets deleted from within the callback).
   scoped_refptr<Job> cur_completing_job_;
 
   // The observers to notify when a request starts/ends.
   ObserversList observers_;
@@ skipping 11 matching lines @@
 
   // TODO(eroman): temp hack for http://crbug.com/15513
   bool shutdown_;
 
   DISALLOW_COPY_AND_ASSIGN(HostResolverImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_IMPL_H_