[Sync] Convert sessions/ directory to 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 232 matching lines @@
 
   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,
     sync_api::ConfigureReason reason,
-    base::Callback<void(const syncable::ModelTypeSet&)> ready_task,
+    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;
   if (enable_nigori) {
     types_to_add_with_nigori.insert(syncable::NIGORI);
     types_to_remove_with_nigori.erase(syncable::NIGORI);
   } else {
     types_to_add_with_nigori.erase(syncable::NIGORI);
     types_to_remove_with_nigori.insert(syncable::NIGORI);
   }
@@ skipping 449 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::ModelTypeSet& failed_configuration_types) {
+    const syncable::ModelEnumSet failed_configuration_types) {
   if (!host_)
     return;
   host_->HandleInitializationCompletedOnFrontendLoop(
-      js_backend, failed_configuration_types.empty());
+      js_backend, failed_configuration_types.Empty());
 }
 
 void SyncBackendHost::Core::StartSavingChanges() {
   // We may already be shut down.
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   save_changes_timer_.Start(FROM_HERE,
       base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &Core::SaveChanges);
@@ skipping 75 matching lines @@
 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::ModelTypeSet& to_migrate =
+  const syncable::ModelEnumSet to_migrate =
       snapshot->syncer_status.types_needing_local_migration;
-  if (!to_migrate.empty())
-    host_->frontend_->OnMigrationNeededForTypes(to_migrate);
+  if (!to_migrate.Empty())
+    host_->frontend_->OnMigrationNeededForTypes(
+        syncable::ModelEnumSetToSet(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());
-    DCHECK(
-        std::includes(state->types_to_add.begin(), state->types_to_add.end(),
-                      state->added_types.begin(), state->added_types.end()));
-    syncable::ModelTypeSet initial_sync_ended =
-        syncable::ModelTypeBitSetToSet(snapshot->initial_sync_ended);
-    syncable::ModelTypeSet failed_configuration_types;
-    std::set_difference(
-        state->added_types.begin(), state->added_types.end(),
-        initial_sync_ended.begin(), initial_sync_ended.end(),
-        std::inserter(failed_configuration_types,
-                      failed_configuration_types.end()));
+    const syncable::ModelEnumSet types_to_add =
+        syncable::ModelTypeSetToEnumSet(state->types_to_add);
+    const syncable::ModelEnumSet added_types =
+        syncable::ModelTypeSetToEnumSet(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::ModelTypeSetToString(state->added_types)
+        << syncable::ModelEnumSetToString(added_types)
         << ", configured types: "
-        << syncable::ModelTypeSetToString(initial_sync_ended)
+        << syncable::ModelEnumSetToString(initial_sync_ended)
         << ", failed configuration types: "
-        << syncable::ModelTypeSetToString(failed_configuration_types);
+        << syncable::ModelEnumSetToString(failed_configuration_types);
     state->ready_task.Run(failed_configuration_types);
-    if (!failed_configuration_types.empty())
+    if (!failed_configuration_types.Empty())
       return;
   }
 
   if (host_->initialized())
     host_->frontend_->OnSyncCycleCompleted();
 }
 
 void SyncBackendHost::Core::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!host_ || !host_->frontend_)
     return;
@@ skipping 130 matching lines @@
     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::ModelTypeSet failed_configuration_types;
+    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::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
@@ skipping 56 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshEncryption,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync