Change Cronet's "disable_ipv6" to "disable_ipv6_on_wifi"

components/cronet/url_request_context_config.cc

 // Copyright 2014 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 "components/cronet/url_request_context_config.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
@@ skipping 64 matching lines @@
 const char kStaleDnsMaxStaleUses[] = "max_stale_uses";
 // Name of boolean to allow stale DNS results from other networks to be used on
 // the current network.
 const char kStaleDnsAllowOtherNetwork[] = "allow_other_network";
 
 // Rules to override DNS resolution. Intended for testing.
 // See explanation of format in net/dns/mapped_host_resolver.h.
 const char kHostResolverRulesFieldTrialName[] = "HostResolverRules";
 const char kHostResolverRules[] = "host_resolver_rules";
 
-// Disable IPv6. This should almost never be necessary because the network stack
-// has IPv6 detection logic. Please do not turn on this option without first
-// reporting a bug. See http://crbug.com/696569 for the currently known issue.
-const char kDisableIPv6[] = "disable_ipv6";
+// Disable IPv6 when on WiFi. This is a workaround for a known issue on certain
+// Android phones, and should not be necessary when not on one of those devices.
+// See https://crbug.com/696569 for details.
+const char kDisableIPv6OnWifi[] = "disable_ipv6_on_wifi";
 
 const char kSSLKeyLogFile[] = "ssl_key_log_file";
 
 // Returns the effective experimental options.
 std::unique_ptr<base::DictionaryValue> ParseAndSetExperimentalOptions(
     const std::string& experimental_options,
     net::URLRequestContextBuilder* context_builder,
     net::NetLog* net_log,
     const scoped_refptr<base::SequencedTaskRunner>& file_task_runner) {
   if (experimental_options.empty())
@@ skipping 16 matching lines @@
 
   if (!dict) {
     DCHECK(false) << "Experimental options string is not a dictionary: "
                   << experimental_options;
     return nullptr;
   }
 
   bool async_dns_enable = false;
   bool stale_dns_enable = false;
   bool host_resolver_rules_enable = false;
-  bool disable_ipv6 = false;
+  bool disable_ipv6_on_wifi = false;
 
   std::unique_ptr<base::DictionaryValue> effective_experimental_options =
       dict->CreateDeepCopy();
   StaleHostResolver::StaleOptions stale_dns_options;
   std::string host_resolver_rules_string;
   for (base::DictionaryValue::Iterator it(*dict.get()); !it.IsAtEnd();
        it.Advance()) {
     if (it.key() == kQuicFieldTrialName) {
       const base::DictionaryValue* quic_args = nullptr;
       if (!it.value().GetAsDictionary(&quic_args)) {
@@ skipping 134 matching lines @@
     } else if (it.key() == kHostResolverRulesFieldTrialName) {
       const base::DictionaryValue* host_resolver_rules_args = nullptr;
       if (!it.value().GetAsDictionary(&host_resolver_rules_args)) {
         LOG(ERROR) << "\"" << it.key() << "\" config params \"" << it.value()
                    << "\" is not a dictionary value";
         effective_experimental_options->Remove(it.key(), nullptr);
         continue;
       }
       host_resolver_rules_enable = host_resolver_rules_args->GetString(
           kHostResolverRules, &host_resolver_rules_string);
-    } else if (it.key() == kDisableIPv6) {
-      if (!it.value().GetAsBoolean(&disable_ipv6)) {
+    } else if (it.key() == kDisableIPv6OnWifi) {
+      if (!it.value().GetAsBoolean(&disable_ipv6_on_wifi)) {
         LOG(ERROR) << "\"" << it.key() << "\" config params \"" << it.value()
                    << "\" is not a bool";
         effective_experimental_options->Remove(it.key(), nullptr);
         continue;
       }
     } else if (it.key() == kSSLKeyLogFile) {
       std::string ssl_key_log_file_string;
       if (it.value().GetAsString(&ssl_key_log_file_string)) {
         DCHECK(file_task_runner);
         base::FilePath ssl_key_log_file(ssl_key_log_file_string);
         if (!ssl_key_log_file.empty() && file_task_runner) {
           // SetSSLKeyLogFile is only safe to call before any SSLClientSockets
           // are created. This should not be used if there are multiple
           // CronetEngine.
           // TODO(xunjieli): Expose this as a stable API after crbug.com/458365
           // is resolved.
           net::SSLClientSocket::SetSSLKeyLogFile(ssl_key_log_file,
                                                  file_task_runner);
         }
       }
     } else {
       LOG(WARNING) << "Unrecognized Cronet experimental option \"" << it.key()
                    << "\" with params \"" << it.value();
       effective_experimental_options->Remove(it.key(), nullptr);
     }
   }
 
   if (async_dns_enable || stale_dns_enable || host_resolver_rules_enable ||
-      disable_ipv6) {
+      disable_ipv6_on_wifi) {
     CHECK(net_log) << "All DNS-related experiments require NetLog.";
     std::unique_ptr<net::HostResolver> host_resolver;
     if (stale_dns_enable) {
-      DCHECK(!disable_ipv6);
+      DCHECK(!disable_ipv6_on_wifi);
       host_resolver.reset(new StaleHostResolver(
           net::HostResolver::CreateDefaultResolverImpl(net_log),
           stale_dns_options));
     } else {
       host_resolver = net::HostResolver::CreateDefaultResolver(net_log);
     }
-    if (disable_ipv6)
-      host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
+    if (disable_ipv6_on_wifi)
+      host_resolver->SetNoIPv6OnWifi(true);
     if (async_dns_enable)
       host_resolver->SetDnsClientEnabled(true);
     if (host_resolver_rules_enable) {
       std::unique_ptr<net::MappedHostResolver> remapped_resolver(
           new net::MappedHostResolver(std::move(host_resolver)));
       remapped_resolver->SetRulesFromString(host_resolver_rules_string);
       host_resolver = std::move(remapped_resolver);
     }
     context_builder->set_host_resolver(std::move(host_resolver));
   }
@@ skipping 115 matching lines @@
       enable_quic, quic_user_agent_id, enable_spdy, enable_sdch, http_cache,
       http_cache_max_size, load_disable_cache, storage_path, user_agent,
       experimental_options, data_reduction_proxy_key,
       data_reduction_primary_proxy, data_reduction_fallback_proxy,
       data_reduction_secure_proxy_check_url, std::move(mock_cert_verifier),
       enable_network_quality_estimator,
       bypass_public_key_pinning_for_local_trust_anchors, cert_verifier_data);
 }
 
 }  // namespace cronet