[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/engine/syncer_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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 126 matching lines @@
   }
 
   // ModelSafeWorkerRegistrar implementation.
   virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) OVERRIDE {
     out->push_back(worker_.get());
   }
 
   virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) OVERRIDE {
     // We're just testing the sync engine here, so we shunt everything to
     // the SyncerThread.  Datatypes which aren't enabled aren't in the map.
-    for (syncable::ModelEnumSet::Iterator it = enabled_datatypes_.First();
+    for (syncable::ModelTypeSet::Iterator it = enabled_datatypes_.First();
          it.Good(); it.Inc()) {
       (*out)[it.Get()] = GROUP_PASSIVE;
     }
   }
 
   virtual void OnSyncEngineEvent(const SyncEngineEvent& event) OVERRIDE {
     DVLOG(1) << "HandleSyncEngineEvent in unittest " << event.what_happened;
     // we only test for entry-specific events, not status changed ones.
     switch (event.what_happened) {
       case SyncEngineEvent::STATUS_CHANGED:
@@ skipping 205 matching lines @@
       StatusController* status = session_->mutable_status_controller();
       WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
       ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
       status->set_unsynced_handles(unsynced_handle_view);
 
       ModelSafeRoutingInfo routes;
       GetModelSafeRoutingInfo(&routes);
       GetCommitIdsCommand command(limit);
       command.BuildCommitIds(
           session_->status_controller().unsynced_handles(),
-          session_->write_transaction(), routes, syncable::ModelEnumSet());
+          session_->write_transaction(), routes, syncable::ModelTypeSet());
       vector<syncable::Id> output =
           command.ordered_commit_set_->GetAllCommitIds();
       size_t truncated_size = std::min(limit, expected_id_order.size());
       ASSERT_TRUE(truncated_size == output.size());
       for (size_t i = 0; i < truncated_size; ++i) {
         ASSERT_TRUE(expected_id_order[i] == output[i])
             << "At index " << i << " with batch size limited to " << limit;
       }
       sessions::OrderedCommitSet::Projection proj;
       proj = command.ordered_commit_set_->GetCommitIdProjection(GROUP_PASSIVE);
@@ skipping 104 matching lines @@
   Syncer* syncer_;
 
   scoped_ptr<SyncSession> session_;
   scoped_ptr<SyncSessionContext> context_;
   bool saw_syncer_event_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
   base::TimeDelta last_sessions_commit_delay_seconds_;
   scoped_refptr<ModelSafeWorker> worker_;
 
-  syncable::ModelEnumSet enabled_datatypes_;
+  syncable::ModelTypeSet enabled_datatypes_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
     Syncer::UnsyncedMetaHandles handles;
     {
@@ skipping 42 matching lines @@
   expected_order.push_back(ids_.MakeLocal("x"));
   expected_order.push_back(ids_.MakeLocal("b"));
   expected_order.push_back(ids_.MakeLocal("c"));
   expected_order.push_back(ids_.MakeLocal("e"));
   DoTruncationTest(dir, unsynced_handle_view, expected_order);
 }
 
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
-  const syncable::ModelEnumSet throttled_types(syncable::BOOKMARKS);
+  const syncable::ModelTypeSet throttled_types(syncable::BOOKMARKS);
   KeyParams key_params = {"localhost", "dummy", "foobar"};
   sync_pb::EntitySpecifics bookmark_data;
   AddDefaultExtensionValue(syncable::BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   SyncShareAsDelegate();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
@@ skipping 277 matching lines @@
 
     MutableEntry parent2(&wtrans, syncable::CREATE, wtrans.root_id(), "Tim");
     ASSERT_TRUE(parent2.good());
     parent2.Put(syncable::IS_UNSYNCED, true);
     parent2.Put(syncable::IS_DIR, true);
     parent2.Put(syncable::SPECIFICS, DefaultPreferencesSpecifics());
     parent2.Put(syncable::BASE_VERSION, 1);
     parent2.Put(syncable::ID, pref_node_id);
   }
 
-  dir->PurgeEntriesWithTypeIn(syncable::ModelEnumSet(syncable::PREFERENCES));
+  dir->PurgeEntriesWithTypeIn(syncable::ModelTypeSet(syncable::PREFERENCES));
 
   const StatusController& status = session_->status_controller();
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   EXPECT_EQ(2U, status.unsynced_handles().size());
   ASSERT_EQ(2U, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     ReadTransaction rt(FROM_HERE, dir);
@@ skipping 17 matching lines @@
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
   }
 
-  dir->PurgeEntriesWithTypeIn(syncable::ModelEnumSet(syncable::BOOKMARKS));
+  dir->PurgeEntriesWithTypeIn(syncable::ModelTypeSet(syncable::BOOKMARKS));
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   dir->SaveChanges();
   {
     ReadTransaction rt(FROM_HERE, dir);
     Entry entry(&rt, syncable::GET_BY_ID, parent_id_);
     ASSERT_FALSE(entry.good());
   }
 }
 
@@ skipping 1241 matching lines @@
   SyncShareAsDelegate();
   {
     ReadTransaction trans(FROM_HERE, dir);
     Entry entry(&trans, syncable::GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(MTIME) == test_time);
   }
 }
 
 TEST_F(SyncerTest, ParentAndChildBothMatch) {
-  const syncable::FullModelEnumSet all_types =
-      syncable::FullModelEnumSet::All();
+  const syncable::FullModelTypeSet all_types =
+      syncable::FullModelTypeSet::All();
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id child_id = ids_.NewServerId();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir);
     MutableEntry parent(&wtrans, CREATE, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
@@ skipping 3180 matching lines @@
   Add(low_id_);
   Add(high_id_);
   SyncShareAsDelegate();
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync