[Sync] Convert syncable/ directory to ModelEnumSet

chrome/browser/sync/syncable/syncable_unittest.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/syncable/syncable.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 428 matching lines @@
   }
 
   bool IsInDirtyMetahandles(int64 metahandle) {
     return 1 == dir_->kernel_->dirty_metahandles->count(metahandle);
   }
 
   bool IsInMetahandlesToPurge(int64 metahandle) {
     return 1 == dir_->kernel_->metahandles_to_purge->count(metahandle);
   }
 
-  void CheckPurgeEntriesWithTypeInSucceeded(const ModelTypeSet& types_to_purge,
+  void CheckPurgeEntriesWithTypeInSucceeded(ModelEnumSet types_to_purge,
                                             bool before_reload) {
     SCOPED_TRACE(testing::Message("Before reload: ") << before_reload);
     {
       ReadTransaction trans(FROM_HERE, dir_.get());
       MetahandleSet all_set;
       dir_->GetAllMetaHandles(&trans, &all_set);
       EXPECT_EQ(3U, all_set.size());
       if (before_reload)
         EXPECT_EQ(4U, dir_->kernel_->metahandles_to_purge->size());
       for (MetahandleSet::iterator iter = all_set.begin();
            iter != all_set.end(); ++iter) {
         Entry e(&trans, GET_BY_HANDLE, *iter);
-        if ((types_to_purge.count(e.GetModelType()) ||
-             types_to_purge.count(e.GetServerModelType()))) {
+        const ModelType local_type = e.GetModelType();
+        const ModelType server_type = e.GetServerModelType();
+
+        // Note the dance around incrementing |it|, since we sometimes erase().
+        if ((IsRealDataType(local_type) &&
+             types_to_purge.Has(local_type)) ||
+            (IsRealDataType(server_type) &&
+             types_to_purge.Has(server_type))) {
           FAIL() << "Illegal type should have been deleted.";
         }
       }
     }
 
-    EXPECT_FALSE(dir_->initial_sync_ended_for_type(PREFERENCES));
-    EXPECT_FALSE(dir_->initial_sync_ended_for_type(AUTOFILL));
+    for (ModelEnumSet::Iterator it = types_to_purge.First();
+         it.Good(); it.Inc()) {
+      EXPECT_FALSE(dir_->initial_sync_ended_for_type(it.Get()));
+    }
+    EXPECT_FALSE(types_to_purge.Has(BOOKMARKS));
     EXPECT_TRUE(dir_->initial_sync_ended_for_type(BOOKMARKS));
   }
 
   scoped_ptr<Directory> dir_;
   FilePath file_path_;
   NullDirectoryChangeDelegate delegate_;
 
   // Creates an empty entry and sets the ID field to the default kId.
   void CreateEntry(const std::string& entryname) {
     CreateEntry(entryname, kId);
@@ skipping 36 matching lines @@
         all_handles.insert(e.Get(META_HANDLE));
       } else {
         AddDefaultExtensionValue(PREFERENCES, &specs);
         all_handles.insert(e.Get(META_HANDLE));
       }
       e.Put(SPECIFICS, specs);
       e.Put(SERVER_SPECIFICS, specs);
     }
   }
 
-  ModelTypeSet to_purge;
-  to_purge.insert(BOOKMARKS);
+  syncable::ModelEnumSet to_purge(BOOKMARKS);
   dir_->PurgeEntriesWithTypeIn(to_purge);
 
   Directory::SaveChangesSnapshot snapshot1;
   base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
   dir_->TakeSnapshotForSaveChanges(&snapshot1);
   EXPECT_TRUE(expected_purges == snapshot1.metahandles_to_purge);
 
-  to_purge.clear();
-  to_purge.insert(PREFERENCES);
+  to_purge.Clear();
+  to_purge.Put(PREFERENCES);
   dir_->PurgeEntriesWithTypeIn(to_purge);
 
   dir_->HandleSaveChangesFailure(snapshot1);
 
   Directory::SaveChangesSnapshot snapshot2;
   dir_->TakeSnapshotForSaveChanges(&snapshot2);
   EXPECT_TRUE(all_handles == snapshot2.metahandles_to_purge);
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest) {
@@ skipping 60 matching lines @@
   sync_pb::EntitySpecifics bookmark_specs;
   sync_pb::EntitySpecifics autofill_specs;
   sync_pb::EntitySpecifics preference_specs;
   AddDefaultExtensionValue(BOOKMARKS, &bookmark_specs);
   AddDefaultExtensionValue(PREFERENCES, &preference_specs);
   AddDefaultExtensionValue(AUTOFILL, &autofill_specs);
   dir_->set_initial_sync_ended_for_type(BOOKMARKS, true);
   dir_->set_initial_sync_ended_for_type(PREFERENCES, true);
   dir_->set_initial_sync_ended_for_type(AUTOFILL, true);
 
-  std::set<ModelType> types_to_purge;
-  types_to_purge.insert(PREFERENCES);
-  types_to_purge.insert(AUTOFILL);
+  syncable::ModelEnumSet types_to_purge(PREFERENCES, AUTOFILL);
 
   TestIdFactory id_factory;
   // Create some items for each type.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     MutableEntry item1(&trans, CREATE, trans.root_id(), "Item");
     ASSERT_TRUE(item1.good());
     item1.Put(SPECIFICS, bookmark_specs);
     item1.Put(SERVER_SPECIFICS, bookmark_specs);
     item1.Put(IS_UNSYNCED, true);
@@ skipping 735 matching lines @@
   ASSERT_TRUE(dir_->SaveChanges());
 
   // Now do some operations using a directory for which SaveChanges will
   // always fail.
   dir_.reset(new TestUnsaveableDirectory());
   ASSERT_TRUE(dir_.get());
   ASSERT_EQ(OPENED, dir_->Open(file_path_, kName,
                                &delegate_, NullTransactionObserver()));
   ASSERT_TRUE(dir_->good());
 
-  ModelTypeSet set;
-  set.insert(BOOKMARKS);
+  syncable::ModelEnumSet set(BOOKMARKS);
   dir_->PurgeEntriesWithTypeIn(set);
   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
   ASSERT_FALSE(dir_->SaveChanges());
   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
 }
 
 // Create items of each model type, and check that GetModelType and
 // GetServerModelType return the right value.
 TEST_F(SyncableDirectoryTest, GetModelType) {
   TestIdFactory id_factory;
@@ skipping 504 matching lines @@
 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable