net/dns/host_cache.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_DNS_HOST_CACHE_H_
   6 #define NET_DNS_HOST_CACHE_H_
   7
   8 #include <functional>
   9 #include <string>
  10
  11 #include "base/gtest_prod_util.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/threading/non_thread_safe.h"
  14 #include "base/time/time.h"
  15 #include "net/base/address_family.h"
  16 #include "net/base/address_list.h"
  17 #include "net/base/expiring_cache.h"
  18 #include "net/base/net_export.h"
  19
  20 namespace net {
  21
  22 // Cache used by HostResolver to map hostnames to their resolved result.
  23 class NET_EXPORT HostCache : NON_EXPORTED_BASE(public base::NonThreadSafe) {
  24  public:
  25   // Stores the latest address list that was looked up for a hostname.
  26   struct NET_EXPORT Entry {
  27     Entry(int error, const AddressList& addrlist, base::TimeDelta ttl);
  28     // Use when |ttl| is unknown.
  29     Entry(int error, const AddressList& addrlist);
  30     ~Entry();
  31
  32     bool has_ttl() const { return ttl >= base::TimeDelta(); }
  33
  34     // The resolve results for this entry.
  35     int error;
  36     AddressList addrlist;
  37     // TTL obtained from the nameserver. Negative if unknown.
  38     base::TimeDelta ttl;
  39   };
  40
  41   struct Key {
  42     Key(const std::string& hostname, AddressFamily address_family,
  43         HostResolverFlags host_resolver_flags)
  44         : hostname(hostname),
  45           address_family(address_family),
  46           host_resolver_flags(host_resolver_flags) {}
  47
  48     bool operator<(const Key& other) const {
  49       // |address_family| and |host_resolver_flags| are compared before
  50       // |hostname| under assumption that integer comparisons are faster than
  51       // string comparisons.
  52       if (address_family != other.address_family)
  53         return address_family < other.address_family;
  54       if (host_resolver_flags != other.host_resolver_flags)
  55         return host_resolver_flags < other.host_resolver_flags;
  56       return hostname < other.hostname;
  57     }
  58
  59     std::string hostname;
  60     AddressFamily address_family;
  61     HostResolverFlags host_resolver_flags;
  62   };
  63
  64   struct EvictionHandler {
  65     void Handle(const Key& key,
  66                 const Entry& entry,
  67                 const base::TimeTicks& expiration,
  68                 const base::TimeTicks& now,
  69                 bool onGet) const;
  70   };
  71
  72   typedef ExpiringCache<Key, Entry, base::TimeTicks,
  73                         std::less<base::TimeTicks>,
  74                         EvictionHandler> EntryMap;
  75
  76   // Constructs a HostCache that stores up to |max_entries|.
  77   explicit HostCache(size_t max_entries);
  78
  79   ~HostCache();
  80
  81   // Returns a pointer to the entry for |key|, which is valid at time
  82   // |now|. If there is no such entry, returns NULL.
  83   const Entry* Lookup(const Key& key, base::TimeTicks now);
  84
  85   // Overwrites or creates an entry for |key|.
  86   // |entry| is the value to set, |now| is the current time
  87   // |ttl| is the "time to live".
  88   void Set(const Key& key,
  89            const Entry& entry,
  90            base::TimeTicks now,
  91            base::TimeDelta ttl);
  92
  93   // Empties the cache
  94   void clear();
  95
  96   // Returns the number of entries in the cache.
  97   size_t size() const;
  98
  99   // Following are used by net_internals UI.
 100   size_t max_entries() const;
 101
 102   const EntryMap& entries() const;
 103
 104   // Creates a default cache.
 105   static scoped_ptr<HostCache> CreateDefaultCache();
 106
 107  private:
 108   FRIEND_TEST_ALL_PREFIXES(HostCacheTest, NoCache);
 109
 110   // Returns true if this HostCache can contain no entries.
 111   bool caching_is_disabled() const {
 112     return entries_.max_entries() == 0;
 113   }
 114
 115   // Map from hostname (presumably in lowercase canonicalized format) to
 116   // a resolved result entry.
 117   EntryMap entries_;
 118
 119   DISALLOW_COPY_AND_ASSIGN(HostCache);
 120 };
 121
 122 }  // namespace net
 123
 124 #endif  // NET_DNS_HOST_CACHE_H_