HostResolver supports optional CNAME lookups.

net/base/host_cache.h

-// 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.
 
 #ifndef NET_BASE_HOST_CACHE_H_
 #define NET_BASE_HOST_CACHE_H_
 
 #include <map>
 #include <string>
 
 #include "base/ref_counted.h"
@@ skipping 18 matching lines @@
     // The time when this entry expires.
     base::TimeTicks expiration;
 
    private:
     friend class base::RefCounted<Entry>;
 
     ~Entry();
   };
 
   struct Key {
-    Key(const std::string& hostname, AddressFamily address_family)
-        : hostname(hostname), address_family(address_family) {}
+    Key(const std::string& hostname, AddressFamily address_family,
+        HostResolverFlags host_resolver_flags)
+        : hostname(hostname),
+          address_family(address_family),
+          host_resolver_flags(host_resolver_flags) {}
 
     bool operator==(const Key& other) const {
-      return other.hostname == hostname &&
-             other.address_family == address_family;
+      return (other.address_family == address_family &&
+              other.host_resolver_flags == host_resolver_flags &&
+              other.hostname == hostname);
     }
 
     bool operator<(const Key& other) const {
-      if (address_family == other.address_family)
-        return hostname < other.hostname;
-      return address_family < other.address_family;
+      if (address_family != other.address_family)
+        return address_family < other.address_family;
+      if (host_resolver_flags != other.host_resolver_flags)
+        return host_resolver_flags < other.host_resolver_flags;
+      return hostname < other.hostname;
     }
 
     std::string hostname;
     AddressFamily address_family;
+    HostResolverFlags host_resolver_flags;
   };
 
   typedef std::map<Key, scoped_refptr<Entry> > EntryMap;
 
   // Constructs a HostCache that caches successful host resolves for
   // |success_entry_ttl| time, and failed host resolves for
   // |failure_entry_ttl|. The cache will store up to |max_entries|.
   HostCache(size_t max_entries,
             base::TimeDelta success_entry_ttl,
             base::TimeDelta failure_entry_ttl);
@@ skipping 66 matching lines @@
   // 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_