[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/util/cryptographer_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/util/cryptographer.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "chrome/browser/password_manager/encryptor.h"
 #include "chrome/browser/sync/protocol/nigori_specifics.pb.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
+#include "chrome/browser/sync/syncable/model_type_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
+using ::testing::_;
 using ::testing::Mock;
 using ::testing::StrictMock;
-using syncable::ModelTypeSet;
+using syncable::ModelEnumSet;
 
 namespace {
 
 class MockObserver : public Cryptographer::Observer {
  public:
   MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(const syncable::ModelTypeSet&, bool));
+               void(syncable::ModelEnumSet, bool));
 };
 
 }  // namespace
 
 TEST(CryptographerTest, EmptyCantDecrypt) {
   Cryptographer cryptographer;
   EXPECT_FALSE(cryptographer.is_ready());
 
   sync_pb::EncryptedData encrypted;
   encrypted.set_key_name("foo");
@@ skipping 160 matching lines @@
   Cryptographer cryptographer2;
   sync_pb::NigoriSpecifics nigori;
 
   StrictMock<MockObserver> observer;
   cryptographer.AddObserver(&observer);
   StrictMock<MockObserver> observer2;
   cryptographer2.AddObserver(&observer2);
 
   // Just set the sensitive types (shouldn't trigger any
   // notifications).
-  ModelTypeSet encrypted_types(Cryptographer::SensitiveTypes());
+  ModelEnumSet encrypted_types(Cryptographer::SensitiveTypes());
   cryptographer.MergeEncryptedTypesForTest(encrypted_types);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
-  EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
-  EXPECT_EQ(encrypted_types, cryptographer2.GetEncryptedTypes());
+  EXPECT_TRUE(encrypted_types.Equals(cryptographer.GetEncryptedTypes()));
+  EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes()));
 
   Mock::VerifyAndClearExpectations(&observer);
   Mock::VerifyAndClearExpectations(&observer2);
 
   EXPECT_CALL(observer,
-              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
-                                      false));
+              OnEncryptedTypesChanged(
+                  HasModelTypes(syncable::ModelEnumSet::All()),
+                  false));
   EXPECT_CALL(observer2,
-              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+              OnEncryptedTypesChanged(_,

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

modelenumset::all?

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

Done.

                                       false));
 
   // Set all encrypted types
-  encrypted_types = syncable::GetAllRealModelTypes();
+  encrypted_types = syncable::ModelEnumSet::All();
   cryptographer.MergeEncryptedTypesForTest(encrypted_types);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
-  EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
-  EXPECT_EQ(encrypted_types, cryptographer2.GetEncryptedTypes());
+  EXPECT_TRUE(encrypted_types.Equals(cryptographer.GetEncryptedTypes()));
+  EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes()));
 
    // Receiving an empty nigori should not reset any encrypted types or trigger
    // an observer notification.
    Mock::VerifyAndClearExpectations(&observer);
    nigori = sync_pb::NigoriSpecifics();
    cryptographer.UpdateEncryptedTypesFromNigori(nigori);
-   EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
+   EXPECT_TRUE(encrypted_types.Equals(cryptographer.GetEncryptedTypes()));
 }
 
 TEST(CryptographerTest, EncryptEverythingExplicit) {
-  ModelTypeSet real_types = syncable::GetAllRealModelTypes();
+  ModelEnumSet real_types = syncable::ModelEnumSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_everything(true);
 
   Cryptographer cryptographer;
   StrictMock<MockObserver> observer;
   cryptographer.AddObserver(&observer);
 
   EXPECT_CALL(observer,
-              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
-                                      true));
+              OnEncryptedTypesChanged(
+                  HasModelTypes(syncable::ModelEnumSet::All()), true));
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
-  ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelTypeSet::iterator iter = real_types.begin();
-       iter != real_types.end();
-       ++iter) {
-    if (*iter == syncable::PASSWORDS || *iter == syncable::NIGORI)
-      EXPECT_EQ(1U, encrypted_types.count(*iter));
+  ModelEnumSet encrypted_types = cryptographer.GetEncryptedTypes();
+  for (ModelEnumSet::Iterator iter = real_types.First();
+       iter.Good(); iter.Inc()) {
+    if (iter.Get() == syncable::PASSWORDS || iter.Get() == syncable::NIGORI)
+      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
-      EXPECT_EQ(0U, encrypted_types.count(*iter));
+      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_TRUE(cryptographer.encrypt_everything());
   encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelTypeSet::iterator iter = real_types.begin();
-       iter != real_types.end();
-       ++iter) {
-    EXPECT_EQ(1U, encrypted_types.count(*iter));
+  for (ModelEnumSet::Iterator iter = real_types.First();
+       iter.Good(); iter.Inc()) {
+    EXPECT_TRUE(encrypted_types.Has(iter.Get()));
   }
 
   // Shouldn't trigger another notification.
   specifics.set_encrypt_everything(true);
 
   cryptographer.RemoveObserver(&observer);
 }
 
 TEST(CryptographerTest, EncryptEverythingImplicit) {
-  ModelTypeSet real_types = syncable::GetAllRealModelTypes();
+  ModelEnumSet real_types = syncable::ModelEnumSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything
 
   Cryptographer cryptographer;
   StrictMock<MockObserver> observer;
   cryptographer.AddObserver(&observer);
 
   EXPECT_CALL(observer,
-              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
-                                      true));
+              OnEncryptedTypesChanged(
+                  HasModelTypes(syncable::ModelEnumSet::All()), true));
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
-  ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelTypeSet::iterator iter = real_types.begin();
-       iter != real_types.end();
-       ++iter) {
-    if (*iter == syncable::PASSWORDS || *iter == syncable::NIGORI)
-      EXPECT_EQ(1U, encrypted_types.count(*iter));
+  ModelEnumSet encrypted_types = cryptographer.GetEncryptedTypes();
+  for (ModelEnumSet::Iterator iter = real_types.First();
+       iter.Good(); iter.Inc()) {
+    if (iter.Get() == syncable::PASSWORDS || iter.Get() == syncable::NIGORI)
+      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
-      EXPECT_EQ(0U, encrypted_types.count(*iter));
+      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_TRUE(cryptographer.encrypt_everything());
   encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelTypeSet::iterator iter = real_types.begin();
-       iter != real_types.end();
-       ++iter) {
-    EXPECT_EQ(1U, encrypted_types.count(*iter));
+  for (ModelEnumSet::Iterator iter = real_types.First();
+       iter.Good(); iter.Inc()) {
+    EXPECT_TRUE(encrypted_types.Has(iter.Get()));
   }
 
   // Shouldn't trigger another notification.
   specifics.set_encrypt_everything(true);
 
   cryptographer.RemoveObserver(&observer);
 }
 
 TEST(CryptographerTest, UnknownSensitiveTypes) {
-  ModelTypeSet real_types = syncable::GetAllRealModelTypes();
+  ModelEnumSet real_types = syncable::ModelEnumSet::All();
   sync_pb::NigoriSpecifics specifics;
   // Explicitly setting encrypt everything should override logic for implicit
   // encrypt everything.
   specifics.set_encrypt_everything(false);
   specifics.set_encrypt_bookmarks(true);
 
   Cryptographer cryptographer;
   StrictMock<MockObserver> observer;
   cryptographer.AddObserver(&observer);
 
-  syncable::ModelTypeSet expected_encrypted_types =
+  syncable::ModelEnumSet expected_encrypted_types =
       Cryptographer::SensitiveTypes();
-  expected_encrypted_types.insert(syncable::BOOKMARKS);
+  expected_encrypted_types.Put(syncable::BOOKMARKS);
 
   EXPECT_CALL(observer,
-              OnEncryptedTypesChanged(expected_encrypted_types,
-                                      false));
+              OnEncryptedTypesChanged(
+                  HasModelTypes(expected_encrypted_types), false));
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
-  ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelTypeSet::iterator iter = real_types.begin();
-       iter != real_types.end();
-       ++iter) {
-    if (*iter == syncable::PASSWORDS || *iter == syncable::NIGORI)
-      EXPECT_EQ(1U, encrypted_types.count(*iter));
+  ModelEnumSet encrypted_types = cryptographer.GetEncryptedTypes();
+  for (ModelEnumSet::Iterator iter = real_types.First();
+       iter.Good(); iter.Inc()) {
+    if (iter.Get() == syncable::PASSWORDS || iter.Get() == syncable::NIGORI)
+      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
-      EXPECT_EQ(0U, encrypted_types.count(*iter));
+      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
   encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelTypeSet::iterator iter = real_types.begin();
-       iter != real_types.end();
-       ++iter) {
-    if (*iter == syncable::PASSWORDS ||
-        *iter == syncable::NIGORI ||
-        *iter == syncable::BOOKMARKS)
-      EXPECT_EQ(1U, encrypted_types.count(*iter));
+  for (ModelEnumSet::Iterator iter = real_types.First();
+       iter.Good(); iter.Inc()) {
+    if (iter.Get() == syncable::PASSWORDS ||
+        iter.Get() == syncable::NIGORI ||
+        iter.Get() == syncable::BOOKMARKS)
+      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
     else
-      EXPECT_EQ(0U, encrypted_types.count(*iter));
+      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.RemoveObserver(&observer);
 }
 
 }  // namespace browser_sync