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/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/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/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context_builder.h"
 
 namespace cronet {
 
 namespace {
 
@@ skipping 18 matching lines @@
 const char kQuicUserAgentId[] = "user_agent_id";
 const char kQuicMigrateSessionsEarly[] = "migrate_sessions_early";
 const char kQuicDisableBidirectionalStreams[] =
     "quic_disable_bidirectional_streams";
 
 // AsyncDNS experiment dictionary name.
 const char kAsyncDnsFieldTrialName[] = "AsyncDNS";
 // Name of boolean to enable AsyncDNS experiment.
 const char kAsyncDnsEnable[] = "enable";
 
+const char kHostResolverRulesFieldTrialName[] = "HostResolverRules";

[pauljensen, 2016/04/07 16:29:15]

can we add a comment above here documenting what this does? preferably with a
link to another comment explaining how to write such rules?

[mgersh, 2016/06/08 18:31:14]

Done.

+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;
 
@@ skipping 110 matching lines @@
     }
 
     bool quic_disable_bidirectional_streams = false;
     if (quic_args->GetBoolean(kQuicDisableBidirectionalStreams,
                               &quic_disable_bidirectional_streams)) {
       context_builder->set_quic_disable_bidirectional_streams(
           quic_disable_bidirectional_streams);
     }
   }
 
+  scoped_ptr<net::HostResolver> host_resolver;
+
   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 {
-        scoped_ptr<net::HostResolver> host_resolver(
-            net::HostResolver::CreateDefaultResolver(net_log));
+        host_resolver = net::HostResolver::CreateDefaultResolver(net_log);
         host_resolver->SetDnsClientEnabled(true);
-        context_builder->set_host_resolver(std::move(host_resolver));
       }
     }
   }
 
+  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)) {
+      if (net_log == nullptr) {
+        DCHECK(false) << "HostResolver experiment requires NetLog.";
+      } else {
+        if (!host_resolver) {  // Host resolver rules enabled, no AsyncDNS
+          host_resolver = net::HostResolver::CreateDefaultResolver(net_log);
+        }

[pauljensen, 2016/04/07 16:29:15]

I think we need to simplify some things in this function by by adding the
precondition that net_log is non-null:
1. make net_log non-null, we can do this by making the three call sites other
than CronetUrlRequestContext just call "new NetLog()".
2. initialize |host_resolver| to CreateDefaultResolver(net_log)
3. remove lines 197-199,202,212-214,222,226,228,221
4. changing line 218 to "host_resolver.reset("

[mgersh, 2016/06/08 18:31:14]

Done.

+        scoped_ptr<net::MappedHostResolver> remapped_resolver(
+            new net::MappedHostResolver(std::move(host_resolver)));
+        remapped_resolver->SetRulesFromString(host_resolver_rules);
+        context_builder->set_host_resolver(std::move(remapped_resolver));
+      }
+    }
+  }
+
+  if (host_resolver) {  // AsyncDNS enabled, no host resolver rules
+    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 82 matching lines @@
 
   ParseAndSetExperimentalOptions(experimental_options, context_builder, net_log,
                                  file_task_runner);
 
   if (mock_cert_verifier)
     context_builder->SetCertVerifier(std::move(mock_cert_verifier));
   // TODO(mef): Use |config| to set cookies.
 }
 
 }  // namespace cronet