Refine IPv6 probe to require that the client has an IPv6 address on an interf...

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"
 #include "net/base/net_log.h"
 
 #include <cmath>
 #include <deque>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/debug_util.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/worker_pool.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver_proc.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
 namespace net {
 
 namespace {
 
@@ skipping 151 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 // This class represents a request to the worker pool for a "getaddrinfo()"
 // call.
 class HostResolverImpl::Job
     : public base::RefCountedThreadSafe<HostResolverImpl::Job> {
  public:
   Job(int id, HostResolverImpl* resolver, const Key& key,
       RequestsTrace* requests_trace)
-      : id_(id), key_(key),
+      : id_(id),
+        key_(key),
         resolver_(resolver),
         origin_loop_(MessageLoop::current()),
         resolver_proc_(resolver->effective_resolver_proc()),
         requests_trace_(requests_trace),
         error_(OK),
         had_non_speculative_request_(false) {
     if (requests_trace_) {
       requests_trace_->Add(StringPrintf(
           "Created job j%d for {hostname='%s', address_family=%d}",
           id_, key.hostname.c_str(),
@@ skipping 208 matching lines @@
   AddressList results_;
 
   // The time when the job was started.
   base::TimeTicks start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 //-----------------------------------------------------------------------------
 
+// This class represents a request to the worker pool for a "probe for IPv6
+// support" call.
+class HostResolverImpl::IPv6ProbeJob
+    : public base::RefCountedThreadSafe<HostResolverImpl::IPv6ProbeJob> {
+ public:
+  explicit IPv6ProbeJob(HostResolverImpl* resolver)
+      : resolver_(resolver),
+        origin_loop_(MessageLoop::current()) {
+  }
+
+  void Start() {
+    DCHECK(IsOnOriginThread());
+    const bool IS_SLOW = true;
+    WorkerPool::PostTask(
+        FROM_HERE, NewRunnableMethod(this, &IPv6ProbeJob::DoProbe), IS_SLOW);
+  }
+
+  // Cancels the current job.
+  void Cancel() {
+    DCHECK(IsOnOriginThread());
+    resolver_ = NULL;  // Read/write ONLY on origin thread.
+    {
+      AutoLock locked(origin_loop_lock_);
+      // Origin loop may be destroyed before we can use it!
+      origin_loop_ = NULL;
+    }
+  }
+
+  bool was_cancelled() const {
+    DCHECK(IsOnOriginThread());
+    return resolver_ == NULL;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<HostResolverImpl::IPv6ProbeJob>;
+
+  ~IPv6ProbeJob() {
+  }
+
+  // Run on worker thread.
+  void DoProbe() {
+    // Do actual testing on this thread, as it takes 40-100ms.
+    AddressFamily family = IPv6Supported() ? ADDRESS_FAMILY_UNSPECIFIED
+                                           : ADDRESS_FAMILY_IPV4;
+
+    Task* reply = NewRunnableMethod(this, &IPv6ProbeJob::OnProbeComplete,
+                                    family);
+
+    // 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);
+        return;
+      }
+    }
+
+    // We didn't post, so delete the reply.
+    delete reply;
+  }
+
+  // Callback for when DoProbe() completes (runs on origin thread).
+  void OnProbeComplete(AddressFamily address_family) {
+    DCHECK(IsOnOriginThread());
+    if (!was_cancelled())
+      resolver_->IPv6ProbeSetDefaultAddressFamily(address_family);
+  }
+
+  bool IsOnOriginThread() const {
+    return !MessageLoop::current() || origin_loop_ == MessageLoop::current();
+  }
+
+  // Used/set only on origin thread.
+  HostResolverImpl* resolver_;
+
+  // Used to post ourselves onto the origin thread.
+  Lock origin_loop_lock_;
+  MessageLoop* origin_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(IPv6ProbeJob);
+};
+
+//-----------------------------------------------------------------------------
+
 // We rely on the priority enum values being sequential having starting at 0,
 // and increasing for lower priorities.
 COMPILE_ASSERT(HIGHEST == 0u &&
                LOWEST > HIGHEST &&
                NUM_PRIORITIES > LOWEST,
                priority_indexes_incompatible);
 
 // JobPool contains all the information relating to queued requests, including
 // the limits on how many jobs are allowed to be used for this category of
 // requests.
@@ skipping 140 matching lines @@
     HostCache* cache,
     NetworkChangeNotifier* network_change_notifier,
     size_t max_jobs)
     : cache_(cache),
       max_jobs_(max_jobs),
       next_request_id_(0),
       next_job_id_(0),
       resolver_proc_(resolver_proc),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       shutdown_(false),
-      network_change_notifier_(network_change_notifier) {
+      network_change_notifier_(network_change_notifier),
+      ipv6_probe_monitoring_(false) {
   DCHECK_GT(max_jobs, 0u);
 
   // It is cumbersome to expose all of the constraints in the constructor,
   // so we choose some defaults, which users can override later.
   job_pools_[POOL_NORMAL] = new JobPool(max_jobs, 100u * max_jobs);
 
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
   if (network_change_notifier_)
     network_change_notifier_->AddObserver(this);
 }
 
 HostResolverImpl::~HostResolverImpl() {
   // Cancel the outstanding jobs. Those jobs may contain several attached
   // requests, which will also be cancelled.
+  DiscardIPv6ProbeJob();
+
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->Cancel();
 
   // In case we are being deleted during the processing of a callback.
   if (cur_completing_job_)
     cur_completing_job_->Cancel();
 
   if (network_change_notifier_)
     network_change_notifier_->RemoveObserver(this);
 
@@ skipping 124 matching lines @@
 void HostResolverImpl::RemoveObserver(HostResolver::Observer* observer) {
   ObserversList::iterator it =
       std::find(observers_.begin(), observers_.end(), observer);
 
   // Observer must exist.
   DCHECK(it != observers_.end());
 
   observers_.erase(it);
 }
 
+void HostResolverImpl::SetDefaultAddressFamily(AddressFamily address_family) {
+  ipv6_probe_monitoring_ = false;
+  DiscardIPv6ProbeJob();
+  default_address_family_ = address_family;
+}
+
+void HostResolverImpl::ProbeIPv6Support() {
+  DCHECK(!ipv6_probe_monitoring_);
+  ipv6_probe_monitoring_ = true;
+  OnIPAddressChanged();  // Give initial setup call.
+}
+
 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::ClearRequestsTrace() {
@@ skipping 213 matching lines @@
 
     net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONCANCEL);
   }
 
   net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL);
 }
 
 void HostResolverImpl::OnIPAddressChanged() {
   if (cache_.get())
     cache_->clear();
+  if (ipv6_probe_monitoring_) {
+    DiscardIPv6ProbeJob();
+    ipv6_probe_job_ = new IPv6ProbeJob(this);
+    ipv6_probe_job_->Start();
+  }
+}
+
+void HostResolverImpl::DiscardIPv6ProbeJob() {
+  if (ipv6_probe_job_.get()) {
+    ipv6_probe_job_->Cancel();
+    ipv6_probe_job_ = NULL;
+  }
+}
+
+void HostResolverImpl::IPv6ProbeSetDefaultAddressFamily(
+    AddressFamily address_family) {
+  DCHECK(address_family == ADDRESS_FAMILY_UNSPECIFIED ||
+         address_family == ADDRESS_FAMILY_IPV4);
+  if (default_address_family_ != address_family)
+      LOG(INFO) << "IPv6Probe forced AddressFamily setting to "
+                << ((address_family == ADDRESS_FAMILY_UNSPECIFIED)
+                        ? "ADDRESS_FAMILY_UNSPECIFIED"
+                        : "ADDRESS_FAMILY_IPV4");
+  default_address_family_ = address_family;
+  // Drop reference since the job has called us back.
+  DiscardIPv6ProbeJob();
 }
 
 // static
 HostResolverImpl::JobPoolIndex HostResolverImpl::GetJobPoolIndexForRequest(
     const Request* req) {
   return POOL_NORMAL;
 }
 
 bool HostResolverImpl::CanCreateJobForPool(const JobPool& pool) const {
   DCHECK_LE(jobs_.size(), max_jobs_);
@@ skipping 67 matching lines @@
     if (r == req)
       return error;
 
     r->OnComplete(error, AddressList());
   }
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net