Separate prefs from HttpServerPropertiesManager.

net/http/http_server_properties_manager.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 "net/http/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/ip_address_number.h"
 #include "net/base/port_util.h"
 
 namespace net {
@@ skipping 45 matching lines @@
 const char kProbabilityKey[] = "probability";
 const char kExpirationKey[] = "expiration";
 const char kNetworkStatsKey[] = "network_stats";
 const char kSrttKey[] = "srtt";
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
+HttpServerPropertiesManager::PrefDelegate::~PrefDelegate() {}
+
 HttpServerPropertiesManager::HttpServerPropertiesManager(
-    PrefService* pref_service,
-    const char* pref_path,
+    PrefDelegate* pref_delegate,
     scoped_refptr<base::SequencedTaskRunner> network_task_runner)
     : pref_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      pref_service_(pref_service),
+      pref_delegate_(pref_delegate),
       setting_prefs_(false),
-      path_(pref_path),
       network_task_runner_(network_task_runner) {
-  DCHECK(pref_service);
+  DCHECK(pref_delegate_);
   pref_weak_ptr_factory_.reset(
       new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
   pref_weak_ptr_ = pref_weak_ptr_factory_->GetWeakPtr();
   pref_cache_update_timer_.reset(new base::OneShotTimer);
-  pref_change_registrar_.Init(pref_service_);
-  pref_change_registrar_.Add(
-      path_,
+  pref_delegate_->StartListeningForUpdates(
       base::Bind(&HttpServerPropertiesManager::OnHttpServerPropertiesChanged,
                  base::Unretained(this)));
 }
 
 HttpServerPropertiesManager::~HttpServerPropertiesManager() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   network_weak_ptr_factory_.reset();
 }
 
 void HttpServerPropertiesManager::InitializeOnNetworkThread() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   network_weak_ptr_factory_.reset(
       new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
   http_server_properties_impl_.reset(new HttpServerPropertiesImpl());
 
   network_prefs_update_timer_.reset(new base::OneShotTimer);
 
   pref_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread,
                  pref_weak_ptr_));
 }
 
 void HttpServerPropertiesManager::ShutdownOnPrefThread() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   // Cancel any pending updates, and stop listening for pref change updates.
   pref_cache_update_timer_->Stop();
   pref_weak_ptr_factory_.reset();
-  pref_change_registrar_.RemoveAll();
+  pref_delegate_->StopListeningForUpdates();
 }
 
 // static
 void HttpServerPropertiesManager::SetVersion(
     base::DictionaryValue* http_server_properties_dict,
     int version_number) {
   if (version_number < 0)
     version_number = kVersionNumber;
   DCHECK_LE(version_number, kVersionNumber);
   if (version_number <= kVersionNumber)
@@ skipping 307 matching lines @@
       FROM_HERE,
       delay,
       this,
       &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread);
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread() {
   // The preferences can only be read on the pref thread.
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!pref_service_->HasPrefPath(path_))
+  if (!pref_delegate_->HasServerProperties())
     return;
 
   bool detected_corrupted_prefs = false;
   const base::DictionaryValue& http_server_properties_dict =
-      *pref_service_->GetDictionary(path_);
+      pref_delegate_->GetServerProperties();
 
   int version = kMissingVersion;
   if (!http_server_properties_dict.GetIntegerWithoutPathExpansion(kVersionKey,
                                                                   &version)) {
     DVLOG(1) << "Missing version. Clearing all properties.";
     return;
   }
 
   const base::DictionaryValue* servers_dict = nullptr;
   const base::ListValue* servers_list = nullptr;
@@ skipping 646 matching lines @@
     ServerPrefMap::iterator it = server_pref_map.Get(server);
     if (it == server_pref_map.end()) {
       ServerPref server_pref;
       server_pref.server_network_stats = &map_it->second;
       server_pref_map.Put(server, server_pref);
     } else {
       it->second.server_network_stats = &map_it->second;
     }
   }
 
-  // Persist properties to the |path_| in the MRU order.
+  // Persist properties to the prefs in the MRU order.
   base::DictionaryValue http_server_properties_dict;
   base::ListValue* servers_list = new base::ListValue;
   for (ServerPrefMap::const_reverse_iterator map_it = server_pref_map.rbegin();
        map_it != server_pref_map.rend(); ++map_it) {
     const HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     base::DictionaryValue* servers_dict = new base::DictionaryValue;
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
@@ skipping 14 matching lines @@
   http_server_properties_dict.SetWithoutPathExpansion(kServersKey,
                                                       servers_list);
   SetVersion(&http_server_properties_dict, kVersionNumber);
 
   SaveSupportsQuicToPrefs(last_quic_address, &http_server_properties_dict);
 
   SaveQuicServerInfoMapToServerPrefs(quic_server_info_map,
                                      &http_server_properties_dict);
 
   setting_prefs_ = true;
-  pref_service_->Set(path_, http_server_properties_dict);
+  pref_delegate_->SetServerProperties(http_server_properties_dict);
   setting_prefs_ = false;
 
   // Note that |completion| will be fired after we have written everything to
   // the Preferences, but likely before these changes are serialized to disk.
   // This is not a problem though, as JSONPrefStore guarantees that this will
   // happen, pretty soon, and even in the case we shut down immediately.
   if (!completion.is_null())
     completion.Run();
 }
 
@@ skipping 99 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net