[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 84 matching lines @@
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!registrar_.get());
 }
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& sync_service_url,
-    syncable::ModelEnumSet initial_types,
+    syncable::ModelTypeSet initial_types,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder) {
   if (!sync_thread_.Start())
     return;
 
   frontend_ = frontend;
   DCHECK(frontend);
 
-  syncable::ModelEnumSet initial_types_with_nigori(initial_types);
+  syncable::ModelTypeSet initial_types_with_nigori(initial_types);
   CHECK(sync_prefs_.get());
   if (sync_prefs_->HasSyncSetupCompleted()) {
     initial_types_with_nigori.Put(syncable::NIGORI);
   }
 
   registrar_.reset(new SyncBackendRegistrar(initial_types_with_nigori,
                                             name_,
                                             profile_,
                                             sync_thread_.message_loop()));
   initialization_state_ = CREATING_SYNC_MANAGER;
@@ skipping 115 matching lines @@
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     sync_thread_.Stop();
   }
 
   registrar_.reset();
   frontend_ = NULL;
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
-    syncable::ModelEnumSet types_to_add,
-    syncable::ModelEnumSet types_to_remove,
+    syncable::ModelTypeSet types_to_add,
+    syncable::ModelTypeSet types_to_remove,
     sync_api::ConfigureReason reason,
-    base::Callback<void(syncable::ModelEnumSet)> ready_task,
+    base::Callback<void(syncable::ModelTypeSet)> ready_task,
     bool enable_nigori) {
-  syncable::ModelEnumSet types_to_add_with_nigori = types_to_add;
-  syncable::ModelEnumSet types_to_remove_with_nigori = types_to_remove;
+  syncable::ModelTypeSet types_to_add_with_nigori = types_to_add;
+  syncable::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
   if (enable_nigori) {
     types_to_add_with_nigori.Put(syncable::NIGORI);
     types_to_remove_with_nigori.Remove(syncable::NIGORI);
   } else {
     types_to_add_with_nigori.Remove(syncable::NIGORI);
     types_to_remove_with_nigori.Put(syncable::NIGORI);
   }
   // Only one configure is allowed at a time.
   DCHECK(!pending_config_mode_state_.get());
   DCHECK(!pending_download_state_.get());
@@ skipping 208 matching lines @@
 
 void SyncBackendHost::Core::OnClearServerDataSucceeded() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, base::Bind(
       &Core::HandleClearServerDataSucceededOnFrontendLoop, this));
 }
 
 void SyncBackendHost::Core::OnEncryptedTypesChanged(
-    syncable::ModelEnumSet encrypted_types,
+    syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       base::Bind(&Core::NotifyEncryptedTypesChanged, this,
                  encrypted_types, encrypt_everything));
 }
@@ skipping 181 matching lines @@
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_ = NULL;
 }
 
 void SyncBackendHost::Core::DoRequestConfig(
-    syncable::ModelEnumSet types_to_config,
+    syncable::ModelTypeSet types_to_config,
     sync_api::ConfigureReason reason) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestConfig(types_to_config, reason);
 }
 
 void SyncBackendHost::Core::DoStartConfiguration(
     const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartConfigurationMode(callback);
 }
@@ skipping 15 matching lines @@
 void SyncBackendHost::Core::HandleInitializationCompletedOnFrontendLoop(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
   if (!host_)
     return;
   host_->HandleInitializationCompletedOnFrontendLoop(js_backend, success);
 }
 
 void SyncBackendHost::Core::HandleNigoriConfigurationCompletedOnFrontendLoop(
     const WeakHandle<JsBackend>& js_backend,
-    const syncable::ModelEnumSet failed_configuration_types) {
+    const syncable::ModelTypeSet failed_configuration_types) {
   if (!host_)
     return;
   host_->HandleInitializationCompletedOnFrontendLoop(
       js_backend, failed_configuration_types.Empty());
 }
 
 void SyncBackendHost::Core::StartSavingChanges() {
   // We may already be shut down.
   if (!sync_loop_)
     return;
@@ skipping 53 matching lines @@
     return;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TokenAvailableDetails details(GaiaConstants::kSyncService, token);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_UPDATED,
       content::Source<Profile>(host_->profile_),
       content::Details<const TokenAvailableDetails>(&details));
 }
 
 void SyncBackendHost::Core::NotifyEncryptedTypesChanged(
-    syncable::ModelEnumSet encrypted_types,
+    syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!host_)
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
   host_->frontend_->OnEncryptedTypesChanged(
       encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHost::Core::NotifyEncryptionComplete() {
   if (!host_)
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
   host_->frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHost::Core::HandleSyncCycleCompletedOnFrontendLoop(
     SyncSessionSnapshot* snapshot) {
   if (!host_ || !host_->frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
   host_->last_snapshot_.reset(snapshot);
 
   SVLOG(1) << "Got snapshot " << snapshot->ToString();
 
-  const syncable::ModelEnumSet to_migrate =
+  const syncable::ModelTypeSet to_migrate =
       snapshot->syncer_status.types_needing_local_migration;
   if (!to_migrate.Empty())
     host_->frontend_->OnMigrationNeededForTypes(to_migrate);
 
   // Process any changes to the datatypes we're syncing.
   // TODO(sync): add support for removing types.
   if (host_->initialized())
     host_->AddExperimentalTypes();
 
   // If we are waiting for a configuration change, check here to see
   // if this sync cycle has initialized all of the types we've been
   // waiting for.
   if (host_->pending_download_state_.get()) {
     scoped_ptr<PendingConfigureDataTypesState> state(
         host_->pending_download_state_.release());
-    const syncable::ModelEnumSet types_to_add = state->types_to_add;
-    const syncable::ModelEnumSet added_types = state->added_types;
+    const syncable::ModelTypeSet types_to_add = state->types_to_add;
+    const syncable::ModelTypeSet added_types = state->added_types;
     DCHECK(types_to_add.HasAll(added_types));
-    const syncable::ModelEnumSet initial_sync_ended =
+    const syncable::ModelTypeSet initial_sync_ended =
         snapshot->initial_sync_ended;
-    const syncable::ModelEnumSet failed_configuration_types =
+    const syncable::ModelTypeSet failed_configuration_types =
         Difference(added_types, initial_sync_ended);
     SVLOG(1)
         << "Added types: "
-        << syncable::ModelEnumSetToString(added_types)
+        << syncable::ModelTypeSetToString(added_types)
         << ", configured types: "
-        << syncable::ModelEnumSetToString(initial_sync_ended)
+        << syncable::ModelTypeSetToString(initial_sync_ended)
         << ", failed configuration types: "
-        << syncable::ModelEnumSetToString(failed_configuration_types);
+        << syncable::ModelTypeSetToString(failed_configuration_types);
     state->ready_task.Run(failed_configuration_types);
     if (!failed_configuration_types.Empty())
       return;
   }
 
   if (host_->initialized())
     host_->frontend_->OnSyncCycleCompleted();
 }
 
 void SyncBackendHost::Core::HandleStopSyncingPermanentlyOnFrontendLoop() {
@@ skipping 13 matching lines @@
     return;
   host_->frontend_->OnClearServerDataFailed();
 }
 
 void SyncBackendHost::Core::FinishConfigureDataTypesOnFrontendLoop() {
   host_->FinishConfigureDataTypesOnFrontendLoop();
 }
 
 void SyncBackendHost::AddExperimentalTypes() {
   CHECK(initialized());
-  syncable::ModelEnumSet to_add;
+  syncable::ModelTypeSet to_add;
   if (core_->sync_manager()->ReceivedExperimentalTypes(&to_add))
     frontend_->OnDataTypesChanged(to_add);
 }
 
 void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop(
     const WeakHandle<JsBackend>& js_backend, bool success) {
   DCHECK_NE(NOT_ATTEMPTED, initialization_state_);
   if (!frontend_)
     return;
 
@@ skipping 15 matching lines @@
   if (sync_prefs_->HasSyncSetupCompleted() &&
       initialization_state_ < DOWNLOADING_NIGORI) {
     initialization_state_ = DOWNLOADING_NIGORI;
   }
 
   // Run initialization state machine.
   switch (initialization_state_) {
     case NOT_INITIALIZED:
       initialization_state_ = DOWNLOADING_NIGORI;
       ConfigureDataTypes(
-          syncable::ModelEnumSet(),
-          syncable::ModelEnumSet(),
+          syncable::ModelTypeSet(),
+          syncable::ModelTypeSet(),
           sync_api::CONFIGURE_REASON_NEW_CLIENT,
           // Calls back into this function.
           base::Bind(
               &SyncBackendHost::Core::
                   HandleNigoriConfigurationCompletedOnFrontendLoop,
               core_.get(), js_backend),
           true);
       break;
     case DOWNLOADING_NIGORI:
       initialization_state_ = REFRESHING_ENCRYPTION;
@@ skipping 36 matching lines @@
   // downloading updates for newly added data types.  Once this is
   // complete, the configure_state_.ready_task_ is run via an
   // OnInitializationComplete notification.
 
   SVLOG(1) << "Syncer in config mode. SBH executing "
            << "FinishConfigureDataTypesOnFrontendLoop";
 
   if (pending_config_mode_state_->added_types.Empty() &&
       !core_->sync_manager()->InitialSyncEndedForAllEnabledTypes()) {
 
-    syncable::ModelEnumSet enabled_types;
+    syncable::ModelTypeSet enabled_types;
     ModelSafeRoutingInfo routing_info;
     registrar_->GetModelSafeRoutingInfo(&routing_info);
     for (ModelSafeRoutingInfo::const_iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       enabled_types.Put(i->first);
     }
 
     // TODO(tim): Log / UMA / count this somehow?
     // Add only the types with empty progress markers. Note: it is possible
     // that some types have their initial_sync_ended be false but with non
     // empty progress marker. Which is ok as the rest of the changes would
     // be downloaded on a regular nudge and initial_sync_ended should be set
     // to true. However this is a very corner case. So it is not explicitly
     // handled.
     pending_config_mode_state_->added_types =
         sync_api::GetTypesWithEmptyProgressMarkerToken(enabled_types,
                                                        GetUserShare());
   }
 
   // If we've added types, we always want to request a nudge/config (even if
   // the initial sync is ended), in case we could not decrypt the data.
   if (pending_config_mode_state_->added_types.Empty()) {
     SVLOG(1) << "No new types added; calling ready_task directly";
     // No new types - just notify the caller that the types are available.
-    const syncable::ModelEnumSet failed_configuration_types;
+    const syncable::ModelTypeSet failed_configuration_types;
     pending_config_mode_state_->ready_task.Run(failed_configuration_types);
   } else {
     pending_download_state_.reset(pending_config_mode_state_.release());
 
     // Always configure nigori if it's enabled.
-    syncable::ModelEnumSet types_to_config =
+    syncable::ModelTypeSet types_to_config =
         pending_download_state_->added_types;
     if (IsNigoriEnabled()) {
       // Note: Nigori is the only type that gets added with a nonempty
       // progress marker during config. If the server returns a migration
       // error then we will go into unrecoverable error. We dont handle it
       // explicitly because server might help us out here by not sending a
       // migraiton error for nigori during config.
       types_to_config.Put(syncable::NIGORI);
     }
     SVLOG(1) << "Types "
-             << syncable::ModelEnumSetToString(types_to_config)
+             << syncable::ModelTypeSetToString(types_to_config)
             << " added; calling DoRequestConfig";
     sync_thread_.message_loop()->PostTask(FROM_HERE,
          base::Bind(&SyncBackendHost::Core::DoRequestConfig,
                     core_.get(),
                     types_to_config,
                     pending_download_state_->reason));
   }
 
   pending_config_mode_state_.reset();
 
@@ skipping 40 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshEncryption,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync