Introduce PrefRegistrySyncable, simplifying PrefServiceSyncable.

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/admin_policy.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_sorting.h"
+#include "chrome/browser/prefs/pref_registry_syncable.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/pref_names.h"
@@ skipping 336 matching lines @@
 base::Time ExtensionPrefs::TimeProvider::GetCurrentTime() const {
   return base::Time::Now();
 }
 
 //
 // ExtensionPrefs
 //
 
 // static
 scoped_ptr<ExtensionPrefs> ExtensionPrefs::Create(
-    PrefServiceSyncable* prefs,
+    PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     bool extensions_disabled) {
   return ExtensionPrefs::Create(prefs,
                                 root_dir,
                                 extension_pref_value_map,
                                 extensions_disabled,
                                 make_scoped_ptr(new TimeProvider()));
 }
 
 // static
 scoped_ptr<ExtensionPrefs> ExtensionPrefs::Create(
-    PrefServiceSyncable* pref_service,
+    PrefService* pref_service,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     bool extensions_disabled,
     scoped_ptr<TimeProvider> time_provider) {
   scoped_ptr<ExtensionPrefs> prefs(
       new ExtensionPrefs(pref_service,
                          root_dir,
                          extension_pref_value_map,
                          time_provider.Pass()));
   prefs->Init(extensions_disabled);
@@ skipping 1780 matching lines @@
   return ext;
 }
 
 void ExtensionPrefs::SetGeometryCache(
     const std::string& extension_id,
     scoped_ptr<base::DictionaryValue> cache) {
   UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release());
 }
 
 ExtensionPrefs::ExtensionPrefs(
-    PrefServiceSyncable* prefs,
+    PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     scoped_ptr<TimeProvider> time_provider)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       ALLOW_THIS_IN_INITIALIZER_LIST(extension_sorting_(
           new ExtensionSorting(this, prefs))),
       content_settings_store_(new ContentSettingsStore()),
       time_provider_(time_provider.Pass()) {
 }
 
 void ExtensionPrefs::Init(bool extensions_disabled) {
   MakePathsRelative();
 
   InitPrefStore(extensions_disabled);
 
   content_settings_store_->AddObserver(this);
 }
 
 void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) {
   prefs_->SetBoolean(prefs::kExtensionStorageGarbageCollect, value);
 }
 
 bool ExtensionPrefs::NeedsStorageGarbageCollection() {
   return prefs_->GetBoolean(prefs::kExtensionStorageGarbageCollect);
 }
 
 // static
-void ExtensionPrefs::RegisterUserPrefs(PrefServiceSyncable* prefs) {
-  prefs->RegisterDictionaryPref(kExtensionsPref,
-                                PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(kExtensionToolbar,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(kExtensionActionBox,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(kExtensionActionBoxBar,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize,
-                             -1,  // default value
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate,
-                                PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterDictionaryPref(prefs::kExtensionInstallForceList,
-                                PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(prefs::kExtensionAllowedTypes,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(kWebStoreLogin,
-                            std::string(),  // default value
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion,
-                            "0",  // default value
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kExtensionStorageGarbageCollect,
-                             false,  // default value
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
-                           0,  // default value
-                           PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
-                           0,  // default value
-                           PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(kExtensionsLastChromeVersion,
-                            std::string(),  // default value
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(kSideloadWipeoutDone,
-                             false,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
+void ExtensionPrefs::RegisterUserPrefs(PrefRegistrySyncable* registry) {
+  registry->RegisterDictionaryPref(kExtensionsPref,
+                                   PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(kExtensionToolbar,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(kExtensionActionBox,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(kExtensionActionBoxBar,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(prefs::kExtensionToolbarSize,
+                                -1,  // default value
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterDictionaryPref(kExtensionsBlacklistUpdate,
+                                   PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(prefs::kExtensionInstallAllowList,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(prefs::kExtensionInstallDenyList,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterDictionaryPref(prefs::kExtensionInstallForceList,
+                                   PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(prefs::kExtensionAllowedTypes,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(kWebStoreLogin,
+                               std::string(),  // default value
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion,
+                               "0",  // default value
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kExtensionStorageGarbageCollect,
+                                false,  // default value
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
+                              0,  // default value
+                              PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
+                              0,  // default value
+                              PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(prefs::kExtensionAllowedInstallSites,
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(kExtensionsLastChromeVersion,
+                               std::string(),  // default value
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(kSideloadWipeoutDone,
+                                false,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 ExtensionIdList ExtensionPrefs::GetExtensionPrefAsVector(
     const char* pref) {
   ExtensionIdList extension_ids;
   const ListValue* list_of_values = prefs_->GetList(pref);
   if (!list_of_values)
     return extension_ids;
 
   std::string extension_id;
@@ skipping 87 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions