Make SDCH dictionaries persistent across browser restart.

chrome/browser/profiles/profile_impl_io_data.cc

 // Copyright (c) 2012 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 "chrome/browser/profiles/profile_impl_io_data.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
+#include "base/prefs/json_pref_store.h"
+#include "base/prefs/pref_filter.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 37 matching lines @@
 #include "net/http/http_cache.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace {
 
+// Seconds to delay writing persisted preferences to disk.
+const int kPrefsCommitDelay = 10;
+
 net::BackendType ChooseCacheBackendType() {
 #if defined(OS_ANDROID)
   return net::CACHE_BACKEND_SIMPLE;
 #else
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUseSimpleCacheBackend)) {
     const std::string opt_value =
         command_line.GetSwitchValueASCII(switches::kUseSimpleCacheBackend);
     if (LowerCaseEqualsASCII(opt_value, "off"))
@@ skipping 316 matching lines @@
 ProfileImplIOData::LazyParams::LazyParams()
     : cache_max_size(0),
       media_cache_max_size(0),
       session_cookie_mode(
           content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES) {}
 
 ProfileImplIOData::LazyParams::~LazyParams() {}
 
 ProfileImplIOData::ProfileImplIOData()
     : ProfileIOData(Profile::REGULAR_PROFILE),
+      network_store_commit_timer_(false, false),
       http_server_properties_manager_(NULL),
       app_cache_max_size_(0),
-      app_media_cache_max_size_(0) {
+      app_media_cache_max_size_(0),
+      factory_(this) {
 }
 
 ProfileImplIOData::~ProfileImplIOData() {
   DestroyResourceContext();
 
   if (media_request_context_)
     media_request_context_->AssertNoURLRequests();
 }
 
 void ProfileImplIOData::InitializeInternal(
     scoped_ptr<ChromeNetworkDelegate> chrome_network_delegate,
     ProfileParams* profile_params,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) const {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/436671 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "436671 ProfileImplIOData::InitializeInternal"));
 
+  // Set up a persistent store for use by the network stack on the IO thread.
+  base::FilePath network_json_store_filepath(
+      profile_path_.Append(chrome::kNetworkPersistentStateFilename));
+  network_json_store_ = new JsonPrefStore(
+      network_json_store_filepath,
+      JsonPrefStore::GetTaskRunnerForFile(network_json_store_filepath,
+                                          BrowserThread::GetBlockingPool()),
+      scoped_ptr<PrefFilter>());
+  network_json_store_->ReadPrefsAsync(nullptr);
+
   net::URLRequestContext* main_context = main_request_context();
 
   IOThread* const io_thread = profile_params->io_thread;
   IOThread::Globals* const io_thread_globals = io_thread->globals();
 
   chrome_network_delegate->set_predictor(predictor_.get());
 
   if (domain_reliability_monitor_) {
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/436671 is fixed.
     tracked_objects::ScopedTracker tracking_profile1(
@@ skipping 167 matching lines @@
           "436671 ProfileImplIOData::InitializeInternal9"));
 
 #if defined(ENABLE_EXTENSIONS)
   InitializeExtensionsRequestContext(profile_params);
 #endif
 
   // Setup SDCH for this profile.
   sdch_manager_.reset(new net::SdchManager);
   sdch_policy_.reset(new net::SdchOwner(sdch_manager_.get(), main_context));
   main_context->set_sdch_manager(sdch_manager_.get());
+  sdch_policy_->EnablePersistentStorage(network_json_store_.get());
 
   // Create a media request context based on the main context, but using a
   // media cache.  It shares the same job factory as the main context.
   StoragePartitionDescriptor details(profile_path_, false);
   media_request_context_.reset(InitializeMediaRequestContext(main_context,
                                                              details));
 
   lazy_params_.reset();
 }
 
@@ skipping 222 matching lines @@
     const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }
+
+void ProfileImplIOData::FlushPrefsToDisk() {
+  network_json_store_->CommitPendingWrite();
+}
+
+void ProfileImplIOData::OnPrefValueChanged(const std::string& key) {
+  // Schedule a write to disk for the preferences.  This will
+  // reset (i.e. push out) any previously scheduled but untriggered
+  // timer.  In other words, if there's a lot of preference activity,
+  // disk commit will be delayed until kPrefsCommitDelay seconds
+  // after it stops.
+  network_store_commit_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kPrefsCommitDelay),
+      base::Bind(&ProfileImplIOData::FlushPrefsToDisk, factory_.GetWeakPtr()));

[Bernhard Bauer, 2015/02/02 14:39:46]

JsonPrefStore has an internal timer that will commit pending writes (also every
ten seconds). The explicit method is only for cases where you want to commit
*now* (like right before shutdown).

In any case, using a weak pointer here is probably not necessary, as the timer
is a member, so it will cancel itself when this object is destroyed. 

[Randy Smith (Not in Mondays), 2015/02/04 19:29:03]

That makes my life simpler!  Much excess stuff removed.

+}
+
+void ProfileImplIOData::OnInitializationCompleted(bool succeeded) {}