Add Cronet experimental option for host cache persistence

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"
@@ skipping 55 matching lines @@
 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";
+// Name of boolean to enable persisting the DNS cache to disk.
+const char kStaleDnsPersist[] = "persist_to_disk";
+// Name of integer minimum time in milliseconds between writes to disk for DNS
+// cache persistence. Default value is one minute. Only relevant if
+// "persist_to_disk" is true.
+const char kStaleDnsPersistTimer[] = "persist_delay_ms";
 
 // 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 when on WiFi. This is a workaround for a known issue on certain
 // Android phones, and should not be necessary when not on one of those devices.
 // See https://crbug.com/696569 for details.
 const char kDisableIPv6OnWifi[] = "disable_ipv6_on_wifi";
@@ skipping 199 matching lines @@
               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;
         }
+        bool persist;
+        if (stale_dns_args->GetBoolean(kStaleDnsPersist, &persist))
+          enable_host_cache_persistence = persist;
+        int persist_timer;
+        if (stale_dns_args->GetInteger(kStaleDnsPersistTimer, &persist_timer))
+          host_cache_persistence_delay_ms = persist_timer;
       }
     } else if (it.key() == kHostResolverRulesFieldTrialName) {
       const base::DictionaryValue* host_resolver_rules_args = nullptr;
       if (!it.value().GetAsDictionary(&host_resolver_rules_args)) {
         LOG(ERROR) << "\"" << it.key() << "\" config params \"" << it.value()
                    << "\" is not a dictionary value";
         effective_experimental_options->Remove(it.key(), nullptr);
         continue;
       }
       host_resolver_rules_enable = host_resolver_rules_args->GetString(
@@ skipping 105 matching lines @@
 URLRequestContextConfigBuilder::Build() {
   return base::MakeUnique<URLRequestContextConfig>(
       enable_quic, quic_user_agent_id, enable_spdy, enable_sdch, enable_brotli,
       http_cache, http_cache_max_size, load_disable_cache, storage_path,
       user_agent, experimental_options, std::move(mock_cert_verifier),
       enable_network_quality_estimator,
       bypass_public_key_pinning_for_local_trust_anchors, cert_verifier_data);
 }
 
 }  // namespace cronet