[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/internal_api/syncapi_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 56 matching lines @@
 using browser_sync::JsReplyHandler;
 using browser_sync::MockJsEventHandler;
 using browser_sync::MockJsReplyHandler;
 using browser_sync::ModelSafeRoutingInfo;
 using browser_sync::ModelSafeWorker;
 using browser_sync::ModelSafeWorkerRegistrar;
 using browser_sync::sessions::SyncSessionSnapshot;
 using browser_sync::WeakHandle;
 using content::BrowserThread;
 using syncable::kEncryptedString;
-using syncable::ModelEnumSet;
+using syncable::ModelTypeSet;
 using syncable::ModelType;
 using test::ExpectDictStringValue;
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::InSequence;
 using testing::Invoke;
 using testing::SaveArg;
 using testing::StrictMock;
 
@@ skipping 537 matching lines @@
                void(const WeakHandle<JsBackend>&, bool));  // NOLINT
   MOCK_METHOD1(OnAuthError, void(const GoogleServiceAuthError&));  // NOLINT
   MOCK_METHOD1(OnPassphraseRequired,
                void(sync_api::PassphraseRequiredReason));  // NOLINT
   MOCK_METHOD1(OnPassphraseAccepted, void(const std::string&));  // NOLINT
   MOCK_METHOD0(OnStopSyncingPermanently, void());  // NOLINT
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));  // NOLINT
   MOCK_METHOD0(OnClearServerDataFailed, void());  // NOLINT
   MOCK_METHOD0(OnClearServerDataSucceeded, void());  // NOLINT
   MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(ModelEnumSet, bool));  // NOLINT
+               void(ModelTypeSet, bool));  // NOLINT
   MOCK_METHOD0(OnEncryptionComplete, void());  // NOLINT
   MOCK_METHOD1(OnActionableError,
                  void(const browser_sync::SyncProtocolError&));  // NOLINT
 };
 
 class SyncNotifierMock : public sync_notifier::SyncNotifier {
  public:
   MOCK_METHOD1(AddObserver, void(sync_notifier::SyncNotifierObserver*));
   MOCK_METHOD1(RemoveObserver, void(sync_notifier::SyncNotifierObserver*));
   MOCK_METHOD1(SetUniqueId, void(const std::string&));
   MOCK_METHOD1(SetState, void(const std::string&));
   MOCK_METHOD2(UpdateCredentials,
                void(const std::string&, const std::string&));
   MOCK_METHOD1(UpdateEnabledTypes,
-               void(syncable::ModelEnumSet));
-  MOCK_METHOD1(SendNotification, void(syncable::ModelEnumSet));
+               void(syncable::ModelTypeSet));
+  MOCK_METHOD1(SendNotification, void(syncable::ModelTypeSet));
 };
 
 class SyncManagerTest : public testing::Test,
                         public ModelSafeWorkerRegistrar,
                         public SyncManager::ChangeDelegate {
  protected:
   SyncManagerTest()
       : ui_thread_(BrowserThread::UI, &ui_loop_),
         sync_notifier_mock_(NULL),
         sync_manager_("Test sync manager"),
@@ skipping 132 matching lines @@
     EXPECT_EQ(NULL, sync_notifier_observer_);
     sync_notifier_observer_ = sync_notifier_observer;
   }
 
   void SyncNotifierRemoveObserver(
       sync_notifier::SyncNotifierObserver* sync_notifier_observer) {
     EXPECT_EQ(sync_notifier_observer_, sync_notifier_observer);
     sync_notifier_observer_ = NULL;
   }
 
-  void SyncNotifierUpdateEnabledTypes(syncable::ModelEnumSet types) {
+  void SyncNotifierUpdateEnabledTypes(syncable::ModelTypeSet types) {
     ModelSafeRoutingInfo routes;
     GetModelSafeRoutingInfo(&routes);
-    const syncable::ModelEnumSet expected_types =
+    const syncable::ModelTypeSet expected_types =
         GetRoutingInfoTypes(routes);
     EXPECT_TRUE(types.Equals(expected_types));
     ++update_enabled_types_call_count_;
   }
 
   void PumpLoop() {
     ui_loop_.RunAllPending();
   }
 
   void SendJsMessage(const std::string& name, const JsArgList& args,
@@ skipping 29 matching lines @@
 };
 
 TEST_F(SyncManagerTest, UpdateEnabledTypes) {
   EXPECT_EQ(1, update_enabled_types_call_count_);
   // Triggers SyncNotifierUpdateEnabledTypes.
   sync_manager_.UpdateEnabledTypes();
   EXPECT_EQ(2, update_enabled_types_call_count_);
 }
 
 TEST_F(SyncManagerTest, DoNotSyncTabsInNigoriNode) {
-  const syncable::ModelEnumSet encrypted_types(syncable::TYPED_URLS);
+  const syncable::ModelTypeSet encrypted_types(syncable::TYPED_URLS);
   sync_manager_.MaybeSetSyncTabsInNigoriNode(encrypted_types);
 
   ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
   ReadNode node(&trans);
   ASSERT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
   EXPECT_FALSE(node.GetNigoriSpecifics().sync_tabs());
 }
 
 TEST_F(SyncManagerTest, SyncTabsInNigoriNode) {
-  const syncable::ModelEnumSet encrypted_types(syncable::SESSIONS);
+  const syncable::ModelTypeSet encrypted_types(syncable::SESSIONS);
   sync_manager_.MaybeSetSyncTabsInNigoriNode(encrypted_types);
 
   ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
   ReadNode node(&trans);
   ASSERT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
   EXPECT_TRUE(node.GetNigoriSpecifics().sync_tabs());
 }
 
 TEST_F(SyncManagerTest, ProcessJsMessage) {
   const JsArgList kNoArgs;
@@ skipping 273 matching lines @@
   sync_manager_.TriggerOnNotificationStateChangeForTest(true);
   sync_manager_.TriggerOnNotificationStateChangeForTest(false);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, OnIncomingNotification) {
   StrictMock<MockJsEventHandler> event_handler;
 
-  const syncable::ModelEnumSet empty_model_types;
-  const syncable::ModelEnumSet model_types(
+  const syncable::ModelTypeSet empty_model_types;
+  const syncable::ModelTypeSet model_types(
       syncable::BOOKMARKS, syncable::THEMES);
 
   // Build expected_args to have a single argument with the string
   // equivalents of model_types.
   DictionaryValue expected_details;
   {
     ListValue* model_type_list = new ListValue();
     expected_details.Set("changedTypes", model_type_list);
-    for (syncable::ModelEnumSet::Iterator it = model_types.First();
+    for (syncable::ModelTypeSet::Iterator it = model_types.First();
          it.Good(); it.Inc()) {
       model_type_list->Append(
           Value::CreateStringValue(
               syncable::ModelTypeToString(it.Get())));
     }
   }
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onIncomingNotification",
                            HasDetailsAsDictionary(expected_details)));
 
   sync_manager_.TriggerOnIncomingNotificationForTest(empty_model_types);
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
 
   SetJsEventHandler(event_handler.AsWeakHandle());
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
   SetJsEventHandler(WeakHandle<JsEventHandler>());
 
   sync_manager_.TriggerOnIncomingNotificationForTest(empty_model_types);
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, RefreshEncryptionReady) {
   EXPECT_TRUE(SetUpEncryption(true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.RefreshEncryption();
-  const syncable::ModelEnumSet encrypted_types =
+  const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 // Attempt to refresh encryption when nigori not downloaded.
 TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
   // Don't set up encryption (no nigori node created).
   sync_manager_.RefreshEncryption();  // Should fail.
-  const syncable::ModelEnumSet encrypted_types =
+  const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
 }
 
 // Attempt to refresh encryption when nigori is empty.
 TEST_F(SyncManagerTest, RefreshEncryptionEmptyNigori) {
   EXPECT_TRUE(SetUpEncryption(false));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.RefreshEncryption();  // Should write to nigori.
-  const syncable::ModelEnumSet encrypted_types =
+  const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
   EXPECT_TRUE(SetUpEncryption(true));
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelEnumSet::All()), true));
+                  HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithData) {
   size_t batch_size = 5;
   EXPECT_TRUE(SetUpEncryption(true));
 
   // Create some unencrypted unsynced data.
@@ skipping 36 matching lines @@
         false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::THEMES,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelEnumSet::All()), true));
+                  HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
-        syncable::ModelEnumSet::All()));
+        syncable::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::SESSIONS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::THEMES,
         true /* is encrypted */));
   }
 
   // Trigger's a ReEncryptEverything with new passphrase.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnPassphraseAccepted(_));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetPassphrase("new_passphrase", true);
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
-        syncable::ModelEnumSet::All()));
+        syncable::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::SESSIONS,
         true /* is encrypted */));
@@ skipping 140 matching lines @@
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::BOOKMARKS,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelEnumSet::All()), true));
+                  HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
-        syncable::ModelEnumSet::All()));
+        syncable::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::BOOKMARKS,
         true /* is encrypted */));
 
     ReadNode node(&trans);
     EXPECT_TRUE(node.InitByIdLookup(node_id1));
     EXPECT_EQ(syncable::BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
 
     ReadNode node2(&trans);
     EXPECT_TRUE(node2.InitByIdLookup(node_id2));
     EXPECT_EQ(syncable::BOOKMARKS, node2.GetModelType());
     // We should de-canonicalize the title in GetTitle(), but the title in the
     // specifics should be stored in the server legal form.
     EXPECT_EQ(raw_title2, node2.GetTitle());
     EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
     EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
   }
 }
 
 }  // namespace browser_sync