[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/engine/apply_updates_command_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 <string>
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/syncable/syncable_id.h"
 #include "chrome/browser/sync/test/engine/fake_model_worker.h"
 #include "chrome/browser/sync/test/engine/syncer_command_test.h"
 #include "chrome/browser/sync/test/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
 using sessions::SyncSession;
 using std::string;
 using syncable::Entry;
-using syncable::GetAllRealModelTypes;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::ReadTransaction;
 using syncable::ScopedDirLookup;
 using syncable::UNITTEST;
 using syncable::WriteTransaction;
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
@@ skipping 379 matching lines @@
         << "conflict";
     EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The undecryptable password update shouldn't be applied";
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdate) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.insert(syncable::PASSWORDS);
-  encrypted_types.insert(syncable::NIGORI);
+  syncable::ModelEnumSet encrypted_types;
+  encrypted_types.Put(syncable::PASSWORDS);
+  encrypted_types.Put(syncable::NIGORI);
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     cryptographer =
         session()->context()->directory_manager()->GetCryptographer(&trans);
-    EXPECT_EQ(encrypted_types, cryptographer->GetEncryptedTypes());
+    EXPECT_TRUE(encrypted_types.Equals(cryptographer->GetEncryptedTypes()));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_cryptographer;
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori =
       specifics.MutableExtension(sync_pb::nigori);
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
-  encrypted_types.insert(syncable::BOOKMARKS);
+  encrypted_types.Put(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
-  EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
+  EXPECT_TRUE(

[Nicolas Zea, 2011/12/08 01:49:37]

ExpectTrue(cryptographer->GetEncryptedTypes()
                      .Equals(syncable::ModelEnumSet::All()));

[akalin, 2011/12/09 19:10:10]

Indented 4 spaces instead

+      cryptographer->GetEncryptedTypes()
+      .Equals(syncable::ModelEnumSet::All()));
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdateForDisabledTypes) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.insert(syncable::PASSWORDS);
-  encrypted_types.insert(syncable::NIGORI);
+  syncable::ModelEnumSet encrypted_types;
+  encrypted_types.Put(syncable::PASSWORDS);
+  encrypted_types.Put(syncable::NIGORI);
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     cryptographer =
         session()->context()->directory_manager()->GetCryptographer(&trans);
-    EXPECT_EQ(encrypted_types, cryptographer->GetEncryptedTypes());
+    EXPECT_TRUE(encrypted_types.Equals(cryptographer->GetEncryptedTypes()));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_cryptographer;
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori =
       specifics.MutableExtension(sync_pb::nigori);
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_sessions(true);
   nigori->set_encrypt_themes(true);
-  encrypted_types.insert(syncable::SESSIONS);
-  encrypted_types.insert(syncable::THEMES);
+  encrypted_types.Put(syncable::SESSIONS);
+  encrypted_types.Put(syncable::THEMES);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->ConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
-  EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
+  EXPECT_TRUE(syncable::ModelEnumSet::All().Equals(
+      cryptographer->GetEncryptedTypes()));
 }
 
 TEST_F(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.insert(syncable::PASSWORDS);
-  encrypted_types.insert(syncable::NIGORI);
+  syncable::ModelEnumSet encrypted_types;
+  encrypted_types.Put(syncable::PASSWORDS);
+  encrypted_types.Put(syncable::NIGORI);
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     cryptographer =
         session()->context()->directory_manager()->GetCryptographer(&trans);
-    EXPECT_EQ(encrypted_types, cryptographer->GetEncryptedTypes());
+    EXPECT_TRUE(encrypted_types.Equals(cryptographer->GetEncryptedTypes()));
 
 
     // With default encrypted_types, this should be true.
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_TRUE(handles.empty());
   }
 
@@ skipping 17 matching lines @@
                        syncable::BOOKMARKS, NULL);
   }
 
   KeyParams params = {"localhost", "dummy", "foobar"};
   cryptographer->AddKey(params);
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori =
       specifics.MutableExtension(sync_pb::nigori);
   cryptographer->GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
-  encrypted_types.insert(syncable::BOOKMARKS);
+  encrypted_types.Put(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
 
   {
     // Ensure we have unsynced nodes that aren't properly encrypted.
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
@@ skipping 21 matching lines @@
       << "The nigori update should be applied";
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
 
     // If ProcessUnsyncedChangesForEncryption worked, all our unsynced changes
     // should be encrypted now.
-    EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
+    EXPECT_TRUE(syncable::ModelEnumSet::All().Equals(
+        cryptographer->GetEncryptedTypes()));
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, CannotEncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.insert(syncable::PASSWORDS);
-  encrypted_types.insert(syncable::NIGORI);
+  syncable::ModelEnumSet encrypted_types;
+  encrypted_types.Put(syncable::PASSWORDS);
+  encrypted_types.Put(syncable::NIGORI);
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     cryptographer =
         session()->context()->directory_manager()->GetCryptographer(&trans);
-    EXPECT_EQ(encrypted_types, cryptographer->GetEncryptedTypes());
+    EXPECT_TRUE(encrypted_types.Equals(cryptographer->GetEncryptedTypes()));
 
 
     // With default encrypted_types, this should be true.
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_TRUE(handles.empty());
   }
 
@@ skipping 20 matching lines @@
   // We encrypt with new keys, triggering the local cryptographer to be unready
   // and unable to decrypt data (once updated).
   Cryptographer other_cryptographer;
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori =
       specifics.MutableExtension(sync_pb::nigori);
   other_cryptographer.GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
-  encrypted_types.insert(syncable::BOOKMARKS);
+  encrypted_types.Put(syncable::BOOKMARKS);
   CreateUnappliedNewItem(syncable::ModelTypeToRootTag(syncable::NIGORI),
                          specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   {
     // Ensure we have unsynced nodes that aren't properly encrypted.
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
@@ skipping 23 matching lines @@
   EXPECT_TRUE(cryptographer->has_pending_keys());
   {
     // Ensure the unsynced nodes are still not encrypted.
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
 
     // Since we're in conflict, the specifics don't reflect the unapplied
     // changes.
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
-    encrypted_types.clear();
-    encrypted_types.insert(syncable::PASSWORDS);
-    encrypted_types.insert(syncable::BOOKMARKS);
-    EXPECT_EQ(GetAllRealModelTypes(), cryptographer->GetEncryptedTypes());
+    encrypted_types.Clear();
+    encrypted_types.Put(syncable::PASSWORDS);
+    encrypted_types.Put(syncable::BOOKMARKS);
+    EXPECT_TRUE(syncable::ModelEnumSet().All().Equals(
+        cryptographer->GetEncryptedTypes()));
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 }  // namespace browser_sync