Avoid doing concurrent DNS resolves of the same hostname

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 <string>
+
+#include "base/hash_tables.h"
+#include "base/ref_counted.h"
+#include "base/time.h"
+#include "net/base/address_list.h"
+#include "testing/gtest/include/gtest/gtest_prod.h"
+
+namespace net {
+
+// Cache used by HostResolver to map hostnames to their resolved result.
+// If the resolve is still in progress, the entry will reference the job
+// responsible for populating it.
+class HostCache {
+ public:
+  // Stores the latest address list that was looked up for a hostname.
+  struct Entry : public base::RefCounted<Entry> {
+    Entry(int error, const AddressList& addrlist, base::TimeTicks expiration);
+    ~Entry();
+
+    // The resolve results for this entry.
+    int error;
+    AddressList addrlist;
+
+    // The time when this entry expires.
+    base::TimeTicks expiration;
+  };
+
+  // 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);
+
+  ~HostCache();
+
+  // Returns a pointer to the entry for |hostname|, which is valid at time
+  // |now|. If there is no such entry, returns NULL.
+  const Entry* Lookup(const std::string& hostname, base::TimeTicks now) const;
+
+  // Overwrites or creates an entry for |hostname|. 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
+  // timestamp.
+  Entry* Set(const std::string& hostname,
+             int error,
+             const AddressList addrlist,
+             base::TimeTicks now);
+
+  // Returns true if this HostCache can contain no entries.
+  bool caching_is_disabled() const {
+    return max_entries_ == 0;
+  }
+
+  // Returns the number of entries in the cache.
+  size_t size() const {
+    return entries_.size();
+  }
+
+ private:
+  FRIEND_TEST(HostCacheTest, Compact);
+  FRIEND_TEST(HostCacheTest, NoCache);
+
+  typedef base::hash_map<std::string, scoped_refptr<Entry> > EntryMap;
+
+  // 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_;
+
+  // 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_