Add host resolver rules experimental flag for Cronet

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 "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/core/quic_protocol.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context_builder.h"
 
 namespace cronet {
 
 namespace {
 
@@ skipping 21 matching lines @@
 const char kQuicMigrateSessionsEarly[] = "migrate_sessions_early";
 const char kQuicDisableBidirectionalStreams[] =
     "quic_disable_bidirectional_streams";
 const char kQuicRaceCertVerification[] = "race_cert_verification";
 
 // AsyncDNS experiment dictionary name.
 const char kAsyncDnsFieldTrialName[] = "AsyncDNS";
 // Name of boolean to enable AsyncDNS experiment.
 const char kAsyncDnsEnable[] = "enable";
 
+// 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";
+
 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;
 
+  DCHECK(net_log);
+
   DVLOG(1) << "Experimental Options:" << experimental_options;
   std::unique_ptr<base::Value> options =
       base::JSONReader::Read(experimental_options);
 
   if (!options) {
     DCHECK(false) << "Parsing experimental options failed: "
                   << experimental_options;
     return;
   }
 
@@ skipping 107 matching lines @@
     }
 
     bool quic_race_cert_verification = false;
     if (quic_args->GetBoolean(kQuicRaceCertVerification,
                               &quic_race_cert_verification)) {
       context_builder->set_quic_race_cert_verification(
           quic_race_cert_verification);
     }
   }
 
+  std::unique_ptr<net::HostResolver> host_resolver =
+      net::HostResolver::CreateDefaultResolver(net_log);
+
   const base::DictionaryValue* async_dns_args = nullptr;
   if (dict->GetDictionary(kAsyncDnsFieldTrialName, &async_dns_args)) {
     bool async_dns_enable = false;
     if (async_dns_args->GetBoolean(kAsyncDnsEnable, &async_dns_enable) &&
         async_dns_enable) {
-      if (net_log == nullptr) {
-        DCHECK(false) << "AsyncDNS experiment requires NetLog.";
-      } else {
-        std::unique_ptr<net::HostResolver> host_resolver(
-            net::HostResolver::CreateDefaultResolver(net_log));
-        host_resolver->SetDnsClientEnabled(true);
-        context_builder->set_host_resolver(std::move(host_resolver));
-      }
+      host_resolver->SetDnsClientEnabled(true);
     }
   }
 
+  const base::DictionaryValue* host_resolver_args = nullptr;
+  if (dict->GetDictionary(kHostResolverRulesFieldTrialName,
+                          &host_resolver_args)) {
+    std::string host_resolver_rules;
+    if (host_resolver_args->GetString(kHostResolverRules,
+                                      &host_resolver_rules)) {
+      std::unique_ptr<net::MappedHostResolver> remapped_resolver(
+          new net::MappedHostResolver(std::move(host_resolver)));
+      remapped_resolver->SetRulesFromString(host_resolver_rules);
+      host_resolver = std::move(remapped_resolver);
+    }
+  }
+
+  context_builder->set_host_resolver(std::move(host_resolver));
+
   std::string ssl_key_log_file_string;
   if (dict->GetString(kSSLKeyLogFile, &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,
@@ skipping 59 matching lines @@
       bypass_public_key_pinning_for_local_trust_anchors(
           bypass_public_key_pinning_for_local_trust_anchors),
       cert_verifier_data(cert_verifier_data) {}
 
 URLRequestContextConfig::~URLRequestContextConfig() {}
 
 void URLRequestContextConfig::ConfigureURLRequestContextBuilder(
     net::URLRequestContextBuilder* context_builder,
     net::NetLog* net_log,
     const scoped_refptr<base::SequencedTaskRunner>& file_task_runner) {
+  DCHECK(net_log);
+
   std::string config_cache;
   if (http_cache != DISABLED) {
     net::URLRequestContextBuilder::HttpCacheParams cache_params;
     if (http_cache == DISK && !storage_path.empty()) {
       cache_params.type = net::URLRequestContextBuilder::HttpCacheParams::DISK;
       cache_params.path =
           base::FilePath(storage_path)
               .Append(FILE_PATH_LITERAL(kDiskCacheDirectoryName));
     } else {
       cache_params.type =
@@ skipping 21 matching lines @@
         std::move(mock_cert_verifier));
   } else {
     // net::CertVerifier::CreateDefault() returns a CachingCertVerifier.
     cert_verifier = net::CertVerifier::CreateDefault();
   }
   context_builder->SetCertVerifier(std::move(cert_verifier));
   // TODO(mef): Use |config| to set cookies.
 }
 
 }  // namespace cronet