Cronet: Use stale DNS cache entries experimentally.

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/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/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"
@@ skipping 26 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";
 
+// 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, or 0 for no limit.
+const char kStaleDnsMaxExpiredTimeMs[] = "max_expired_time_ms";
+// Name of integer maximum times each stale DNS result can be used, or 0 for no
+// limit.
+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(
     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 117 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);
     }
   }
 
+  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;
   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 100 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