DNS: Retain stale entries in HostCache and return when requested

net/dns/host_cache_unittest.cc

 // Copyright (c) 2012 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/dns/host_cache.h"
 
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 24 matching lines @@
   HostCache::Key key1 = Key("foobar.com");
   HostCache::Key key2 = Key("foobar2.com");
   HostCache::Entry entry = HostCache::Entry(OK, AddressList());
 
   EXPECT_EQ(0U, cache.size());
 
   // Add an entry for "foobar.com" at t=0.
   EXPECT_FALSE(cache.Lookup(key1, now));
   cache.Set(key1, entry, now, kTTL);
   EXPECT_TRUE(cache.Lookup(key1, now));
-  EXPECT_TRUE(cache.Lookup(key1, now)->error == entry.error);
+  EXPECT_TRUE(cache.Lookup(key1, now)->error() == entry.error());
 
   EXPECT_EQ(1U, cache.size());
 
   // Advance to t=5.
   now += base::TimeDelta::FromSeconds(5);
 
   // Add an entry for "foobar2.com" at t=5.
   EXPECT_FALSE(cache.Lookup(key2, now));
   cache.Set(key2, entry, now, kTTL);
   EXPECT_TRUE(cache.Lookup(key2, now));
@@ skipping 190 matching lines @@
   EXPECT_EQ(3U, cache.size());
 
   // Even though the hostnames were the same, we should have two unique
   // entries (because the HostResolverFlags differ).
   EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now));
   EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key3, now));
   EXPECT_NE(cache.Lookup(key2, now), cache.Lookup(key3, now));
 }
 
 TEST(HostCacheTest, NoCache) {
-  // Disable caching.
   const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10);
 
+  // Disable caching.
   HostCache cache(0);
   EXPECT_TRUE(cache.caching_is_disabled());
 
   // Set t=0.
   base::TimeTicks now;
 
   HostCache::Entry entry = HostCache::Entry(OK, AddressList());
 
   // Lookup and Set should have no effect.
   EXPECT_FALSE(cache.Lookup(Key("foobar.com"),now));
@@ skipping 20 matching lines @@
   cache.Set(Key("foobar2.com"), entry, now, kTTL);
   cache.Set(Key("foobar3.com"), entry, now, kTTL);
 
   EXPECT_EQ(3u, cache.size());
 
   cache.clear();
 
   EXPECT_EQ(0u, cache.size());
 }
 
+// Try to add too many entries to cache; it should evict the one with the oldest
+// expiration time.
+TEST(HostCacheTest, Evict) {
+  HostCache cache(2);
+
+  base::TimeTicks now;
+
+  HostCache::Key key1 = Key("foobar.com");
+  HostCache::Key key2 = Key("foobar2.com");
+  HostCache::Key key3 = Key("foobar3.com");
+  HostCache::Entry entry = HostCache::Entry(OK, AddressList());
+
+  EXPECT_EQ(0u, cache.size());
+  EXPECT_FALSE(cache.Lookup(key1, now));
+  EXPECT_FALSE(cache.Lookup(key2, now));
+  EXPECT_FALSE(cache.Lookup(key3, now));
+
+  // |key1| expires in 10 seconds, but |key2| in just 5.
+  cache.Set(key1, entry, now, base::TimeDelta::FromSeconds(10));
+  cache.Set(key2, entry, now, base::TimeDelta::FromSeconds(5));
+  EXPECT_EQ(2u, cache.size());
+  EXPECT_TRUE(cache.Lookup(key1, now));
+  EXPECT_TRUE(cache.Lookup(key2, now));
+  EXPECT_FALSE(cache.Lookup(key3, now));
+
+  // |key2| should be chosen for eviction, since it expires sooner.
+  cache.Set(key3, entry, now, base::TimeDelta::FromSeconds(10));
+  EXPECT_EQ(2u, cache.size());
+  EXPECT_TRUE(cache.Lookup(key1, now));
+  EXPECT_FALSE(cache.Lookup(key2, now));
+  EXPECT_TRUE(cache.Lookup(key3, now));
+}
+
+// Try to retrieve stale entries from the cache. They should be returned by
+// |LookupStale()| but not |Lookup()|, with correct |EntryStaleness| data.
+TEST(HostCacheTest, Stale) {
+  const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10);
+
+  HostCache cache(kMaxCacheEntries);
+
+  // Start at t=0.
+  base::TimeTicks now;
+  HostCache::EntryStaleness stale;
+
+  HostCache::Key key = Key("foobar.com");
+  HostCache::Entry entry = HostCache::Entry(OK, AddressList());
+
+  EXPECT_EQ(0U, cache.size());
+
+  // Add an entry for "foobar.com" at t=0.
+  EXPECT_FALSE(cache.Lookup(key, now));
+  EXPECT_FALSE(cache.LookupStale(key, now, &stale));
+  cache.Set(key, entry, now, kTTL);
+  EXPECT_TRUE(cache.Lookup(key, now));
+  EXPECT_TRUE(cache.LookupStale(key, now, &stale));
+  EXPECT_FALSE(stale.is_stale());
+  EXPECT_EQ(0, stale.stale_hits);
+
+  EXPECT_EQ(1U, cache.size());
+
+  // Advance to t=5.
+  now += base::TimeDelta::FromSeconds(5);
+
+  EXPECT_TRUE(cache.Lookup(key, now));
+  EXPECT_TRUE(cache.LookupStale(key, now, &stale));
+  EXPECT_FALSE(stale.is_stale());
+  EXPECT_EQ(0, stale.stale_hits);
+
+  // Advance to t=15.
+  now += base::TimeDelta::FromSeconds(10);
+
+  EXPECT_FALSE(cache.Lookup(key, now));
+  EXPECT_TRUE(cache.LookupStale(key, now, &stale));
+  EXPECT_TRUE(stale.is_stale());
+  EXPECT_EQ(base::TimeDelta::FromSeconds(5), stale.expired_by);
+  EXPECT_EQ(0, stale.network_changes);
+  EXPECT_EQ(1, stale.stale_hits);
+
+  // Advance to t=20.
+  now += base::TimeDelta::FromSeconds(5);
+
+  EXPECT_FALSE(cache.Lookup(key, now));
+  EXPECT_TRUE(cache.LookupStale(key, now, &stale));
+  EXPECT_TRUE(stale.is_stale());
+  EXPECT_EQ(base::TimeDelta::FromSeconds(10), stale.expired_by);
+  EXPECT_EQ(0, stale.network_changes);
+  EXPECT_EQ(2, stale.stale_hits);
+
+  // Simulate network change.
+  cache.OnNetworkChange();
+
+  EXPECT_FALSE(cache.Lookup(key, now));
+  EXPECT_TRUE(cache.LookupStale(key, now, &stale));
+  EXPECT_TRUE(stale.is_stale());
+  EXPECT_EQ(base::TimeDelta::FromSeconds(10), stale.expired_by);
+  EXPECT_EQ(1, stale.network_changes);
+  EXPECT_EQ(3, stale.stale_hits);
+}
+
 // Tests the less than and equal operators for HostCache::Key work.
 TEST(HostCacheTest, KeyComparators) {
   struct {
     // Inputs.
     HostCache::Key key1;
     HostCache::Key key2;
 
     // Expectation.
     //   -1 means key1 is less than key2
     //    0 means key1 equals key2
@@ skipping 70 matching lines @@
         EXPECT_FALSE(key1 < key2);
         EXPECT_TRUE(key2 < key1);
         break;
       default:
         FAIL() << "Invalid expectation. Can be only -1, 0, 1";
     }
   }
 }
 
 }  // namespace net