[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/engine/sync_scheduler_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 "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 14 matching lines @@
 using testing::Eq;
 using testing::Invoke;
 using testing::Mock;
 using testing::Return;
 using testing::WithArg;
 
 namespace browser_sync {
 using sessions::SyncSession;
 using sessions::SyncSessionContext;
 using sessions::SyncSessionSnapshot;
-using syncable::ModelEnumSet;
+using syncable::ModelTypeSet;
 using sync_pb::GetUpdatesCallerInfo;
 
 class MockSyncer : public Syncer {
  public:
   MOCK_METHOD3(SyncShare, void(sessions::SyncSession*, SyncerStep,
                                SyncerStep));
 };
 
 // Used when tests want to record syncing activity to examine later.
 struct SyncShareRecords {
@@ skipping 97 matching lines @@
   }
 
   // This stops the scheduler synchronously.
   void StopSyncScheduler() {
     scheduler()->RequestStop(base::Bind(&SyncSchedulerTest::DoQuitLoopNow,
                              weak_ptr_factory_.GetWeakPtr()));
     RunLoop();
   }
 
   bool GetBackoffAndResetTest() {
-    ModelEnumSet nudge_types;
+    ModelTypeSet nudge_types;
     StartSyncScheduler(SyncScheduler::NORMAL_MODE);
     RunLoop();
 
     scheduler()->ScheduleNudge(
         zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
     RunLoop();
 
     bool backing_off = scheduler()->IsBackingOff();
     StopSyncScheduler();
 
     syncdb_.TearDown();
 
     Mock::VerifyAndClearExpectations(syncer());
 
     TearDown();
     SetUp();
     UseMockDelayProvider();
     EXPECT_CALL(*delay(), GetDelay(_))
         .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
     return backing_off;
   }
 
   void UseMockDelayProvider() {
     delay_ = new MockDelayProvider();
     scheduler_->delay_provider_.reset(delay_);
   }
 
-  // Compare a ModelEnumSet to a ModelTypePayloadMap, ignoring
+  // Compare a ModelTypeSet to a ModelTypePayloadMap, ignoring
   // payload values.
-  bool CompareModelEnumSetToModelTypePayloadMap(
-      ModelEnumSet lhs,
+  bool CompareModelTypeSetToModelTypePayloadMap(
+      ModelTypeSet lhs,
       const syncable::ModelTypePayloadMap& rhs) {
     size_t count = 0;
     for (syncable::ModelTypePayloadMap::const_iterator i = rhs.begin();
          i != rhs.end(); ++i, ++count) {
       if (!lhs.Has(i->first))
         return false;
     }
     if (lhs.Size() != count)
       return false;
     return true;
@@ skipping 37 matching lines @@
   QuitLoopNow();
 }
 
 ACTION(QuitLoopNowAction) {
   QuitLoopNow();
 }
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, Nudge) {
   SyncShareRecords records;
-  ModelEnumSet model_types(syncable::BOOKMARKS);
+  ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[0]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records.snapshots[0]->source.updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareRecords records2;
   model_types.Remove(syncable::BOOKMARKS);
   model_types.Put(syncable::AUTOFILL);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records2.snapshots[0]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records2.snapshots[0]->source.updates_source);
 }
 
 // Make sure a regular config command is scheduled fine in the absence of any
 // errors.
 TEST_F(SyncSchedulerTest, Config) {
   SyncShareRecords records;
-  const ModelEnumSet model_types(syncable::BOOKMARKS);
+  const ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[0]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[0]->source.updates_source);
 }
 
 // Simulate a failure and make sure the config request is retried.
 TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
   SyncShareRecords records;
-  const ModelEnumSet model_types(syncable::BOOKMARKS);
+  const ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
   scheduler()->ScheduleConfig(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[1]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION,
             records.snapshots[1]->source.updates_source);
 }
 
 // Issue 2 config commands. Second one right after the first has failed
 // and make sure LATEST is executed.
 TEST_F(SyncSchedulerTest, MultipleConfigWithBackingOff) {
-  const ModelEnumSet
+  const ModelTypeSet
       model_types1(syncable::BOOKMARKS),
       model_types2(syncable::AUTOFILL);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(30)));
   SyncShareRecords records;
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
@@ skipping 12 matching lines @@
 
   ASSERT_EQ(1U, records.snapshots.size());
   scheduler()->ScheduleConfig(
       model_types2, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(3U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types2,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types2,
       records.snapshots[2]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[2]->source.updates_source);
 }
 
 // Issue a nudge when the config has failed. Make sure both the config and
 // nudge are executed.
 TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
-  const ModelEnumSet model_types(syncable::BOOKMARKS);
+  const ModelTypeSet model_types(syncable::BOOKMARKS);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(50)));
   SyncShareRecords records;
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
@@ skipping 18 matching lines @@
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
   // Now change the mode so nudge can execute.
   ASSERT_EQ(3U, records.snapshots.size());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   ASSERT_EQ(4U, records.snapshots.size());
 
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[2]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION,
             records.snapshots[2]->source.updates_source);
 
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[3]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records.snapshots[3]->source.updates_source);
 
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
-  const ModelEnumSet
+  const ModelTypeSet
       types1(syncable::BOOKMARKS),
       types2(syncable::AUTOFILL),
       types3(syncable::THEMES);
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
   scheduler()->ScheduleNudge(
       delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(
       Union(types1, types2), r.snapshots[0]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             r.snapshots[0]->source.updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   SyncShareRecords r2;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r2))));
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(types3,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(types3,
       r2.snapshots[0]->source.types));
   EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
             r2.snapshots[0]->source.updates_source);
 }
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, NudgeWithPayloads) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
@@ skipping 161 matching lines @@
                   sessions::test_util::SimulateSessionsCommitDelayUpdate(
                       delay2)),
               Invoke(sessions::test_util::SimulateSuccess),
               QuitLoopNowAction()));
 
   EXPECT_EQ(delay1, scheduler()->sessions_commit_delay());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   EXPECT_EQ(delay1, scheduler()->sessions_commit_delay());
-  const ModelEnumSet model_types(syncable::BOOKMARKS);
+  const ModelTypeSet model_types(syncable::BOOKMARKS);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   EXPECT_EQ(delay2, scheduler()->sessions_commit_delay());
   StopSyncScheduler();
 }
 
 // Test that a sync session is run through to completion.
 TEST_F(SyncSchedulerTest, HasMoreToSync) {
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(Invoke(sessions::test_util::SimulateHasMoreToSync))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       QuitLoopNowAction()));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
-      zero(), NUDGE_SOURCE_LOCAL, ModelEnumSet(), FROM_HERE);
+      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   RunLoop();
   // If more nudges are scheduled, they'll be waited on by TearDown, and would
   // cause our expectation to break.
 }
 
 // Test that no syncing occurs when throttled.
 TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
-  const ModelEnumSet types(syncable::BOOKMARKS);
+  const ModelTypeSet types(syncable::BOOKMARKS);
   TimeDelta poll(TimeDelta::FromMilliseconds(5));
   TimeDelta throttle(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(WithArg<0>(sessions::test_util::SimulateThrottled(throttle)))
       .WillRepeatedly(AddFailureAndQuitLoopNow());
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
@@ skipping 40 matching lines @@
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   SyncShareRecords records;
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce((Invoke(sessions::test_util::SimulateSuccess),
            WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
-  const ModelEnumSet nudge_types(syncable::AUTOFILL);
+  const ModelTypeSet nudge_types(syncable::AUTOFILL);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
   scheduler()->ScheduleNudge(
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
 
-  const ModelEnumSet config_types(syncable::BOOKMARKS);
+  const ModelTypeSet config_types(syncable::BOOKMARKS);
 
   scheduler()->ScheduleConfig(
       config_types, GetUpdatesCallerInfo::RECONFIGURATION);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelEnumSetToModelTypePayloadMap(config_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(config_types,
       records.snapshots[0]->source.types));
 }
 
 // Test that exponential backoff is properly triggered.
 TEST_F(SyncSchedulerTest, BackoffTriggers) {
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(Invoke(sessions::test_util::SimulateDownloadUpdatesFailed))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
@@ skipping 27 matching lines @@
       .WillOnce(Invoke(sessions::test_util::SimulateCommitFailed))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                             QuitLoopNowAction()));
   EXPECT_FALSE(GetBackoffAndResetTest());
 }
 
 // Test that no polls or extraneous nudges occur when in backoff.
 TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
   SyncShareRecords r;
   TimeDelta poll(TimeDelta::FromMilliseconds(5));
-  const ModelEnumSet types(syncable::BOOKMARKS);
+  const ModelTypeSet types(syncable::BOOKMARKS);
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(2)
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
           RecordSyncShareMultiple(&r, 2U)));
   EXPECT_CALL(*delay(), GetDelay(_)).
       WillRepeatedly(Return(TimeDelta::FromDays(1)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ skipping 143 matching lines @@
 
 // Test that appropriate syncer steps are requested for each job type.
 TEST_F(SyncSchedulerTest, SyncerSteps) {
   // Nudges.
   EXPECT_CALL(*syncer(), SyncShare(_, SYNCER_BEGIN, SYNCER_END))
       .Times(1);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
-      zero(), NUDGE_SOURCE_LOCAL, ModelEnumSet(), FROM_HERE);
+      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // ClearUserData.
   EXPECT_CALL(*syncer(), SyncShare(_, CLEAR_PRIVATE_DATA, CLEAR_PRIVATE_DATA))
       .Times(1);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleClearUserData();
   PumpLoop();
   PumpLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Configuration.
   EXPECT_CALL(*syncer(), SyncShare(_, DOWNLOAD_UPDATES, APPLY_UPDATES));
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   RunLoop();
 
   scheduler()->ScheduleConfig(
-      ModelEnumSet(), GetUpdatesCallerInfo::RECONFIGURATION);
+      ModelTypeSet(), GetUpdatesCallerInfo::RECONFIGURATION);
   PumpLoop();
   PumpLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Cleanup disabled types.
   EXPECT_CALL(*syncer(),
               SyncShare(_, CLEANUP_DISABLED_TYPES, CLEANUP_DISABLED_TYPES));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ skipping 31 matching lines @@
 
 // Test that starting the syncer thread without a valid connection doesn't
 // break things when a connection is detected.
 TEST_F(SyncSchedulerTest, StartWhenNotConnected) {
   connection()->SetServerNotReachable();
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).WillOnce(QuitLoopNowAction());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
-      zero(), NUDGE_SOURCE_LOCAL, ModelEnumSet(), FROM_HERE);
+      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   // Should save the nudge for until after the server is reachable.
   PumpLoop();
 
   connection()->SetServerReachable();
   PumpLoop();
 }
 
 TEST_F(SyncSchedulerTest, SetsPreviousRoutingInfo) {
   ModelSafeRoutingInfo info;
   EXPECT_TRUE(info == context()->previous_session_routing_info());
   ModelSafeRoutingInfo expected;
   context()->registrar()->GetModelSafeRoutingInfo(&expected);
   ASSERT_FALSE(expected.empty());
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(1);
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   RunLoop();
 
   scheduler()->ScheduleNudge(
-      zero(), NUDGE_SOURCE_LOCAL, ModelEnumSet(), FROM_HERE);
+      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
 
   EXPECT_TRUE(expected == context()->previous_session_routing_info());
 }
 
 }  // namespace browser_sync