[Sync] Rename ModelEnumSet to ModelTypeSet

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(ModelEnumSet types_to_purge,
+  void CheckPurgeEntriesWithTypeInSucceeded(ModelTypeSet 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);
         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.";
         }
       }
     }
 
-    for (ModelEnumSet::Iterator it = types_to_purge.First();
+    for (ModelTypeSet::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_;
@@ skipping 40 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);
     }
   }
 
-  syncable::ModelEnumSet to_purge(BOOKMARKS);
+  syncable::ModelTypeSet 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.Put(PREFERENCES);
   dir_->PurgeEntriesWithTypeIn(to_purge);
@@ skipping 69 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);
 
-  syncable::ModelEnumSet types_to_purge(PREFERENCES, AUTOFILL);
+  syncable::ModelTypeSet 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 241 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     dir_->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_TRUE(1 == handles.size());
     ASSERT_TRUE(handle2 == handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnappliedUpdates) {
   Directory::UnappliedUpdateMetaHandles handles;
   int64 handle1, handle2;
-  const syncable::FullModelEnumSet all_types =
-      syncable::FullModelEnumSet::All();
+  const syncable::FullModelTypeSet all_types =
+      syncable::FullModelTypeSet::All();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
 
     dir_->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_TRUE(0 == handles.size());
 
     MutableEntry e1(&trans, CREATE, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.Get(META_HANDLE);
     e1.Put(IS_UNAPPLIED_UPDATE, false);
@@ skipping 472 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());
 
-  syncable::ModelEnumSet set(BOOKMARKS);
+  syncable::ModelTypeSet 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