Implement host-based deletion for the hostname resolution cache.

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 <string>
+
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const int kMaxCacheEntries = 10;
 
 // Builds a key for |hostname|, defaulting the address family to unspecified.
 HostCache::Key Key(const std::string& hostname) {
   return HostCache::Key(hostname, ADDRESS_FAMILY_UNSPECIFIED, 0);
 }
 
+bool FoobarIndexIsOdd(const std::string& foobarx_com) {
+  return (foobarx_com[6] - '0') % 2 == 1;
+}
+
 }  // namespace
 
 TEST(HostCacheTest, Basic) {
   const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10);
 
   HostCache cache(kMaxCacheEntries);
 
   // Start at t=0.
   base::TimeTicks now;
 
@@ skipping 254 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());
 }
 
+TEST(HostCacheTest, ClearForHosts) {
+  const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10);
+
+  HostCache cache(kMaxCacheEntries);
+
+  // Set t=0.
+  base::TimeTicks now;
+
+  HostCache::Entry entry = HostCache::Entry(OK, AddressList());
+
+  EXPECT_EQ(0u, cache.size());
+
+  // Add several entries.
+  cache.Set(Key("foobar1.com"), entry, now, kTTL);
+  cache.Set(Key("foobar2.com"), entry, now, kTTL);
+  cache.Set(Key("foobar3.com"), entry, now, kTTL);
+  cache.Set(Key("foobar4.com"), entry, now, kTTL);
+  cache.Set(Key("foobar5.com"), entry, now, kTTL);
+
+  EXPECT_EQ(5u, cache.size());
+
+  // Clear the hosts matching a certain predicate, such as the number being odd.
+  cache.ClearForHosts(base::Bind(&FoobarIndexIsOdd));
+
+  EXPECT_EQ(2u, cache.size());
+  EXPECT_TRUE(cache.Lookup(Key("foobar2.com"), now));
+  EXPECT_TRUE(cache.Lookup(Key("foobar4.com"), now));
+
+  // Passing null callback will delete all hosts.
+  cache.ClearForHosts(base::Callback<bool(const std::string&)>());
+
+  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");
@@ skipping 220 matching lines @@
         EXPECT_FALSE(key1 < key2);
         EXPECT_TRUE(key2 < key1);
         break;
       default:
         FAIL() << "Invalid expectation. Can be only -1, 0, 1";
     }
   }
 }
 
 }  // namespace net