HostResolver supports optional CNAME lookups.

net/base/host_resolver_impl_unittest.cc

-// Copyright (c) 2006-2008 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_resolver_impl.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
@@ skipping 54 matching lines @@
   return info;
 }
 
 // A variant of WaitingHostResolverProc that pushes each host mapped into a
 // list.
 // (and uses a manual-reset event rather than auto-reset).
 class CapturingHostResolverProc : public HostResolverProc {
  public:
   struct CaptureEntry {
     CaptureEntry(const std::string& hostname, AddressFamily address_family)
-        : hostname(hostname), address_family(address_family) {}
+        : hostname(hostname),
+          address_family(address_family) {}
     std::string hostname;
     AddressFamily address_family;
   };
 
   typedef std::vector<CaptureEntry> CaptureList;
 
   explicit CapturingHostResolverProc(HostResolverProc* previous)
       : HostResolverProc(previous), event_(true, false) {
   }
 
   void Signal() {
     event_.Signal();
   }
 
   virtual int Resolve(const std::string& hostname,
                       AddressFamily address_family,
+                      HostResolverFlags host_resolver_flags,
                       AddressList* addrlist) {
     event_.Wait();
     {
       AutoLock l(lock_);
       capture_list_.push_back(CaptureEntry(hostname, address_family));
     }
-    return ResolveUsingPrevious(hostname, address_family, addrlist);
+    return ResolveUsingPrevious(hostname, address_family,
+                                host_resolver_flags, addrlist);
   }
 
   CaptureList GetCaptureList() const {
     CaptureList copy;
     {
       AutoLock l(lock_);
       copy = capture_list_;
     }
     return copy;
   }
@@ skipping 17 matching lines @@
 //   x = length of hostname
 //   y = ASCII value of hostname[0]
 //   z = value of address_family
 //
 class EchoingHostResolverProc : public HostResolverProc {
  public:
   EchoingHostResolverProc() : HostResolverProc(NULL) {}
 
   virtual int Resolve(const std::string& hostname,
                       AddressFamily address_family,
+                      HostResolverFlags host_resolver_flags,
                       AddressList* addrlist) {
     // Encode the request's hostname and address_family in the output address.
     std::string ip_literal = StringPrintf("192.%d.%d.%d",
         static_cast<int>(hostname.size()),
         static_cast<int>(hostname[0]),
         static_cast<int>(address_family));
 
     return SystemHostResolverProc(ip_literal,
                                   ADDRESS_FAMILY_UNSPECIFIED,
+                                  host_resolver_flags,
                                   addrlist);
   }
 };
 
 // Helper that represents a single Resolve() result, used to inspect all the
 // resolve results by forwarding them to Delegate.
 class ResolveRequest {
  public:
   // Delegate interface, for notification when the ResolveRequest completes.
   class Delegate {
@@ skipping 1328 matching lines @@
   // Addresses take the form: 192.x.y.z
   //    x = length of hostname
   //    y = ASCII value of hostname[0]
   //    z = value of address family
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[0].head()));
   EXPECT_EQ("192.1.98.2", NetAddressToString(addrlist[1].head()));
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[2].head()));
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[3].head()));
 }
 
+// TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
+
 }  // namespace
 
 }  // namespace net