Introduce PrefRegistrySyncable, simplifying PrefServiceSyncable.

chrome/browser/sync/sync_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/sync/sync_prefs.h"
 
 #include "base/logging.h"
 #include "base/prefs/public/pref_member.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
+#include "chrome/browser/prefs/pref_registry_syncable.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 namespace browser_sync {
 
 SyncPrefObserver::~SyncPrefObserver() {}
 
-SyncPrefs::SyncPrefs(PrefServiceSyncable* pref_service)
+SyncPrefs::SyncPrefs(PrefService* pref_service)
     : pref_service_(pref_service) {
   RegisterPrefGroups();
   // TODO(tim): Create a Mock instead of maintaining the if(!pref_service_) case
   // throughout this file.  This is a problem now due to lack of injection at
   // ProfileSyncService. Bug 130176.
   if (pref_service_) {
     // Watch the preference that indicates sync is managed so we can take
     // appropriate action.
     pref_sync_managed_.Init(prefs::kSyncManaged, pref_service_,
                             base::Bind(&SyncPrefs::OnSyncManagedPrefChanged,
                                        base::Unretained(this)));
   }
 }
 
 SyncPrefs::~SyncPrefs() {
   DCHECK(CalledOnValidThread());
 }
 
 // static
-void SyncPrefs::RegisterUserPrefs(PrefServiceSyncable* prefs) {
-  prefs->RegisterBooleanPref(prefs::kSyncHasSetupCompleted,
-                             false,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kSyncSuppressStart,
-                             false,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterInt64Pref(prefs::kSyncLastSyncedTime,
-                           0,
-                           PrefServiceSyncable::UNSYNCABLE_PREF);
+void SyncPrefs::RegisterUserPrefs(PrefService* prefs,
+                                  PrefRegistrySyncable* registry) {
+  // TODO(joi): Remove |prefs| parameter.
+  registry->RegisterBooleanPref(prefs::kSyncHasSetupCompleted,
+                                false,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kSyncSuppressStart,
+                                false,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterInt64Pref(prefs::kSyncLastSyncedTime,
+                              0,
+                              PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   // If you've never synced before, or if you're using Chrome OS or Android,
   // all datatypes are on by default.
   // TODO(nick): Perhaps a better model would be to always default to false,
   // and explicitly call SetDataTypes() when the user shows the wizard.
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   bool enable_by_default = true;
 #else
   bool enable_by_default = !prefs->HasPrefPath(prefs::kSyncHasSetupCompleted);
 #endif
 
-  prefs->RegisterBooleanPref(prefs::kSyncKeepEverythingSynced,
-                             enable_by_default,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kSyncKeepEverythingSynced,
+                                enable_by_default,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   syncer::ModelTypeSet user_types = syncer::UserTypes();
 
   // Include proxy types as well, as they can be individually selected,
   // although they don't have sync representations.
   user_types.PutAll(syncer::ProxyTypes());
 
   // Treat bookmarks specially.
-  RegisterDataTypePreferredPref(prefs, syncer::BOOKMARKS, true);
+  RegisterDataTypePreferredPref(registry, syncer::BOOKMARKS, true);
   user_types.Remove(syncer::BOOKMARKS);
 
   for (syncer::ModelTypeSet::Iterator it = user_types.First();
        it.Good(); it.Inc()) {
-    RegisterDataTypePreferredPref(prefs, it.Get(), enable_by_default);
+    RegisterDataTypePreferredPref(registry, it.Get(), enable_by_default);
   }
 
-  prefs->RegisterBooleanPref(prefs::kSyncManaged,
-                             false,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
-                            "",
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(prefs::kSyncKeystoreEncryptionBootstrapToken,
-                            "",
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kSyncManaged,
+                                false,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
+                               "",
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(prefs::kSyncKeystoreEncryptionBootstrapToken,
+                               "",
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
 #if defined(OS_CHROMEOS)
-  prefs->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
-                            "",
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
+                               "",
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
 
   // We will start prompting people about new data types after the launch of
   // SESSIONS - all previously launched data types are treated as if they are
   // already acknowledged.
   syncer::ModelTypeSet model_set;
   model_set.Put(syncer::BOOKMARKS);
   model_set.Put(syncer::PREFERENCES);
   model_set.Put(syncer::PASSWORDS);
   model_set.Put(syncer::AUTOFILL_PROFILE);
   model_set.Put(syncer::AUTOFILL);
   model_set.Put(syncer::THEMES);
   model_set.Put(syncer::EXTENSIONS);
   model_set.Put(syncer::NIGORI);
   model_set.Put(syncer::SEARCH_ENGINES);
   model_set.Put(syncer::APPS);
   model_set.Put(syncer::TYPED_URLS);
   model_set.Put(syncer::SESSIONS);
-  prefs->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
-                          syncer::ModelTypeSetToValue(model_set),
-                          PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
+                             syncer::ModelTypeSetToValue(model_set),
+                             PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 bool SyncPrefs::IsSyncAccessibleOnIOThread(ProfileIOData* io_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   return ProfileSyncService::IsSyncEnabled() &&
          !io_data->sync_disabled()->GetValue();
 }
 
 void SyncPrefs::AddSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
@@ skipping 257 matching lines @@
   pref_groups_[syncer::EXTENSIONS].Put(syncer::EXTENSION_SETTINGS);
 
   pref_groups_[syncer::PREFERENCES].Put(syncer::DICTIONARY);
   pref_groups_[syncer::PREFERENCES].Put(syncer::SEARCH_ENGINES);
 
   // TODO(akalin): Revisit this once UI lands.
   pref_groups_[syncer::SESSIONS].Put(syncer::HISTORY_DELETE_DIRECTIVES);
 }
 
 // static
-void SyncPrefs::RegisterDataTypePreferredPref(PrefServiceSyncable* prefs,
+void SyncPrefs::RegisterDataTypePreferredPref(PrefRegistrySyncable* registry,
                                               syncer::ModelType type,
                                               bool is_preferred) {
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
-  prefs->RegisterBooleanPref(pref_name, is_preferred,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(pref_name, is_preferred,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 bool SyncPrefs::GetDataTypePreferred(syncer::ModelType type) const {
   DCHECK(CalledOnValidThread());
   if (!pref_service_) {
     return false;
   }
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
@@ skipping 25 matching lines @@
     if (types.Has(i->first))
       types_with_groups.PutAll(i->second);
     else
       types_with_groups.RemoveAll(i->second);
   }
   types_with_groups.RetainAll(registered_types);
   return types_with_groups;
 }
 
 }  // namespace browser_sync