Add back "default address family" to HostResolver

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 1993 matching lines @@
 
 HostResolverImpl::HostResolverImpl(
     const Options& options,
     NetLog* net_log,
     scoped_refptr<base::TaskRunner> worker_task_runner)
     : max_queued_jobs_(0),
       proc_params_(NULL, options.max_retry_attempts),
       net_log_(net_log),
       received_dns_config_(false),
       num_dns_failures_(0),
+      default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       use_local_ipv6_(false),
       last_ipv6_probe_result_(true),
       resolved_known_ipv6_hostname_(false),
       additional_resolver_flags_(0),
       fallback_to_proctask_(true),
       worker_task_runner_(std::move(worker_task_runner)),
       persist_initialized_(false),
       weak_ptr_factory_(this),
       probe_weak_ptr_factory_(this) {
   if (options.enable_caching)
@@ skipping 153 matching lines @@
     ip_address_ptr = &ip_address;
 
   Key key = GetEffectiveKeyForRequest(info, ip_address_ptr, source_net_log);
 
   int rv = ResolveHelper(key, info, ip_address_ptr, addresses, true, stale_info,
                          source_net_log);
   LogFinishRequest(source_net_log, info, rv);
   return rv;
 }
 
+void HostResolverImpl::SetDefaultAddressFamily(AddressFamily address_family) {
+  DCHECK(CalledOnValidThread());
+  default_address_family_ = address_family;
+}
+
+AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
+  return default_address_family_;
+}
+
 bool HostResolverImpl::ResolveAsIP(const Key& key,
                                    const RequestInfo& info,
                                    const IPAddress* ip_address,
                                    int* net_error,
                                    AddressList* addresses) {
   DCHECK(addresses);
   DCHECK(net_error);
   if (ip_address == nullptr)
     return false;
 
   *net_error = OK;
   AddressFamily family = GetAddressFamily(*ip_address);
+  if (family == ADDRESS_FAMILY_IPV6 &&
+      default_address_family_ == ADDRESS_FAMILY_IPV4) {
+    // Don't return IPv6 addresses if default address family is set to IPv4.
+    *net_error = ERR_NAME_NOT_RESOLVED;
+  }
   if (key.address_family != ADDRESS_FAMILY_UNSPECIFIED &&
       key.address_family != family) {
     // Don't return IPv6 addresses for IPv4 queries, and vice versa.
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else {
     *addresses = AddressList::CreateFromIPAddress(*ip_address, info.port());
     if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
       addresses->SetDefaultCanonicalName();
   }
   return true;
@@ skipping 122 matching lines @@
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
     const RequestInfo& info,
     const IPAddress* ip_address,
     const NetLogWithSource& net_log) {
   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 (!use_local_ipv6_ &&
-        // When resolving IPv4 literals, there's no need to probe for IPv6.
-        // When resolving IPv6 literals, there's no benefit to artificially
-        // limiting our resolution based on a probe.  Prior logic ensures
-        // that this query is UNSPECIFIED (see info.address_family()
-        // check above) so the code requesting the resolution should be amenable
-        // to receiving a IPv6 resolution.
-        ip_address == nullptr) {
-      if (!IsIPv6Reachable(net_log)) {
-        effective_address_family = ADDRESS_FAMILY_IPV4;
-        effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
-      }
-    }
+  if (info.address_family() == ADDRESS_FAMILY_UNSPECIFIED)
+    effective_address_family = default_address_family_;
+
+  if (effective_address_family == ADDRESS_FAMILY_UNSPECIFIED &&
+      // When resolving IPv4 literals, there's no need to probe for IPv6.
+      // When resolving IPv6 literals, there's no benefit to artificially
+      // limiting our resolution based on a probe.  Prior logic ensures
+      // that this query is UNSPECIFIED (see effective_address_family
+      // check above) so the code requesting the resolution should be amenable
+      // to receiving a IPv6 resolution.
+      !use_local_ipv6_ && ip_address == nullptr && !IsIPv6Reachable(net_log)) {
+    effective_address_family = ADDRESS_FAMILY_IPV4;
+    effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   }
 
   return Key(info.hostname(), effective_address_family, effective_flags);
 }
 
 bool HostResolverImpl::IsIPv6Reachable(const NetLogWithSource& net_log) {
   // Cache the result for kIPv6ProbePeriodMs (measured from after
   // IsGloballyReachable() completes).
   bool cached = true;
   if ((base::TimeTicks::Now() - last_ipv6_probe_time_).InMilliseconds() >
@@ skipping 269 matching lines @@
   if (job_)
     job_->CancelRequest(this);
 }
 
 void HostResolverImpl::RequestImpl::ChangeRequestPriority(
     RequestPriority priority) {
   job_->ChangeRequestPriority(this, priority);
 }
 
 }  // namespace net