HostResolver supports optional CNAME lookups.

net/base/host_resolver_impl.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 "net/base/net_log.h"
 
 #include <cmath>
 #include <deque>
 
 #include "base/basictypes.h"
@@ skipping 41 matching lines @@
 
   HostResolverImpl* resolver = new HostResolverImpl(
       NULL, CreateDefaultCache(), network_change_notifier, kMaxJobs);
 
   return resolver;
 }
 
 static int ResolveAddrInfo(HostResolverProc* resolver_proc,
                            const std::string& host,
                            AddressFamily address_family,
+                           HostResolverFlags host_resolver_flags,
                            AddressList* out) {
   if (resolver_proc) {
     // Use the custom procedure.
-    return resolver_proc->Resolve(host, address_family, out);
+    return resolver_proc->Resolve(host, address_family,
+                                  host_resolver_flags, out);
   } else {
     // Use the system procedure (getaddrinfo).
-    return SystemHostResolverProc(host, address_family, out);
+    return SystemHostResolverProc(host, address_family,
+                                  host_resolver_flags, out);
   }
 }
 
 //-----------------------------------------------------------------------------
 
 class HostResolverImpl::Request {
  public:
   Request(const BoundNetLog& net_log,
           int id,
           const RequestInfo& info,
@@ skipping 236 matching lines @@
   void DoLookup() {
     if (requests_trace_) {
       requests_trace_->Add(StringPrintf(
           "[resolver thread] Running job j%d", id_));
     }
 
     // Running on the worker thread
     error_ = ResolveAddrInfo(resolver_proc_,
                              key_.hostname,
                              key_.address_family,
+                             key_.host_resolver_flags,
                              &results_);
 
     if (requests_trace_) {
       requests_trace_->Add(StringPrintf(
           "[resolver thread] Completed job j%d", id_));
     }
 
     Task* reply = NewRunnableMethod(this, &Job::OnLookupComplete);
 
     // The origin loop could go away while we are trying to post to it, so we
@@ skipping 400 matching lines @@
       OnFinishRequest(net_log, request_id, info, error);
 
       return error;
     }
   }
 
   // If no callback was specified, do a synchronous resolution.
   if (!callback) {
     AddressList addrlist;
     int error = ResolveAddrInfo(
-        effective_resolver_proc(), key.hostname, key.address_family, &addrlist);
+        effective_resolver_proc(), key.hostname, key.address_family,
+        key.host_resolver_flags, &addrlist);
     if (error == OK) {
       addrlist.SetPort(info.port());
       *addresses = addrlist;
     }
 
     // Write to cache.
     if (cache_.get())
       cache_->Set(key, error, addrlist, base::TimeTicks::Now());
 
     // Update the net log and notify registered observers.
@@ skipping 387 matching lines @@
     JobPool* pool = job_pools_[pool_i];
     pool->MoveRequestsToJob(job);
   }
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
     const RequestInfo& info) const {
   AddressFamily effective_address_family = info.address_family();
   if (effective_address_family == ADDRESS_FAMILY_UNSPECIFIED)
     effective_address_family = default_address_family_;
-  return Key(info.hostname(), effective_address_family);
+  return Key(info.hostname(), effective_address_family,
+             info.host_resolver_flags());
 }
 
 HostResolverImpl::Job* HostResolverImpl::CreateAndStartJob(Request* req) {
   DCHECK(CanCreateJobForPool(*GetPoolForRequest(req)));
   Key key = GetEffectiveKeyForRequest(req->info());
   scoped_refptr<Job> job = new Job(next_job_id_++, this, key, requests_trace_);
   job->AddRequest(req);
   AddOutstandingJob(job);
   job->Start();
   return job.get();
@@ skipping 19 matching lines @@
     if (r == req)
       return error;
 
     r->OnComplete(error, AddressList());
   }
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net