Cache failed DNS resolutions for 1 second....

net/base/host_cache.h

 // Copyright (c) 2009 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_CACHE_H_
 #define NET_BASE_HOST_CACHE_H_
 
 #include <map>
 #include <string>
 
@@ skipping 39 matching lines @@
         return hostname < other.hostname;
       return address_family < other.address_family;
     }
 
     std::string hostname;
     AddressFamily address_family;
   };
 
   typedef std::map<Key, scoped_refptr<Entry> > EntryMap;
 
-  // Constructs a HostCache whose entries are valid for |cache_duration_ms|
-  // milliseconds. The cache will store up to |max_entries|.
-  HostCache(size_t max_entries, size_t cache_duration_ms);
+  // Constructs a HostCache that caches successful host resolves for
+  // |success_entry_ttl| time, and failed host resolves for
+  // |failure_entry_ttl|. The cache will store up to |max_entries|.
+  HostCache(size_t max_entries,
+            base::TimeDelta success_entry_ttl,
+            base::TimeDelta failure_entry_ttl);
 
   ~HostCache();
 
   // Returns a pointer to the entry for |key|, which is valid at time
   // |now|. If there is no such entry, returns NULL.
   const Entry* Lookup(const Key& key, base::TimeTicks now) const;
 
   // Overwrites or creates an entry for |key|. Returns the pointer to the
   // entry, or NULL on failure (fails if caching is disabled).
   // (|error|, |addrlist|) is the value to set, and |now| is the current
@@ skipping 10 matching lines @@
 
   // Returns the number of entries in the cache.
   size_t size() const {
     return entries_.size();
   }
 
   size_t max_entries() const {
     return max_entries_;
   }
 
-  size_t cache_duration_ms() const {
-    return cache_duration_ms_;
+  base::TimeDelta success_entry_ttl() const {
+    return success_entry_ttl_;
+  }
+
+  base::TimeDelta failure_entry_ttl() const {
+    return failure_entry_ttl_;
   }
 
   // Note that this map may contain expired entries.
   const EntryMap& entries() const {
     return entries_;
   }
 
  private:
   FRIEND_TEST(HostCacheTest, Compact);
   FRIEND_TEST(HostCacheTest, NoCache);
 
   // Returns true if this cache entry's result is valid at time |now|.
   static bool CanUseEntry(const Entry* entry, const base::TimeTicks now);
 
   // Prunes entries from the cache to bring it below max entry bound. Entries
   // matching |pinned_entry| will NOT be pruned.
   void Compact(base::TimeTicks now, const Entry* pinned_entry);
 
   // Bound on total size of the cache.
   size_t max_entries_;
 
-  // Time to live for cache entries in milliseconds.
-  size_t cache_duration_ms_;
+  // Time to live for cache entries.
+  base::TimeDelta success_entry_ttl_;
+  base::TimeDelta failure_entry_ttl_;
 
   // Map from hostname (presumably in lowercase canonicalized format) to
   // a resolved result entry.
   EntryMap entries_;
 
   DISALLOW_COPY_AND_ASSIGN(HostCache);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_CACHE_H_