Add Cronet experimental option for host cache persistence

components/cronet/android/cronet_url_request_context_adapter.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/android/cronet_url_request_context_adapter.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 20 matching lines @@
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/cronet/android/cert/cert_verifier_cache_serializer.h"
 #include "components/cronet/android/cert/proto/cert_verification.pb.h"
 #include "components/cronet/android/cronet_library_loader.h"
 #include "components/cronet/histogram_manager.h"
+#include "components/cronet/host_cache_persistence_manager.h"
 #include "components/cronet/url_request_context_config.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_filter.h"
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/pref_service_factory.h"
 #include "jni/CronetUrlRequestContext_jni.h"
 #include "net/base/load_flags.h"
 #include "net/base/logging_network_change_observer.h"
@@ skipping 56 matching lines @@
   // so network change event are logged just once in the NetLog.
   std::unique_ptr<net::LoggingNetworkChangeObserver> net_change_logger_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogWithNetworkChangeEvents);
 };
 
 // Use a global NetLog instance. See crbug.com/486120.
 static base::LazyInstance<NetLogWithNetworkChangeEvents>::Leaky g_net_log =
     LAZY_INSTANCE_INITIALIZER;
 
-const char kHttpServerProperties[] = "net.http_server_properties";
-const char kNetworkQualities[] = "net.network_qualities";
+// Name of the pref used for host cache persistence.
+const char kHostCachePref[] = "net.host_cache";
+// Name of the pref used for HTTP server properties persistence.
+const char kHttpServerPropertiesPref[] = "net.http_server_properties";
+// Name of the pref used for NQE persistence.
+const char kNetworkQualitiesPref[] = "net.network_qualities";
 // Current version of disk storage.
 const int32_t kStorageVersion = 1;
 // Version number used when the version of disk storage is unknown.
 const uint32_t kStorageVersionUnknown = 0;
 // Name of preference directory.
 const char kPrefsDirectoryName[] = "prefs";
 // Name of preference file.
 const char kPrefsFileName[] = "local_prefs.json";
 
 // Connects the HttpServerPropertiesManager's storage to the prefs.
 class PrefServiceAdapter
     : public net::HttpServerPropertiesManager::PrefDelegate {
  public:
   explicit PrefServiceAdapter(PrefService* pref_service)
-      : pref_service_(pref_service), path_(kHttpServerProperties) {
+      : pref_service_(pref_service), path_(kHttpServerPropertiesPref) {
     pref_change_registrar_.Init(pref_service_);
   }
 
   ~PrefServiceAdapter() override {}
 
   // PrefDelegate implementation.
   bool HasServerProperties() override {
     return pref_service_->HasPrefPath(path_);
   }
   const base::DictionaryValue& GetServerProperties() const override {
@@ skipping 29 matching lines @@
         weak_ptr_factory_(this) {
     DCHECK(pref_service_);
   }
 
   ~NetworkQualitiesPrefDelegateImpl() override {}
 
   // net::NetworkQualitiesPrefsManager::PrefDelegate implementation.
   void SetDictionaryValue(const base::DictionaryValue& value) override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
-    pref_service_->Set(kNetworkQualities, value);
+    pref_service_->Set(kNetworkQualitiesPref, value);
     if (lossy_prefs_writing_task_posted_)
       return;
 
     // Post the task that schedules the writing of the lossy prefs.
     lossy_prefs_writing_task_posted_ = true;
 
     // Delay after which the task that schedules the writing of the lossy prefs.
     // This is needed in case the writing of the lossy prefs is not scheduled
     // automatically. The delay was chosen so that it is large enough that it
     // does not affect the startup performance.
     static const int32_t kUpdatePrefsDelaySeconds = 10;
 
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(
             &NetworkQualitiesPrefDelegateImpl::SchedulePendingLossyWrites,
             weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kUpdatePrefsDelaySeconds));
   }
   std::unique_ptr<base::DictionaryValue> GetDictionaryValue() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     UMA_HISTOGRAM_EXACT_LINEAR("NQE.Prefs.ReadCount", 1, 2);
-    return pref_service_->GetDictionary(kNetworkQualities)->CreateDeepCopy();
+    return pref_service_->GetDictionary(kNetworkQualitiesPref)
+        ->CreateDeepCopy();
   }
 
  private:
   // Schedules the writing of the lossy prefs.
   void SchedulePendingLossyWrites() {
     DCHECK(thread_checker_.CalledOnValidThread());
     UMA_HISTOGRAM_EXACT_LINEAR("NQE.Prefs.WriteCount", 1, 2);
     pref_service_->SchedulePendingLossyWrites();
     lossy_prefs_writing_task_posted_ = false;
   }
@@ skipping 419 matching lines @@
     // Make sure storage directory has correct version.
     InitializeStorageDirectory(storage_path);
     base::FilePath filepath =
         storage_path.Append(FILE_PATH_LITERAL(kPrefsDirectoryName))
             .Append(FILE_PATH_LITERAL(kPrefsFileName));
     json_pref_store_ =
         new JsonPrefStore(filepath, GetFileThread()->task_runner(),
                           std::unique_ptr<PrefFilter>());
     context_builder.SetFileTaskRunner(GetFileThread()->task_runner());
 
-    // Set up HttpServerPropertiesManager.
+    // Register prefs and set up the PrefService.
     PrefServiceFactory factory;
     factory.set_user_prefs(json_pref_store_);
     scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple());
-    registry->RegisterDictionaryPref(kHttpServerProperties,
+    registry->RegisterDictionaryPref(kHttpServerPropertiesPref,
                                      base::MakeUnique<base::DictionaryValue>());
     if (config->enable_network_quality_estimator) {
       // Use lossy prefs to limit the overhead of reading/writing the prefs.
-      registry->RegisterDictionaryPref(kNetworkQualities,
+      registry->RegisterDictionaryPref(kNetworkQualitiesPref,
                                        PrefRegistry::LOSSY_PREF);
     }
+    if (config->enable_host_cache_persistence) {
+      registry->RegisterListPref(kHostCachePref);
+    }
     pref_service_ = factory.Create(registry.get());
 
+    // Set up the HttpServerPropertiesManager.
     std::unique_ptr<net::HttpServerPropertiesManager>
         http_server_properties_manager(new net::HttpServerPropertiesManager(
             new PrefServiceAdapter(pref_service_.get()),
             base::ThreadTaskRunnerHandle::Get(), GetNetworkTaskRunner(),
             g_net_log.Get().net_log()));
     http_server_properties_manager->InitializeOnNetworkSequence();
     http_server_properties_manager_ = http_server_properties_manager.get();
     context_builder.SetHttpServerProperties(
         std::move(http_server_properties_manager));
   }
@@ skipping 33 matching lines @@
                   pref_service_.get()));
       network_qualities_prefs_manager_->InitializeOnNetworkThread(
           network_quality_estimator_.get());
     }
     context_builder.set_network_quality_estimator(
         network_quality_estimator_.get());
   }
 
   context_ = context_builder.Build();
 
+  // Set up host cache persistence if it's enabled. Happens after building the
+  // URLRequestContext to get access to the HostCache.
+  if (pref_service_ && config->enable_host_cache_persistence) {
+    net::HostCache* host_cache = context_->host_resolver()->GetHostCache();
+    host_cache_persistence_manager_ =
+        base::MakeUnique<HostCachePersistenceManager>(
+            host_cache, pref_service_.get(), kHostCachePref,
+            base::TimeDelta::FromMilliseconds(
+                config->host_cache_persistence_delay_ms));
+  }
+
   context_->set_check_cleartext_permitted(true);
   context_->set_enable_brotli(config->enable_brotli);
 
   if (config->load_disable_cache)
     default_load_flags_ |= net::LOAD_DISABLE_CACHE;
 
   if (config->enable_sdch) {
     DCHECK(context_->sdch_manager());
     sdch_owner_.reset(
         new net::SdchOwner(context_->sdch_manager(), context_.get()));
@@ skipping 449 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller) {
   DCHECK(base::StatisticsRecorder::IsActive());
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return ScopedJavaLocalRef<jbyteArray>();
   return base::android::ToJavaByteArray(env, &data[0], data.size());
 }
 
 }  // namespace cronet