[Sync] Move ModelType and related classes to 'syncer' 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/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ skipping 101 matching lines @@
       pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced);
 }
 
 void SyncPrefs::SetKeepEverythingSynced(bool keep_everything_synced) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncKeepEverythingSynced,
                             keep_everything_synced);
 }
 
-syncable::ModelTypeSet SyncPrefs::GetPreferredDataTypes(
-    syncable::ModelTypeSet registered_types) const {
+syncer::ModelTypeSet SyncPrefs::GetPreferredDataTypes(
+    syncer::ModelTypeSet registered_types) const {
   DCHECK(CalledOnValidThread());
   if (!pref_service_) {
-    return syncable::ModelTypeSet();
+    return syncer::ModelTypeSet();
   }
 
   // First remove any datatypes that are inconsistent with the current policies
   // on the client (so that "keep everything synced" doesn't include them).
   if (pref_service_->HasPrefPath(prefs::kSavingBrowserHistoryDisabled) &&
       pref_service_->GetBoolean(prefs::kSavingBrowserHistoryDisabled)) {
-    registered_types.Remove(syncable::TYPED_URLS);
+    registered_types.Remove(syncer::TYPED_URLS);
   }
 
   if (pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced)) {
     return registered_types;
   }
 
-  syncable::ModelTypeSet preferred_types;
-  for (syncable::ModelTypeSet::Iterator it = registered_types.First();
+  syncer::ModelTypeSet preferred_types;
+  for (syncer::ModelTypeSet::Iterator it = registered_types.First();
        it.Good(); it.Inc()) {
     if (GetDataTypePreferred(it.Get())) {
       preferred_types.Put(it.Get());
     }
   }
   return ResolvePrefGroups(registered_types, preferred_types);
 }
 
 void SyncPrefs::SetPreferredDataTypes(
-    syncable::ModelTypeSet registered_types,
-    syncable::ModelTypeSet preferred_types) {
+    syncer::ModelTypeSet registered_types,
+    syncer::ModelTypeSet preferred_types) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   DCHECK(registered_types.HasAll(preferred_types));
   preferred_types = ResolvePrefGroups(registered_types, preferred_types);
-  for (syncable::ModelTypeSet::Iterator i = registered_types.First();
+  for (syncer::ModelTypeSet::Iterator i = registered_types.First();
        i.Good(); i.Inc()) {
     SetDataTypePreferred(i.Get(), preferred_types.Has(i.Get()));
   }
 }
 
 bool SyncPrefs::IsManaged() const {
   DCHECK(CalledOnValidThread());
   return pref_service_ && pref_service_->GetBoolean(prefs::kSyncManaged);
 }
 
@@ skipping 16 matching lines @@
       pref_service_->GetString(prefs::kSyncSpareBootstrapToken) : "";
 }
 
 void SyncPrefs::SetSpareBootstrapToken(const std::string& token) {
   DCHECK(CalledOnValidThread());
   pref_service_->SetString(prefs::kSyncSpareBootstrapToken, token);
 }
 #endif
 
 void SyncPrefs::AcknowledgeSyncedTypes(
-    syncable::ModelTypeSet types) {
+    syncer::ModelTypeSet types) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   // Add the types to the current set of acknowledged
   // types, and then store the resulting set in prefs.
-  const syncable::ModelTypeSet acknowledged_types =
+  const syncer::ModelTypeSet acknowledged_types =
       Union(types,
-            syncable::ModelTypeSetFromValue(
+            syncer::ModelTypeSetFromValue(
                 *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes)));
 
   scoped_ptr<ListValue> value(
-      syncable::ModelTypeSetToValue(acknowledged_types));
+      syncer::ModelTypeSetToValue(acknowledged_types));
   pref_service_->Set(prefs::kSyncAcknowledgedSyncTypes, *value);
 }
 
 void SyncPrefs::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK(CalledOnValidThread());
   DCHECK(content::Source<PrefService>(pref_service_) == source);
   switch (type) {
     case chrome::NOTIFICATION_PREF_CHANGED: {
@@ skipping 10 matching lines @@
       break;
   }
 }
 
 void SyncPrefs::SetManagedForTest(bool is_managed) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncManaged, is_managed);
 }
 
-syncable::ModelTypeSet SyncPrefs::GetAcknowledgeSyncedTypesForTest() const {
+syncer::ModelTypeSet SyncPrefs::GetAcknowledgeSyncedTypesForTest() const {
   DCHECK(CalledOnValidThread());
   if (!pref_service_) {
-    return syncable::ModelTypeSet();
+    return syncer::ModelTypeSet();
   }
-  return syncable::ModelTypeSetFromValue(
+  return syncer::ModelTypeSetFromValue(
       *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes));
 }
 
 namespace {
 
-const char* GetPrefNameForDataType(syncable::ModelType data_type) {
+const char* GetPrefNameForDataType(syncer::ModelType data_type) {
   switch (data_type) {
-    case syncable::BOOKMARKS:
+    case syncer::BOOKMARKS:
       return prefs::kSyncBookmarks;
-    case syncable::PASSWORDS:
+    case syncer::PASSWORDS:
       return prefs::kSyncPasswords;
-    case syncable::PREFERENCES:
+    case syncer::PREFERENCES:
       return prefs::kSyncPreferences;
-    case syncable::AUTOFILL:
+    case syncer::AUTOFILL:
       return prefs::kSyncAutofill;
-    case syncable::AUTOFILL_PROFILE:
+    case syncer::AUTOFILL_PROFILE:
       return prefs::kSyncAutofillProfile;
-    case syncable::THEMES:
+    case syncer::THEMES:
       return prefs::kSyncThemes;
-    case syncable::TYPED_URLS:
+    case syncer::TYPED_URLS:
       return prefs::kSyncTypedUrls;
-    case syncable::EXTENSION_SETTINGS:
+    case syncer::EXTENSION_SETTINGS:
       return prefs::kSyncExtensionSettings;
-    case syncable::EXTENSIONS:
+    case syncer::EXTENSIONS:
       return prefs::kSyncExtensions;
-    case syncable::APP_SETTINGS:
+    case syncer::APP_SETTINGS:
       return prefs::kSyncAppSettings;
-    case syncable::APPS:
+    case syncer::APPS:
       return prefs::kSyncApps;
-    case syncable::SEARCH_ENGINES:
+    case syncer::SEARCH_ENGINES:
       return prefs::kSyncSearchEngines;
-    case syncable::SESSIONS:
+    case syncer::SESSIONS:
       return prefs::kSyncSessions;
-    case syncable::APP_NOTIFICATIONS:
+    case syncer::APP_NOTIFICATIONS:
       return prefs::kSyncAppNotifications;
     default:
       break;
   }
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace
 
 void SyncPrefs::RegisterPrefGroups() {
-  pref_groups_[syncable::APPS].Put(syncable::APP_NOTIFICATIONS);
-  pref_groups_[syncable::APPS].Put(syncable::APP_SETTINGS);
+  pref_groups_[syncer::APPS].Put(syncer::APP_NOTIFICATIONS);
+  pref_groups_[syncer::APPS].Put(syncer::APP_SETTINGS);
 
-  pref_groups_[syncable::AUTOFILL].Put(syncable::AUTOFILL_PROFILE);
+  pref_groups_[syncer::AUTOFILL].Put(syncer::AUTOFILL_PROFILE);
 
-  pref_groups_[syncable::EXTENSIONS].Put(syncable::EXTENSION_SETTINGS);
+  pref_groups_[syncer::EXTENSIONS].Put(syncer::EXTENSION_SETTINGS);
 
-  pref_groups_[syncable::PREFERENCES].Put(syncable::SEARCH_ENGINES);
+  pref_groups_[syncer::PREFERENCES].Put(syncer::SEARCH_ENGINES);
 }
 
 void SyncPrefs::RegisterPreferences() {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   if (pref_service_->FindPreference(prefs::kSyncLastSyncedTime)) {
     return;
   }
 
   pref_service_->RegisterBooleanPref(prefs::kSyncHasSetupCompleted,
@@ skipping 15 matching lines @@
 #else
   bool enable_by_default =
       !pref_service_->HasPrefPath(prefs::kSyncHasSetupCompleted);
 #endif
 
   pref_service_->RegisterBooleanPref(prefs::kSyncKeepEverythingSynced,
                                      enable_by_default,
                                      PrefService::UNSYNCABLE_PREF);
 
   // Treat bookmarks specially.
-  RegisterDataTypePreferredPref(syncable::BOOKMARKS, true);
-  for (int i = syncable::PREFERENCES; i < syncable::MODEL_TYPE_COUNT; ++i) {
-    const syncable::ModelType type = syncable::ModelTypeFromInt(i);
+  RegisterDataTypePreferredPref(syncer::BOOKMARKS, true);
+  for (int i = syncer::PREFERENCES; i < syncer::MODEL_TYPE_COUNT; ++i) {
+    const syncer::ModelType type = syncer::ModelTypeFromInt(i);
     // Also treat nigori specially.
-    if (type == syncable::NIGORI) {
+    if (type == syncer::NIGORI) {
       continue;
     }
     RegisterDataTypePreferredPref(type, enable_by_default);
   }
 
   pref_service_->RegisterBooleanPref(prefs::kSyncManaged,
                                      false,
                                      PrefService::UNSYNCABLE_PREF);
   pref_service_->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
                                     "",
                                     PrefService::UNSYNCABLE_PREF);
 #if defined(OS_CHROMEOS)
   pref_service_->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
                                     "",
                                     PrefService::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.
-  syncable::ModelTypeSet model_set;
-  model_set.Put(syncable::BOOKMARKS);
-  model_set.Put(syncable::PREFERENCES);
-  model_set.Put(syncable::PASSWORDS);
-  model_set.Put(syncable::AUTOFILL_PROFILE);
-  model_set.Put(syncable::AUTOFILL);
-  model_set.Put(syncable::THEMES);
-  model_set.Put(syncable::EXTENSIONS);
-  model_set.Put(syncable::NIGORI);
-  model_set.Put(syncable::SEARCH_ENGINES);
-  model_set.Put(syncable::APPS);
-  model_set.Put(syncable::TYPED_URLS);
-  model_set.Put(syncable::SESSIONS);
+  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);
   pref_service_->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
-                                  syncable::ModelTypeSetToValue(model_set),
+                                  syncer::ModelTypeSetToValue(model_set),
                                   PrefService::UNSYNCABLE_PREF);
 }
 
-void SyncPrefs::RegisterDataTypePreferredPref(syncable::ModelType type,
+void SyncPrefs::RegisterDataTypePreferredPref(syncer::ModelType type,
                                               bool is_preferred) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
   pref_service_->RegisterBooleanPref(pref_name, is_preferred,
                                      PrefService::UNSYNCABLE_PREF);
 }
 
-bool SyncPrefs::GetDataTypePreferred(syncable::ModelType type) const {
+bool SyncPrefs::GetDataTypePreferred(syncer::ModelType type) const {
   DCHECK(CalledOnValidThread());
   if (!pref_service_) {
     return false;
   }
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return false;
   }
 
   return pref_service_->GetBoolean(pref_name);
 }
 
 void SyncPrefs::SetDataTypePreferred(
-    syncable::ModelType type, bool is_preferred) {
+    syncer::ModelType type, bool is_preferred) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
   pref_service_->SetBoolean(pref_name, is_preferred);
 }
 
-syncable::ModelTypeSet SyncPrefs::ResolvePrefGroups(
-    syncable::ModelTypeSet registered_types,
-    syncable::ModelTypeSet types) const {
+syncer::ModelTypeSet SyncPrefs::ResolvePrefGroups(
+    syncer::ModelTypeSet registered_types,
+    syncer::ModelTypeSet types) const {
   DCHECK(registered_types.HasAll(types));
-  syncable::ModelTypeSet types_with_groups = types;
+  syncer::ModelTypeSet types_with_groups = types;
   for (PrefGroupsMap::const_iterator i = pref_groups_.begin();
       i != pref_groups_.end(); ++i) {
     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