Add Cronet experimental option to disable ipv6

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"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "components/cronet/stale_host_resolver.h"
+#include "net/base/address_family.h"
 #include "net/cert/caching_cert_verifier.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/multi_threaded_cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/mapped_host_resolver.h"
 #include "net/http/http_server_properties.h"
 #include "net/quic/chromium/quic_utils_chromium.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/socket/ssl_client_socket.h"
@@ skipping 46 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.

[xunjieli, 2017/02/27 15:37:39]

nit: Open a bug and link it here.

[mgersh, 2017/02/28 18:29:57]

Done.

+const char kDisableIPv6[] = "disable_ipv6";
+
 const char kSSLKeyLogFile[] = "ssl_key_log_file";
 
 void 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())
     return;
 
@@ skipping 108 matching lines @@
     if (quic_args->GetBoolean(kQuicRaceCertVerification,
                               &quic_race_cert_verification)) {
       context_builder->set_quic_race_cert_verification(
           quic_race_cert_verification);
     }
   }
 
   bool async_dns_enable = false;
   bool stale_dns_enable = false;
   bool host_resolver_rules_enable = false;
+  bool disable_ipv6 = false;
   StaleHostResolver::StaleOptions stale_dns_options;
   std::string host_resolver_rules_string;
 
   const base::DictionaryValue* async_dns_args = nullptr;
   if (dict->GetDictionary(kAsyncDnsFieldTrialName, &async_dns_args))
     async_dns_args->GetBoolean(kAsyncDnsEnable, &async_dns_enable);
 
   const base::DictionaryValue* stale_dns_args = nullptr;
   if (dict->GetDictionary(kStaleDnsFieldTrialName, &stale_dns_args)) {
     if (stale_dns_args->GetBoolean(kStaleDnsEnable, &stale_dns_enable) &&
@@ skipping 18 matching lines @@
     }
   }
 
   const base::DictionaryValue* host_resolver_rules_args = nullptr;
   if (dict->GetDictionary(kHostResolverRulesFieldTrialName,
                           &host_resolver_rules_args)) {
     host_resolver_rules_enable = host_resolver_rules_args->GetString(
         kHostResolverRules, &host_resolver_rules_string);
   }
 
-  if (async_dns_enable || stale_dns_enable || host_resolver_rules_enable) {
+  dict->GetBoolean(kDisableIPv6, &disable_ipv6);
+
+  if (async_dns_enable || stale_dns_enable || host_resolver_rules_enable ||
+      disable_ipv6) {
     if (net_log == nullptr) {
-      CHECK(false) << "AsyncDNS, StaleDNS, and HostResolverRules experiments "
-                   << "require NetLog.";
+      CHECK(false) << "All DNS-related experiments require NetLog.";
     }
     std::unique_ptr<net::HostResolver> host_resolver;
     if (stale_dns_enable) {
       host_resolver.reset(new StaleHostResolver(
           net::HostResolver::CreateDefaultResolverImpl(net_log),
           stale_dns_options));

[xunjieli, 2017/02/27 15:37:39]

nit: suggest add a DCHECK(disable_ipv6) here (see my previous comment)

[mgersh, 2017/02/28 18:29:57]

Done.

     } else {
       host_resolver = net::HostResolver::CreateDefaultResolver(net_log);
     }
+    if (disable_ipv6)
+      host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
     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 128 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