[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

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,
-    const syncable::ModelTypeSet& initial_types,
+    syncable::ModelEnumSet initial_types,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder) {
   if (!sync_thread_.Start())
     return;
 
   frontend_ = frontend;
   DCHECK(frontend);
 
-  syncable::ModelTypeSet initial_types_with_nigori(initial_types);
+  syncable::ModelEnumSet initial_types_with_nigori(initial_types);
   CHECK(sync_prefs_.get());
   if (sync_prefs_->HasSyncSetupCompleted()) {
-    initial_types_with_nigori.insert(syncable::NIGORI);
+    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;
   InitCore(Core::DoInitializeOptions(
       sync_thread_.message_loop(),
       registrar_.get(),
@@ skipping 112 matching lines @@
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     sync_thread_.Stop();
   }
 
   registrar_.reset();
   frontend_ = NULL;
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
-    const syncable::ModelTypeSet& types_to_add,
-    const syncable::ModelTypeSet& types_to_remove,
+    syncable::ModelEnumSet types_to_add,
+    syncable::ModelEnumSet types_to_remove,
     sync_api::ConfigureReason reason,
     base::Callback<void(syncable::ModelEnumSet)> ready_task,
     bool enable_nigori) {
-  syncable::ModelTypeSet types_to_add_with_nigori = types_to_add;
-  syncable::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
+  syncable::ModelEnumSet types_to_add_with_nigori = types_to_add;
+  syncable::ModelEnumSet types_to_remove_with_nigori = types_to_remove;
   if (enable_nigori) {
-    types_to_add_with_nigori.insert(syncable::NIGORI);
-    types_to_remove_with_nigori.erase(syncable::NIGORI);
+    types_to_add_with_nigori.Put(syncable::NIGORI);
+    types_to_remove_with_nigori.Remove(syncable::NIGORI);
   } else {
-    types_to_add_with_nigori.erase(syncable::NIGORI);
-    types_to_remove_with_nigori.insert(syncable::NIGORI);
+    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());
   DCHECK_GT(initialization_state_, NOT_INITIALIZED);
 
   pending_config_mode_state_.reset(new PendingConfigureDataTypesState());
   pending_config_mode_state_->ready_task = ready_task;
   pending_config_mode_state_->types_to_add = types_to_add_with_nigori;
   pending_config_mode_state_->added_types =
       registrar_->ConfigureDataTypes(types_to_add_with_nigori,
                                      types_to_remove_with_nigori);
   pending_config_mode_state_->reason = reason;
 
   // Cleanup disabled types before starting configuration so that
   // callers can assume that the data types are cleaned up once
   // configuration is done.
-  if (!types_to_remove_with_nigori.empty()) {
+  if (!types_to_remove_with_nigori.Empty()) {
     sync_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&SyncBackendHost::Core::DoRequestCleanupDisabledTypes,
                    core_.get()));
   }
 
   StartConfiguration(
       base::Bind(&SyncBackendHost::Core::FinishConfigureDataTypes,
                  core_.get()));
 }
@@ skipping 184 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(
-    const syncable::ModelTypeSet& encrypted_types,
+    syncable::ModelEnumSet 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 291 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(
-    const syncable::ModelTypeSet& encrypted_types,
+    syncable::ModelEnumSet 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 =
       snapshot->syncer_status.types_needing_local_migration;
   if (!to_migrate.Empty())
-    host_->frontend_->OnMigrationNeededForTypes(
-        syncable::ModelEnumSetToSet(to_migrate));
+    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 =
-        syncable::ModelTypeSetToEnumSet(state->types_to_add);
-    const syncable::ModelEnumSet added_types =
-        syncable::ModelTypeSetToEnumSet(state->added_types);
+    const syncable::ModelEnumSet types_to_add = state->types_to_add;
+    const syncable::ModelEnumSet added_types = state->added_types;
     DCHECK(types_to_add.HasAll(added_types));
     const syncable::ModelEnumSet initial_sync_ended =
         snapshot->initial_sync_ended;
     const syncable::ModelEnumSet failed_configuration_types =
         Difference(added_types, initial_sync_ended);
     SVLOG(1)
         << "Added types: "
         << syncable::ModelEnumSetToString(added_types)
         << ", configured types: "
         << syncable::ModelEnumSetToString(initial_sync_ended)
@@ skipping 25 matching lines @@
     return;
   host_->frontend_->OnClearServerDataFailed();
 }
 
 void SyncBackendHost::Core::FinishConfigureDataTypesOnFrontendLoop() {
   host_->FinishConfigureDataTypesOnFrontendLoop();
 }
 
 void SyncBackendHost::AddExperimentalTypes() {
   CHECK(initialized());
-  syncable::ModelTypeSet to_add;
+  syncable::ModelEnumSet 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::ModelTypeSet(),
-          syncable::ModelTypeSet(),
+          syncable::ModelEnumSet(),
+          syncable::ModelEnumSet(),
           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 33 matching lines @@
   //
   // In the case of additions, on the next sync cycle, the syncer should
   // notice that the routing info has changed and start the process of
   // 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() &&
+  if (pending_config_mode_state_->added_types.Empty() &&
       !core_->sync_manager()->InitialSyncEndedForAllEnabledTypes()) {
 
-    syncable::ModelTypeSet enabled_types;
+    syncable::ModelEnumSet enabled_types;
     ModelSafeRoutingInfo routing_info;
     registrar_->GetModelSafeRoutingInfo(&routing_info);
     for (ModelSafeRoutingInfo::const_iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
-      enabled_types.insert(i->first);
+      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()) {
+  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;
     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::ModelTypeSetToEnumSet(
-            pending_download_state_->added_types);
+        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)
@@ skipping 50 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshEncryption,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync