Cronet: Use stale DNS cache entries experimentally.

components/cronet/url_request_context_config.cc

Index: components/cronet/url_request_context_config.cc
diff --git a/components/cronet/url_request_context_config.cc b/components/cronet/url_request_context_config.cc
index 570173b1504c03507f148c1f5881e6b660566222..cf59e2e17bc08aaabe65c461f6e81098b1f871c9 100644
--- a/components/cronet/url_request_context_config.cc
+++ b/components/cronet/url_request_context_config.cc
@@ -13,6 +13,7 @@
 #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/cert/cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_server_properties.h"
@@ -55,6 +56,22 @@ const char kAsyncDnsFieldTrialName[] = "AsyncDNS";
 // Name of boolean to enable AsyncDNS experiment.
 const char kAsyncDnsEnable[] = "enable";
 
+// Stale DNS (StaleHostResolver) experiment dictionary name.
+const char kStaleDnsFieldTrialName[] = "StaleDNS";
+// Name of boolean to enable stale DNS experiment.
+const char kStaleDnsEnable[] = "enable";
+// Name of integer delay in milliseconds before a stale DNS result will be
+// used.
+const char kStaleDnsDelayMs[] = "delay_ms";
+// Name of integer maximum age (past expiration) in milliseconds of a stale DNS
+// result that will be used.
+const char kStaleDnsMaxExpiredTimeMs[] = "max_expired_time_ms";
+// Name of integer maximum times each stale DNS result can be used.
+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";
+
 const char kSSLKeyLogFile[] = "ssl_key_log_file";
 
 void ParseAndSetExperimentalOptions(
@@ -185,20 +202,52 @@ void ParseAndSetExperimentalOptions(
     }
   }
 
+  bool async_dns_enable = false;
+  bool stale_dns_enable = false;
+  StaleHostResolver::StaleOptions stale_dns_options;
+
   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));
+  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) &&
+        stale_dns_enable) {
+      int delay;
+      if (stale_dns_args->GetInteger(kStaleDnsDelayMs, &delay))
+        stale_dns_options.delay = base::TimeDelta::FromMilliseconds(delay);
+      int max_expired_time_ms;
+      if (stale_dns_args->GetInteger(kStaleDnsMaxExpiredTimeMs,
+                                     &max_expired_time_ms)) {
+        stale_dns_options.max_expired_time =
+            base::TimeDelta::FromMilliseconds(max_expired_time_ms);
       }
+      int max_stale_uses;
+      if (stale_dns_args->GetInteger(kStaleDnsMaxStaleUses, &max_stale_uses))
+        stale_dns_options.max_stale_uses = max_stale_uses;
+      bool allow_other_network;
+      if (stale_dns_args->GetBoolean(kStaleDnsAllowOtherNetwork,
+                                     &allow_other_network)) {
+        stale_dns_options.allow_other_network = allow_other_network;
+      }
+    }
+  }
+
+  if (async_dns_enable || stale_dns_enable) {
+    if (net_log == nullptr)
+      CHECK(false) << "AsyncDNS and StaleDNS 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));
+    } else {
+      host_resolver = net::HostResolver::CreateDefaultResolver(net_log);
     }
+    if (async_dns_enable)
+      host_resolver->SetDnsClientEnabled(true);
+    context_builder->set_host_resolver(std::move(host_resolver));
   }
 
   std::string ssl_key_log_file_string;