HostResolver supports optional CNAME lookups.

net/base/host_cache_unittest.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/base/host_cache.h"
 
 #include "base/format_macros.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 const int kMaxCacheEntries = 10;
 
 const base::TimeDelta kSuccessEntryTTL = base::TimeDelta::FromSeconds(10);
 const base::TimeDelta kFailureEntryTTL = base::TimeDelta::FromSeconds(0);
 
 // 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);
+  return HostCache::Key(hostname, ADDRESS_FAMILY_UNSPECIFIED, 0);
 }
 
 }  // namespace
 
 TEST(HostCacheTest, Basic) {
   HostCache cache(kMaxCacheEntries, kSuccessEntryTTL, kFailureEntryTTL);
 
   // Start at t=0.
   base::TimeTicks now;
 
@@ skipping 235 matching lines @@
 }
 
 // Tests that the same hostname can be duplicated in the cache, so long as
 // the address family differs.
 TEST(HostCacheTest, AddressFamilyIsPartOfKey) {
   HostCache cache(kMaxCacheEntries, kSuccessEntryTTL, kFailureEntryTTL);
 
   // t=0.
   base::TimeTicks now;
 
-  HostCache::Key key1("foobar.com", ADDRESS_FAMILY_UNSPECIFIED);
-  HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4);
+  HostCache::Key key1("foobar.com", ADDRESS_FAMILY_UNSPECIFIED, 0);
+  HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4, 0);
 
   const HostCache::Entry* entry1 = NULL;  // Entry for key1
   const HostCache::Entry* entry2 = NULL;  // Entry for key2
 
   EXPECT_EQ(0U, cache.size());
 
   // Add an entry for ("foobar.com", UNSPECIFIED) at t=0.
   EXPECT_TRUE(cache.Lookup(key1, base::TimeTicks()) == NULL);
   cache.Set(key1, OK, AddressList(), now);
   entry1 = cache.Lookup(key1, base::TimeTicks());
   EXPECT_FALSE(entry1 == NULL);
   EXPECT_EQ(1U, cache.size());
 
   // Add an entry for ("foobar.com", IPV4_ONLY) at t=0.
   EXPECT_TRUE(cache.Lookup(key2, base::TimeTicks()) == NULL);
   cache.Set(key2, OK, AddressList(), now);
   entry2 = cache.Lookup(key2, base::TimeTicks());
   EXPECT_FALSE(entry2 == NULL);
   EXPECT_EQ(2U, cache.size());
 
   // Even though the hostnames were the same, we should have two unique
   // entries (because the address families differ).
   EXPECT_NE(entry1, entry2);
 }
 
+// Tests that the same hostname can be duplicated in the cache, so long as
+// the HostResolverFlags differ.
+TEST(HostCacheTest, HostResolverFlagsArePartOfKey) {
+  HostCache cache(kMaxCacheEntries, kSuccessEntryTTL, kFailureEntryTTL);
+
+  // t=0.
+  base::TimeTicks now;
+
+  HostCache::Key key1("foobar.com", ADDRESS_FAMILY_IPV4, 0);
+  HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4,
+                      HOST_RESOLVER_FLAGS_CANONNAME);
+
+  const HostCache::Entry* entry1 = NULL;  // Entry for key1
+  const HostCache::Entry* entry2 = NULL;  // Entry for key2
+
+  EXPECT_EQ(0U, cache.size());
+
+  // Add an entry for ("foobar.com", IPV4, NONE) at t=0.
+  EXPECT_TRUE(cache.Lookup(key1, base::TimeTicks()) == NULL);
+  cache.Set(key1, OK, AddressList(), now);
+  entry1 = cache.Lookup(key1, base::TimeTicks());
+  EXPECT_FALSE(entry1 == NULL);
+  EXPECT_EQ(1U, cache.size());
+
+  // Add an entry for ("foobar.com", IPV4, CANONNAME) at t=0.
+  EXPECT_TRUE(cache.Lookup(key2, base::TimeTicks()) == NULL);
+  cache.Set(key2, OK, AddressList(), now);
+  entry2 = cache.Lookup(key2, base::TimeTicks());
+  EXPECT_FALSE(entry2 == NULL);
+  EXPECT_EQ(2U, cache.size());
+
+  // Even though the hostnames were the same, we should have two unique
+  // entries (because the HostResolverFlags differ).
+  EXPECT_NE(entry1, entry2);
+}
+
 TEST(HostCacheTest, NoCache) {
   // Disable caching.
   HostCache cache(0, kSuccessEntryTTL, kFailureEntryTTL);
   EXPECT_TRUE(cache.caching_is_disabled());
 
   // Set t=0.
   base::TimeTicks now;
 
   // Lookup and Set should have no effect.
   EXPECT_TRUE(cache.Lookup(Key("foobar.com"), base::TimeTicks()) == NULL);
@@ skipping 30 matching lines @@
     HostCache::Key key1;
     HostCache::Key key2;
 
     // Expectation.
     //   -1 means key1 is less than key2
     //    0 means key1 equals key2
     //    1 means key1 is greater than key2
     int expected_comparison;
   } tests[] = {
     {
-      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED),
-      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
       0
     },
     {
-      HostCache::Key("host1", ADDRESS_FAMILY_IPV4),
-      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED),
+      HostCache::Key("host1", ADDRESS_FAMILY_IPV4, 0),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
       1
     },
     {
-      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED),
-      HostCache::Key("host1", ADDRESS_FAMILY_IPV4),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
+      HostCache::Key("host1", ADDRESS_FAMILY_IPV4, 0),
       -1
     },
     {
-      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED),
-      HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
+      HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED, 0),
       -1
     },
     {
-      HostCache::Key("host1", ADDRESS_FAMILY_IPV4),
-      HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED),
+      HostCache::Key("host1", ADDRESS_FAMILY_IPV4, 0),
+      HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED, 0),
       1
     },
     {
-      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED),
-      HostCache::Key("host2", ADDRESS_FAMILY_IPV4),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
+      HostCache::Key("host2", ADDRESS_FAMILY_IPV4, 0),
+      -1
+    },
+        {
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED,
+                     HOST_RESOLVER_FLAGS_CANONNAME),
+      -1
+    },
+    {
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED,
+                     HOST_RESOLVER_FLAGS_CANONNAME),
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0),
+      1
+    },
+    {
+      HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED,
+                     HOST_RESOLVER_FLAGS_CANONNAME),
+      HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED,
+                     HOST_RESOLVER_FLAGS_CANONNAME),
       -1
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     SCOPED_TRACE(StringPrintf("Test[%" PRIuS "]", i));
 
     const HostCache::Key& key1 = tests[i].key1;
     const HostCache::Key& key2 = tests[i].key2;
 
@@ skipping 13 matching lines @@
         EXPECT_TRUE(key2 < key1);
         EXPECT_FALSE(key2 == key1);
         break;
       default:
         FAIL() << "Invalid expectation. Can be only -1, 0, 1";
     }
   }
 }
 
 }  // namespace net