[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/sync_prefs.cc

 // Copyright (c) 2011 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 105 matching lines @@
 }
 
 void SyncPrefs::SetKeepEverythingSynced(bool keep_everything_synced) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncKeepEverythingSynced,
                             keep_everything_synced);
   pref_service_->ScheduleSavePersistentPrefs();
 }
 
-syncable::ModelEnumSet SyncPrefs::GetPreferredDataTypes(
-    syncable::ModelEnumSet registered_types) const {
+syncable::ModelTypeSet SyncPrefs::GetPreferredDataTypes(
+    syncable::ModelTypeSet registered_types) const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   if (!pref_service_) {
-    return syncable::ModelEnumSet();
+    return syncable::ModelTypeSet();
   }
 
   if (pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced)) {
     return registered_types;
   }
 
   // Remove autofill_profile since it's controlled by autofill, and
   // search_engines since it's controlled by preferences (see code below).
-  syncable::ModelEnumSet user_selectable_types(registered_types);
+  syncable::ModelTypeSet user_selectable_types(registered_types);
   DCHECK(!user_selectable_types.Has(syncable::NIGORI));
   user_selectable_types.Remove(syncable::AUTOFILL_PROFILE);
   user_selectable_types.Remove(syncable::SEARCH_ENGINES);
 
   // Remove app_notifications since it's controlled by apps (see
   // code below).
   // TODO(akalin): Centralize notion of all user selectable data types.
   user_selectable_types.Remove(syncable::APP_NOTIFICATIONS);
 
-  syncable::ModelEnumSet preferred_types;
+  syncable::ModelTypeSet preferred_types;
 
-  for (syncable::ModelEnumSet::Iterator it = user_selectable_types.First();
+  for (syncable::ModelTypeSet::Iterator it = user_selectable_types.First();
        it.Good(); it.Inc()) {
     if (GetDataTypePreferred(it.Get())) {
       preferred_types.Put(it.Get());
     }
   }
 
   // Group the enabled/disabled state of autofill_profile with autofill, and
   // search_engines with preferences (since only autofill and preferences are
   // shown on the UI).
   if (registered_types.Has(syncable::AUTOFILL) &&
@@ skipping 12 matching lines @@
   if (registered_types.Has(syncable::APPS) &&
       registered_types.Has(syncable::APP_NOTIFICATIONS) &&
       GetDataTypePreferred(syncable::APPS)) {
     preferred_types.Put(syncable::APP_NOTIFICATIONS);
   }
 
   return preferred_types;
 }
 
 void SyncPrefs::SetPreferredDataTypes(
-    syncable::ModelEnumSet registered_types,
-    syncable::ModelEnumSet preferred_types) {
+    syncable::ModelTypeSet registered_types,
+    syncable::ModelTypeSet preferred_types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   DCHECK(registered_types.HasAll(preferred_types));
-  syncable::ModelEnumSet preferred_types_with_dependents(preferred_types);
+  syncable::ModelTypeSet preferred_types_with_dependents(preferred_types);
   // Set autofill_profile to the same enabled/disabled state as
   // autofill (since only autofill is shown in the UI).
   if (registered_types.Has(syncable::AUTOFILL) &&
       registered_types.Has(syncable::AUTOFILL_PROFILE)) {
     if (preferred_types_with_dependents.Has(syncable::AUTOFILL)) {
       preferred_types_with_dependents.Put(syncable::AUTOFILL_PROFILE);
     } else {
       preferred_types_with_dependents.Remove(syncable::AUTOFILL_PROFILE);
     }
   }
@@ skipping 11 matching lines @@
   // preferences (since only preferences is shown in the UI).
   if (registered_types.Has(syncable::PREFERENCES) &&
       registered_types.Has(syncable::SEARCH_ENGINES)) {
     if (preferred_types_with_dependents.Has(syncable::PREFERENCES)) {
       preferred_types_with_dependents.Put(syncable::SEARCH_ENGINES);
     } else {
       preferred_types_with_dependents.Remove(syncable::SEARCH_ENGINES);
     }
   }
 
-  for (syncable::ModelEnumSet::Iterator it = registered_types.First();
+  for (syncable::ModelTypeSet::Iterator it = registered_types.First();
        it.Good(); it.Inc()) {
     SetDataTypePreferred(
         it.Get(), preferred_types_with_dependents.Has(it.Get()));
   }
 }
 
 bool SyncPrefs::IsManaged() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return pref_service_ && pref_service_->GetBoolean(prefs::kSyncManaged);
 }
@@ skipping 74 matching lines @@
            max_versions.begin();
        it != max_versions.end(); ++it) {
     max_versions_dict.SetString(
         base::IntToString(it->first),
         base::Int64ToString(it->second));
   }
   pref_service_->Set(prefs::kSyncMaxInvalidationVersions, max_versions_dict);
 }
 
 void SyncPrefs::AcknowledgeSyncedTypes(
-    syncable::ModelEnumSet types) {
+    syncable::ModelTypeSet types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   // Add the types to the current set of acknowledged
   // types, and then store the resulting set in prefs.
-  const syncable::ModelEnumSet acknowledged_types =
+  const syncable::ModelTypeSet acknowledged_types =
       Union(types,
-            syncable::ModelEnumSetFromValue(
+            syncable::ModelTypeSetFromValue(
                 *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes)));
 
   scoped_ptr<ListValue> value(
-      syncable::ModelEnumSetToValue(acknowledged_types));
+      syncable::ModelTypeSetToValue(acknowledged_types));
   pref_service_->Set(prefs::kSyncAcknowledgedSyncTypes, *value);
   pref_service_->ScheduleSavePersistentPrefs();
 }
 
 void SyncPrefs::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   DCHECK(content::Source<PrefService>(pref_service_) == source);
   switch (type) {
@@ skipping 12 matching lines @@
   }
 }
 
 void SyncPrefs::SetManagedForTest(bool is_managed) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncManaged, is_managed);
   pref_service_->ScheduleSavePersistentPrefs();
 }
 
-syncable::ModelEnumSet SyncPrefs::GetAcknowledgeSyncedTypesForTest() const {
+syncable::ModelTypeSet SyncPrefs::GetAcknowledgeSyncedTypesForTest() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   if (!pref_service_) {
-    return syncable::ModelEnumSet();
+    return syncable::ModelTypeSet();
   }
-  return syncable::ModelEnumSetFromValue(
+  return syncable::ModelTypeSetFromValue(
       *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes));
 }
 
 namespace {
 
 const char* GetPrefNameForDataType(syncable::ModelType data_type) {
   switch (data_type) {
     case syncable::BOOKMARKS:
       return prefs::kSyncBookmarks;
     case syncable::PASSWORDS:
@@ skipping 77 matching lines @@
   pref_service_->RegisterBooleanPref(prefs::kSyncManaged,
                                      false,
                                      PrefService::UNSYNCABLE_PREF);
   pref_service_->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
                                     "",
                                     PrefService::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.
-  syncable::ModelEnumSet model_set;
+  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);
   pref_service_->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
-                                  syncable::ModelEnumSetToValue(model_set),
+                                  syncable::ModelTypeSetToValue(model_set),
                                   PrefService::UNSYNCABLE_PREF);
 
   pref_service_->RegisterDictionaryPref(prefs::kSyncMaxInvalidationVersions,
                                         PrefService::UNSYNCABLE_PREF);
 }
 
 void SyncPrefs::RegisterDataTypePreferredPref(syncable::ModelType type,
                                               bool is_preferred) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
@@ skipping 27 matching lines @@
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
   }
   pref_service_->SetBoolean(pref_name, is_preferred);
   pref_service_->ScheduleSavePersistentPrefs();
 }
 
 }  // namespace browser_sync