Add a mechanism to disable IPv6....

net/base/host_resolver_impl.cc

 // Copyright (c) 2006-2008 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"
 
 #if defined(OS_WIN)
 #include <ws2tcpip.h>
 #include <wspiapi.h>  // Needed for Win2k compat.
 #elif defined(OS_POSIX)
@@ skipping 23 matching lines @@
 namespace net {
 
 HostResolver* CreateSystemHostResolver() {
   static const size_t kMaxHostCacheEntries = 100;
   static const size_t kHostCacheExpirationMs = 60000;  // 1 minute.
   return new HostResolverImpl(
       NULL, kMaxHostCacheEntries, kHostCacheExpirationMs);
 }
 
 static int ResolveAddrInfo(HostResolverProc* resolver_proc,
-                           const std::string& host, AddressList* out) {
+                           const std::string& host,
+                           AddressFamily address_family,
+                           AddressList* out) {
   if (resolver_proc) {
     // Use the custom procedure.
-    return resolver_proc->Resolve(host, out);
+    return resolver_proc->Resolve(host, address_family, out);
   } else {
     // Use the system procedure (getaddrinfo).
-    return SystemHostResolverProc(host, out);
+    return SystemHostResolverProc(host, address_family, out);
   }
 }
 
 //-----------------------------------------------------------------------------
 
 class HostResolverImpl::Request {
  public:
   Request(LoadLog* load_log,
           int id,
           const RequestInfo& info,
@@ skipping 74 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Request);
 };
 
 //-----------------------------------------------------------------------------
 
 // This class represents a request to the worker pool for a "getaddrinfo()"
 // call.
 class HostResolverImpl::Job
     : public base::RefCountedThreadSafe<HostResolverImpl::Job> {
  public:
-  Job(HostResolverImpl* resolver, const std::string& host)
-      : host_(host),
+  Job(HostResolverImpl* resolver, const Key& key)
+      : key_(key),
         resolver_(resolver),
         origin_loop_(MessageLoop::current()),
         resolver_proc_(resolver->effective_resolver_proc()),
         error_(OK) {
   }
 
   ~Job() {
     // Free the requests attached to this job.
     STLDeleteElements(&requests_);
   }
@@ skipping 42 matching lines @@
         resolver->CancelRequest(req);
     }
   }
 
   // Called from origin thread.
   bool was_cancelled() const {
     return resolver_ == NULL;
   }
 
   // Called from origin thread.
-  const std::string& host() const {
-    return host_;
+  const Key& key() const {
+    return key_;
   }
 
   // Called from origin thread.
   const RequestsList& requests() const {
     return requests_;
   }
 
  private:
   void DoLookup() {
     // Running on the worker thread
-    error_ = ResolveAddrInfo(resolver_proc_, host_, &results_);
+    error_ = ResolveAddrInfo(resolver_proc_,
+                             key_.hostname,
+                             key_.address_family,
+                             &results_);
 
     Task* reply = NewRunnableMethod(this, &Job::OnLookupComplete);
 
     // The origin loop could go away while we are trying to post to it, so we
     // need to call its PostTask method inside a lock.  See ~HostResolver.
     {
       AutoLock locked(origin_loop_lock_);
       if (origin_loop_) {
         origin_loop_->PostTask(FROM_HERE, reply);
         reply = NULL;
@@ skipping 18 matching lines @@
     DCHECK(!requests_.empty());
 
      // Use the port number of the first request.
     if (error_ == OK)
       results_.SetPort(requests_[0]->port());
 
     resolver_->OnJobComplete(this, error_, results_);
   }
 
   // Set on the origin thread, read on the worker thread.
-  std::string host_;
+  Key key_;
 
   // Only used on the origin thread (where Resolve was called).
   HostResolverImpl* resolver_;
   RequestsList requests_;  // The requests waiting on this job.
 
   // Used to post ourselves onto the origin thread.
   Lock origin_loop_lock_;
   MessageLoop* origin_loop_;
 
   // Hold an owning reference to the HostResolverProc that we are going to use.
   // This may not be the current resolver procedure by the time we call
   // ResolveAddrInfo, but that's OK... we'll use it anyways, and the owning
   // reference ensures that it remains valid until we are done.
   scoped_refptr<HostResolverProc> resolver_proc_;
 
   // Assigned on the worker thread, read on the origin thread.
   int error_;
   AddressList results_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 //-----------------------------------------------------------------------------
 
 HostResolverImpl::HostResolverImpl(HostResolverProc* resolver_proc,
                                    int max_cache_entries,
                                    int cache_duration_ms)
-    : cache_(max_cache_entries, cache_duration_ms), next_request_id_(0),
-      resolver_proc_(resolver_proc), shutdown_(false) {
+    : cache_(max_cache_entries, cache_duration_ms),
+      next_request_id_(0),
+      resolver_proc_(resolver_proc),
+      disable_ipv6_(false),
+      shutdown_(false) {
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
 }
 
 HostResolverImpl::~HostResolverImpl() {
   // Cancel the outstanding jobs. Those jobs may contain several attached
   // requests, which will also be cancelled.
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->Cancel();
@@ skipping 12 matching lines @@
                               LoadLog* load_log) {
   if (shutdown_)
     return ERR_UNEXPECTED;
 
   // Choose a unique ID number for observers to see.
   int request_id = next_request_id_++;
 
   // Update the load log and notify registered observers.
   OnStartRequest(load_log, request_id, info);
 
+  // Build a key that identifies the request in the cache and in the
+  // outstanding jobs map.
+  Key key(info.hostname(), info.address_family());
+  if (disable_ipv6_)
+    key.address_family = ADDRESS_FAMILY_IPV4_ONLY;
+
   // If we have an unexpired cache entry, use it.
   if (info.allow_cached_response()) {
     const HostCache::Entry* cache_entry = cache_.Lookup(
-        info.hostname(), base::TimeTicks::Now());
+        key, base::TimeTicks::Now());
     if (cache_entry) {
       addresses->SetFrom(cache_entry->addrlist, info.port());
       int error = cache_entry->error;
 
       // Update the load log and notify registered observers.
       OnFinishRequest(load_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(), info.hostname(), &addrlist);
+        effective_resolver_proc(), key.hostname, key.address_family, &addrlist);
     if (error == OK) {
       addrlist.SetPort(info.port());
       *addresses = addrlist;
     }
 
     // Write to cache.
-    cache_.Set(info.hostname(), error, addrlist, base::TimeTicks::Now());
+    cache_.Set(key, error, addrlist, base::TimeTicks::Now());
 
     // Update the load log and notify registered observers.
     OnFinishRequest(load_log, request_id, info, error);
 
     return error;
   }
 
   // Create a handle for this request, and pass it back to the user if they
   // asked for it (out_req != NULL).
   Request* req = new Request(load_log, request_id, info, callback, addresses);
   if (out_req)
     *out_req = reinterpret_cast<RequestHandle>(req);
 
   // Next we need to attach our request to a "job". This job is responsible for
   // calling "getaddrinfo(hostname)" on a worker thread.
   scoped_refptr<Job> job;
 
-  // If there is already an outstanding job to resolve |info.hostname()|, use
+  // If there is already an outstanding job to resolve |key|, use
   // it. This prevents starting concurrent resolves for the same hostname.
-  job = FindOutstandingJob(info.hostname());
+  job = FindOutstandingJob(key);
   if (job) {
     job->AddRequest(req);
   } else {
     // Create a new job for this request.
-    job = new Job(this, info.hostname());
+    job = new Job(this, key);
     job->AddRequest(req);
     AddOutstandingJob(job);
     // TODO(eroman): Bound the total number of concurrent jobs.
     // http://crbug.com/9598
     job->Start();
   }
 
   // Completion happens during OnJobComplete(Job*).
   return ERR_IO_PENDING;
 }
@@ skipping 40 matching lines @@
 void HostResolverImpl::Shutdown() {
   shutdown_ = true;
 
   // Cancel the outstanding jobs.
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->Cancel();
   jobs_.clear();
 }
 
 void HostResolverImpl::AddOutstandingJob(Job* job) {
-  scoped_refptr<Job>& found_job = jobs_[job->host()];
+  scoped_refptr<Job>& found_job = jobs_[job->key()];
   DCHECK(!found_job);
   found_job = job;
 }
 
-HostResolverImpl::Job* HostResolverImpl::FindOutstandingJob(
-    const std::string& hostname) {
-  JobMap::iterator it = jobs_.find(hostname);
+HostResolverImpl::Job* HostResolverImpl::FindOutstandingJob(const Key& key) {
+  JobMap::iterator it = jobs_.find(key);
   if (it != jobs_.end())
     return it->second;
   return NULL;
 }
 
 void HostResolverImpl::RemoveOutstandingJob(Job* job) {
-  JobMap::iterator it = jobs_.find(job->host());
+  JobMap::iterator it = jobs_.find(job->key());
   DCHECK(it != jobs_.end());
   DCHECK_EQ(it->second.get(), job);
   jobs_.erase(it);
 }
 
 void HostResolverImpl::OnJobComplete(Job* job,
                                  int error,
                                  const AddressList& addrlist) {
   RemoveOutstandingJob(job);
 
   // Write result to the cache.
-  cache_.Set(job->host(), error, addrlist, base::TimeTicks::Now());
+  cache_.Set(job->key(), error, addrlist, base::TimeTicks::Now());
 
   // Make a note that we are executing within OnJobComplete() in case the
   // HostResolver is deleted by a callback invocation.
   DCHECK(!cur_completing_job_);
   cur_completing_job_ = job;
 
   // Complete all of the requests that were attached to the job.
   for (RequestsList::const_iterator it = job->requests().begin();
        it != job->requests().end(); ++it) {
     Request* req = *it;
@@ skipping 73 matching lines @@
     }
 
     LoadLog::EndEvent(
         load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONCANCEL);
   }
 
   LoadLog::EndEvent(load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL);
 }
 
 }  // namespace net