components: Move PrefRegistrySyncable into user_prefs namespace.

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/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
@@ skipping 27 matching lines @@
                             base::Bind(&SyncPrefs::OnSyncManagedPrefChanged,
                                        base::Unretained(this)));
   }
 }
 
 SyncPrefs::~SyncPrefs() {
   DCHECK(CalledOnValidThread());
 }
 
 // static
-void SyncPrefs::RegisterUserPrefs(PrefRegistrySyncable* registry) {
+void SyncPrefs::RegisterUserPrefs(user_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);
+  registry->RegisterBooleanPref(
+      prefs::kSyncHasSetupCompleted,
+      false,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kSyncSuppressStart,
+      false,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterInt64Pref(
+      prefs::kSyncLastSyncedTime,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   // All datatypes are on by default, but this gets set explicitly
   // when you configure sync (when turning it on), in
   // ProfileSyncService::OnUserChoseDatatypes.
-  registry->RegisterBooleanPref(prefs::kSyncKeepEverythingSynced,
-                                true,
-                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kSyncKeepEverythingSynced,
+      true,
+      user_prefs::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(registry, syncer::BOOKMARKS, true);
   user_types.Remove(syncer::BOOKMARKS);
 
   // All types are set to off by default, which forces a configuration to
   // explicitly enable them. GetPreferredTypes() will ensure that any new
   // implicit types are enabled when their pref group is, or via
   // KeepEverythingSynced.
   for (syncer::ModelTypeSet::Iterator it = user_types.First();
        it.Good(); it.Inc()) {
     RegisterDataTypePreferredPref(registry, it.Get(), false);
   }
 
-  registry->RegisterBooleanPref(prefs::kSyncManaged,
-                                false,
-                                PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
-                               std::string(),
-                               PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterStringPref(prefs::kSyncKeystoreEncryptionBootstrapToken,
-                               std::string(),
-                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kSyncManaged,
+      false,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kSyncEncryptionBootstrapToken,
+      std::string(),
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kSyncKeystoreEncryptionBootstrapToken,
+      std::string(),
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 #if defined(OS_CHROMEOS)
-  registry->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
-                               "",
-                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kSyncSpareBootstrapToken,
+      "",
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
 
-  registry->RegisterStringPref(prefs::kSyncSessionsGUID,
-                               std::string(),
-                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kSyncSessionsGUID,
+      std::string(),
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   // 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);
   registry->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
                              syncer::ModelTypeSetToValue(model_set),
-                             PrefRegistrySyncable::UNSYNCABLE_PREF);
+                             user_prefs::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 286 matching lines @@
 
   pref_groups_[syncer::PROXY_TABS].Put(syncer::SESSIONS);
   pref_groups_[syncer::PROXY_TABS].Put(syncer::FAVICON_IMAGES);
   pref_groups_[syncer::PROXY_TABS].Put(syncer::FAVICON_TRACKING);
 
   // TODO(zea): put favicons in the bookmarks group as well once it handles
   // those favicons.
 }
 
 // static
-void SyncPrefs::RegisterDataTypePreferredPref(PrefRegistrySyncable* registry,
-                                              syncer::ModelType type,
-                                              bool is_preferred) {
+void SyncPrefs::RegisterDataTypePreferredPref(
+    user_prefs::PrefRegistrySyncable* registry,
+    syncer::ModelType type,
+    bool is_preferred) {
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
-  registry->RegisterBooleanPref(pref_name, is_preferred,
-                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      pref_name,
+      is_preferred,
+      user_prefs::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 30 matching lines @@
   for (PrefGroupsMap::const_iterator i = pref_groups_.begin();
       i != pref_groups_.end(); ++i) {
     if (types.Has(i->first))
       types_with_groups.PutAll(i->second);
   }
   types_with_groups.RetainAll(registered_types);
   return types_with_groups;
 }
 
 }  // namespace browser_sync