[Sync] Convert syncable/ directory to ModelEnumSet

chrome/browser/sync/test/integration/migration_errors_test.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.
 
 // TODO(akalin): Rename this file to migration_test.cc.
 
 #include "base/compiler_specific.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/bookmarks_helper.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "chrome/browser/sync/test/integration/preferences_helper.h"
 #include "chrome/browser/translate/translate_prefs.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/ui_test_utils.h"
 
 using bookmarks_helper::AddURL;
 using bookmarks_helper::IndexedURL;
 using bookmarks_helper::IndexedURLTitle;
 
 using preferences_helper::BooleanPrefMatches;
 using preferences_helper::ChangeBooleanPref;
 
 namespace {
 
 // Utility functions to make a model type set out of a small number of
 // model types.
 
-syncable::ModelTypeSet MakeSet(syncable::ModelType type) {
-  syncable::ModelTypeSet model_types;
-  model_types.insert(type);
-  return model_types;
+syncable::ModelEnumSet MakeSet(syncable::ModelType type) {
+  return syncable::ModelEnumSet(type);
 }
 
-syncable::ModelTypeSet MakeSet(syncable::ModelType type1,
+syncable::ModelEnumSet MakeSet(syncable::ModelType type1,
                                syncable::ModelType type2) {
-  syncable::ModelTypeSet model_types;
-  model_types.insert(type1);
-  model_types.insert(type2);
-  return model_types;
+  return syncable::ModelEnumSet(type1, type2);
 }
 
 // An ordered list of model types sets to migrate.  Used by
 // RunMigrationTest().
-typedef std::deque<syncable::ModelTypeSet> MigrationList;
+typedef std::deque<syncable::ModelEnumSet> MigrationList;
 
 // Utility functions to make a MigrationList out of a small number of
 // model types / model type sets.
 
-MigrationList MakeList(const syncable::ModelTypeSet& model_types) {
+MigrationList MakeList(syncable::ModelEnumSet model_types) {
   return MigrationList(1, model_types);
 }
 
-MigrationList MakeList(const syncable::ModelTypeSet& model_types1,
-                       const syncable::ModelTypeSet& model_types2) {
+MigrationList MakeList(syncable::ModelEnumSet model_types1,
+                       syncable::ModelEnumSet model_types2) {
   MigrationList migration_list;
   migration_list.push_back(model_types1);
   migration_list.push_back(model_types2);
   return migration_list;
 }
 
 MigrationList MakeList(syncable::ModelType type) {
   return MakeList(MakeSet(type));
 }
 
 MigrationList MakeList(syncable::ModelType type1,
                        syncable::ModelType type2) {
   return MakeList(MakeSet(type1), MakeSet(type2));
 }
 
 class MigrationTest : public SyncTest {
  public:
   explicit MigrationTest(TestType test_type) : SyncTest(test_type) {}
   virtual ~MigrationTest() {}
 
   // TODO(akalin): Add more MODIFY_(data type) trigger methods, as
   // well as a poll-based trigger method.
   enum TriggerMethod { MODIFY_PREF, MODIFY_BOOKMARK, TRIGGER_NOTIFICATION };
 
-  syncable::ModelTypeSet GetPreferredDataTypes() {
+  syncable::ModelEnumSet GetPreferredDataTypes() {
     syncable::ModelTypeSet preferred_data_types;
     GetClient(0)->service()->GetPreferredDataTypes(&preferred_data_types);
     // Make sure all clients have the same preferred data types.
     for (int i = 1; i < num_clients(); ++i) {
       syncable::ModelTypeSet other_preferred_data_types;
       GetClient(i)->service()->GetPreferredDataTypes(
           &other_preferred_data_types);
       EXPECT_EQ(preferred_data_types, other_preferred_data_types);
     }
-    return preferred_data_types;
+    return syncable::ModelTypeSetToEnumSet(preferred_data_types);
   }
 
   // Returns a MigrationList with every enabled data type in its own
   // set.
   MigrationList GetPreferredDataTypesList() {
     MigrationList migration_list;
-    const syncable::ModelTypeSet& preferred_data_types =
+    const syncable::ModelEnumSet preferred_data_types =
         GetPreferredDataTypes();
-    for (syncable::ModelTypeSet::const_iterator it =
-             preferred_data_types.begin();
-         it != preferred_data_types.end(); ++it) {
-      migration_list.push_back(MakeSet(*it));
+    for (syncable::ModelEnumSet::Iterator it =
+             preferred_data_types.First(); it.Good(); it.Inc()) {
+      migration_list.push_back(MakeSet(it.Get()));
     }
     return migration_list;
   }
 
   // Trigger a migration for the given types with the given method.
-  void TriggerMigration(const syncable::ModelTypeSet& model_types,
+  void TriggerMigration(syncable::ModelEnumSet model_types,
                         TriggerMethod trigger_method) {
     switch (trigger_method) {
       case MODIFY_PREF:
         // Unlike MODIFY_BOOKMARK, MODIFY_PREF doesn't cause a
         // notification to happen (since model association on a
         // boolean pref clobbers the local value), so it doesn't work
         // for anything but single-client tests.
         ASSERT_EQ(1, num_clients());
         ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
         ChangeBooleanPref(0, prefs::kShowHomeButton);
         break;
       case MODIFY_BOOKMARK:
         ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))));
         break;
       case TRIGGER_NOTIFICATION:
         TriggerNotification(model_types);
         break;
       default:
         ADD_FAILURE();
     }
   }
 
   // Block until all clients have completed migration for the given
   // types.
-  void AwaitMigration(const syncable::ModelTypeSet& migrate_types) {
+  void AwaitMigration(syncable::ModelEnumSet migrate_types) {
+    const syncable::ModelTypeSet& migrate_types_set =
+        syncable::ModelEnumSetToSet(migrate_types);
     for (int i = 0; i < num_clients(); ++i) {
-      ASSERT_TRUE(GetClient(i)->AwaitMigration(migrate_types));
+      ASSERT_TRUE(GetClient(i)->AwaitMigration(migrate_types_set));
     }
   }
 
   bool ShouldRunMigrationTest() const {
     if (!ServerSupportsNotificationControl() ||
         !ServerSupportsErrorTriggering()) {
       LOG(WARNING) << "Test skipped in this server environment.";
       return false;
     }
     return true;
@@ skipping 146 matching lines @@
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
                        AllTypesWithNigoriIndividually) {
   ASSERT_TRUE(SetupClients());
   MigrationList migration_list = GetPreferredDataTypesList();
   migration_list.push_front(MakeSet(syncable::NIGORI));
   RunSingleClientMigrationTest(migration_list, MODIFY_BOOKMARK);
 }
 
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesWithNigoriAtOnce) {
   ASSERT_TRUE(SetupClients());
-  syncable::ModelTypeSet all_types = GetPreferredDataTypes();
-  all_types.insert(syncable::NIGORI);
+  syncable::ModelEnumSet all_types = GetPreferredDataTypes();
+  all_types.Put(syncable::NIGORI);
   RunSingleClientMigrationTest(MakeList(all_types), MODIFY_PREF);
 }
 
 class MigrationTwoClientTest : public MigrationTest {
  public:
   MigrationTwoClientTest() : MigrationTest(TWO_CLIENT) {}
   virtual ~MigrationTwoClientTest() {}
 
   // Helper function that verifies that preferences sync still works.
   void VerifyPrefSync() {
@@ skipping 56 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, MigrationHellWithNigori) {
   ASSERT_TRUE(SetupClients());
   MigrationList migration_list = GetPreferredDataTypesList();
   // Let the first nudge be a datatype that's neither prefs nor
   // bookmarks.
   migration_list.push_front(MakeSet(syncable::THEMES));
   // Pop off one so that we don't migrate all data types; the syncer
   // freaks out if we do that (see http://crbug.com/94882).
   ASSERT_GE(migration_list.size(), 2u);
-  ASSERT_NE(migration_list.back(), MakeSet(syncable::NIGORI));
+  ASSERT_FALSE(migration_list.back().Equals(MakeSet(syncable::NIGORI)));
   migration_list.back() = MakeSet(syncable::NIGORI);
   RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK);
 }
 
 class MigrationReconfigureTest : public MigrationTwoClientTest {
  public:
   MigrationReconfigureTest() {}
 
   virtual void SetUpCommandLine(CommandLine* cl) OVERRIDE {
     AddTestSwitches(cl);
@@ skipping 56 matching lines @@
 
   // Phase 5: Verify that preferences can still be synchronized.
   VerifyPrefSync();
 
   // Phase 6: Verify that sessions are registered and enabled.
   ASSERT_TRUE(GetClient(0)->IsTypeRunning(syncable::SESSIONS));
   ASSERT_TRUE(GetClient(0)->IsTypePreferred(syncable::SESSIONS));
 }
 
 }  // namespace