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 945 matching lines @@
   DCHECK(CalledOnValidThread());
   default_address_family_ = address_family;
   ipv6_probe_monitoring_ = false;
 }
 
 AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
   return default_address_family_;
 }
 
 // TODO(szym): Remove this API altogether if IPv6ActiveProbe works.
 void HostResolverImpl::ProbeIPv6Support() {

[mmenke, 2013/07/16 17:48:04]

Leaving this in for now?  Seems like we could just make ipv6_probe_monitoring_
default to true and get rid of the function

[szym, 2013/07/16 20:08:31]

--enable-ipv6  => SetDefaultAddressFamily(UNSPEC)
--disable-ipv6 => SetDefaultAddressFamily(IPV4)
otherwise      => ProbeIPv6Support

The difference between the first and last situations is that the first one
disables probing and forces IPv6 resolutions even if connect(IPv6) fails.

Defaulting ipv6_probe_monitoring_ = true, making this call obsolete. I will do
that for now.

Looking forward, I don't think anyone depends on --enable-ipv6, so we could also
remove that in which case we would always probe except then family is restricted
to IPv4.

   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_) {
@@ skipping 127 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 {
@@ skipping 77 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