Remove interface probing for IPv6 support from HostResolverImpl

net/dns/host_resolver_impl.cc

 // Copyright (c) 2012 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/dns/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 904 matching lines @@
 
   AddressList results_;
 
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcTask);
 };
 
 //-----------------------------------------------------------------------------
 
-// Wraps a call to TestIPv6Support to be executed on the WorkerPool as it takes
-// 40-100ms.
-// TODO(szym): Remove altogether, if IPv6ActiveProbe works.
-class HostResolverImpl::IPv6ProbeJob {
- public:
-  IPv6ProbeJob(const base::WeakPtr<HostResolverImpl>& resolver, NetLog* net_log)
-      : resolver_(resolver),
-        net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_IPV6_PROBE_JOB)),
-        result_(false, IPV6_SUPPORT_MAX, OK) {
-    DCHECK(resolver.get());
-    net_log_.BeginEvent(NetLog::TYPE_IPV6_PROBE_RUNNING);
-    const bool kIsSlow = true;
-    base::WorkerPool::PostTaskAndReply(
-        FROM_HERE,
-        base::Bind(&IPv6ProbeJob::DoProbe, base::Unretained(this)),
-        base::Bind(&IPv6ProbeJob::OnProbeComplete, base::Owned(this)),
-        kIsSlow);
-  }
-
-  virtual ~IPv6ProbeJob() {}
-
- private:
-  // Runs on worker thread.
-  void DoProbe() {
-    result_ = TestIPv6Support();
-  }
-
-  void OnProbeComplete() {
-    net_log_.EndEvent(NetLog::TYPE_IPV6_PROBE_RUNNING,
-                      base::Bind(&IPv6SupportResult::ToNetLogValue,
-                                 base::Unretained(&result_)));
-    if (!resolver_.get())
-      return;
-    resolver_->IPv6ProbeSetDefaultAddressFamily(
-        result_.ipv6_supported ? ADDRESS_FAMILY_UNSPECIFIED
-                                      : ADDRESS_FAMILY_IPV4);
-  }
-
-  // Used/set only on origin thread.
-  base::WeakPtr<HostResolverImpl> resolver_;
-
-  BoundNetLog net_log_;
-
-  IPv6SupportResult result_;
-
-  DISALLOW_COPY_AND_ASSIGN(IPv6ProbeJob);
-};
-
 // Wraps a call to HaveOnlyLoopbackAddresses to be executed on the WorkerPool as
 // it takes 40-100ms and should not block initialization.
 class HostResolverImpl::LoopbackProbeJob {
  public:
   explicit LoopbackProbeJob(const base::WeakPtr<HostResolverImpl>& resolver)
       : resolver_(resolver),
         result_(false) {
     DCHECK(resolver.get());
     const bool kIsSlow = true;
     base::WorkerPool::PostTaskAndReply(
@@ skipping 757 matching lines @@
     : cache_(cache.Pass()),
       dispatcher_(job_limits),
       max_queued_jobs_(job_limits.total_jobs * 100u),
       proc_params_(proc_params),
       net_log_(net_log),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       weak_ptr_factory_(this),
       probe_weak_ptr_factory_(this),
       received_dns_config_(false),
       num_dns_failures_(0),
-      ipv6_probe_monitoring_(false),
+      probe_ipv6_support_(true),
       resolved_known_ipv6_hostname_(false),
       additional_resolver_flags_(0),
       fallback_to_proctask_(true) {
 
   DCHECK_GE(dispatcher_.num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
 
   // Maximum of 4 retry attempts for host resolution.
   static const size_t kDefaultMaxRetryAttempts = 4u;
 
   if (proc_params_.max_retry_attempts == HostResolver::kDefaultRetryAttempts)
@@ skipping 159 matching lines @@
   Request* req = reinterpret_cast<Request*>(req_handle);
   DCHECK(req);
   Job* job = req->job();
   DCHECK(job);
   job->CancelRequest(req);
 }
 
 void HostResolverImpl::SetDefaultAddressFamily(AddressFamily address_family) {
   DCHECK(CalledOnValidThread());
   default_address_family_ = address_family;
-  ipv6_probe_monitoring_ = false;
+  probe_ipv6_support_ = false;
 }
 
 AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
   return default_address_family_;
 }
 
-// TODO(szym): Remove this API altogether if IPv6ActiveProbe works.
-void HostResolverImpl::ProbeIPv6Support() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!ipv6_probe_monitoring_);
-  ipv6_probe_monitoring_ = true;
-  OnIPAddressChanged();
-}
-
 void HostResolverImpl::SetDnsClientEnabled(bool enabled) {
   DCHECK(CalledOnValidThread());
 #if defined(ENABLE_BUILT_IN_DNS)
   if (enabled && !dns_client_) {
     SetDnsClient(DnsClient::CreateClient(net_log_));
   } else if (!enabled && dns_client_) {
     SetDnsClient(scoped_ptr<DnsClient>());
   }
 #endif
 }
@@ skipping 24 matching lines @@
   DCHECK(net_error);
   IPAddressNumber ip_number;
   if (!ParseIPLiteralToNumber(key.hostname, &ip_number))
     return false;
 
   DCHECK_EQ(key.host_resolver_flags &
       ~(HOST_RESOLVER_CANONNAME | HOST_RESOLVER_LOOPBACK_ONLY |
         HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6),
             0) << " Unhandled flag";
   bool ipv6_disabled = (default_address_family_ == ADDRESS_FAMILY_IPV4) &&
-      !ipv6_probe_monitoring_;
+      !probe_ipv6_support_;
   *net_error = OK;
   if ((ip_number.size() == kIPv6AddressSize) && ipv6_disabled) {
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else {
     *addresses = AddressList::CreateFromIPAddress(ip_number, info.port());
     if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
       addresses->SetDefaultCanonicalName();
   }
   return true;
 }
@@ skipping 76 matching lines @@
     cache_->Set(key, entry, base::TimeTicks::Now(), ttl);
 }
 
 void HostResolverImpl::RemoveJob(Job* job) {
   DCHECK(job);
   JobMap::iterator it = jobs_.find(job->key());
   if (it != jobs_.end() && it->second == job)
     jobs_.erase(it);
 }
 
-void HostResolverImpl::IPv6ProbeSetDefaultAddressFamily(
-    AddressFamily address_family) {
-  DCHECK(address_family == ADDRESS_FAMILY_UNSPECIFIED ||
-         address_family == ADDRESS_FAMILY_IPV4);
-  if (!ipv6_probe_monitoring_)
-    return;
-  if (default_address_family_ != address_family) {
-    VLOG(1) << "IPv6Probe forced AddressFamily setting to "
-            << ((address_family == ADDRESS_FAMILY_UNSPECIFIED) ?
-                "ADDRESS_FAMILY_UNSPECIFIED" : "ADDRESS_FAMILY_IPV4");
-  }
-  default_address_family_ = address_family;
-}
-
 void HostResolverImpl::SetHaveOnlyLoopbackAddresses(bool result) {
   if (result) {
     additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
   } else {
     additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
   }
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
     const RequestInfo& info) const {
   HostResolverFlags effective_flags =
       info.host_resolver_flags() | additional_resolver_flags_;
   AddressFamily effective_address_family = info.address_family();
 
   if (info.address_family() == ADDRESS_FAMILY_UNSPECIFIED) {
-    if (ipv6_probe_monitoring_) {
+    if (probe_ipv6_support_) {
       base::TimeTicks start_time = base::TimeTicks::Now();
       // Google DNS address.
       const uint8 kIPv6Address[] =
           { 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
       IPAddressNumber address(kIPv6Address,
                               kIPv6Address + arraysize(kIPv6Address));
       bool rv6 = IsGloballyReachable(address);
 
       UMA_HISTOGRAM_TIMES("Net.IPv6ConnectDuration",
@@ skipping 61 matching lines @@
     job->ServeFromHosts();
   }
 }
 
 void HostResolverImpl::OnIPAddressChanged() {
   resolved_known_ipv6_hostname_ = false;
   // Abandon all ProbeJobs.
   probe_weak_ptr_factory_.InvalidateWeakPtrs();
   if (cache_.get())
     cache_->clear();
-  if (ipv6_probe_monitoring_)
-    new IPv6ProbeJob(probe_weak_ptr_factory_.GetWeakPtr(), net_log_);
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   new LoopbackProbeJob(probe_weak_ptr_factory_.GetWeakPtr());
 #endif
   AbortAllInProgressJobs();
   // |this| may be deleted inside AbortAllInProgressJobs().
 }
 
 void HostResolverImpl::OnDNSChanged() {
   DnsConfig dns_config;
   NetworkChangeNotifier::GetDnsConfig(&dns_config);
@@ skipping 77 matching lines @@
   }
   DnsConfig dns_config;
   NetworkChangeNotifier::GetDnsConfig(&dns_config);
   dns_client_->SetConfig(dns_config);
   num_dns_failures_ = 0;
   if (dns_config.IsValid())
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
 }
 
 }  // namespace net