[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

Also change some functions to return ModelEnumSets directly instead of
taking a pointer value.

BUG=79970
TEST=


Review URL: http://codereview.chromium.org/8851006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@113906 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 105 insertions, 110 deletions

diff --git a/chrome/browser/sync/util/cryptographer.cc b/chrome/browser/sync/util/cryptographer.cc
index 59e9610..0f04a01 100644
--- a/chrome/browser/sync/util/cryptographer.cc
+++ b/chrome/browser/sync/util/cryptographer.cc
@@ -22,10 +22,8 @@ Cryptographer::Observer::~Observer() {}
 
 Cryptographer::Cryptographer()
     : default_nigori_(NULL),
-      encrypt_everything_(false) {
-  syncable::ModelTypeSet sensitive_types = SensitiveTypes();
-  encrypted_types_.insert(sensitive_types.begin(), sensitive_types.end());
-}
+      encrypted_types_(SensitiveTypes()),
+      encrypt_everything_(false) {}
 
 Cryptographer::~Cryptographer() {}
 
@@ -275,12 +273,12 @@ Cryptographer::UpdateResult Cryptographer::Update(
 }
 
 // Static
-syncable::ModelTypeSet Cryptographer::SensitiveTypes() {
-  syncable::ModelTypeSet types;
+syncable::ModelEnumSet Cryptographer::SensitiveTypes() {
   // Both of these have their own encryption schemes, but we include them
   // anyways.
-  types.insert(syncable::PASSWORDS);
-  types.insert(syncable::NIGORI);
+  syncable::ModelEnumSet types;
+  types.Put(syncable::PASSWORDS);
+  types.Put(syncable::NIGORI);
   return types;
 }
 
@@ -291,39 +289,39 @@ void Cryptographer::UpdateEncryptedTypesFromNigori(
     return;
   }
 
-  syncable::ModelTypeSet encrypted_types(SensitiveTypes());
+  syncable::ModelEnumSet encrypted_types(SensitiveTypes());
   if (nigori.encrypt_bookmarks())
-    encrypted_types.insert(syncable::BOOKMARKS);
+    encrypted_types.Put(syncable::BOOKMARKS);
   if (nigori.encrypt_preferences())
-    encrypted_types.insert(syncable::PREFERENCES);
+    encrypted_types.Put(syncable::PREFERENCES);
   if (nigori.encrypt_autofill_profile())
-    encrypted_types.insert(syncable::AUTOFILL_PROFILE);
+    encrypted_types.Put(syncable::AUTOFILL_PROFILE);
   if (nigori.encrypt_autofill())
-    encrypted_types.insert(syncable::AUTOFILL);
+    encrypted_types.Put(syncable::AUTOFILL);
   if (nigori.encrypt_themes())
-    encrypted_types.insert(syncable::THEMES);
+    encrypted_types.Put(syncable::THEMES);
   if (nigori.encrypt_typed_urls())
-    encrypted_types.insert(syncable::TYPED_URLS);
+    encrypted_types.Put(syncable::TYPED_URLS);
   if (nigori.encrypt_extension_settings())
-    encrypted_types.insert(syncable::EXTENSION_SETTINGS);
+    encrypted_types.Put(syncable::EXTENSION_SETTINGS);
   if (nigori.encrypt_extensions())
-    encrypted_types.insert(syncable::EXTENSIONS);
+    encrypted_types.Put(syncable::EXTENSIONS);
   if (nigori.encrypt_search_engines())
-    encrypted_types.insert(syncable::SEARCH_ENGINES);
+    encrypted_types.Put(syncable::SEARCH_ENGINES);
   if (nigori.encrypt_sessions())
-    encrypted_types.insert(syncable::SESSIONS);
+    encrypted_types.Put(syncable::SESSIONS);
   if (nigori.encrypt_app_settings())
-    encrypted_types.insert(syncable::APP_SETTINGS);
+    encrypted_types.Put(syncable::APP_SETTINGS);
   if (nigori.encrypt_apps())
-    encrypted_types.insert(syncable::APPS);
+    encrypted_types.Put(syncable::APPS);
   if (nigori.encrypt_app_notifications())
-    encrypted_types.insert(syncable::APP_NOTIFICATIONS);
+    encrypted_types.Put(syncable::APP_NOTIFICATIONS);
 
   // Note: the initial version with encryption did not support the
   // encrypt_everything field. If anything more than the sensitive types were
   // encrypted, it meant we were encrypting everything.
   if (!nigori.has_encrypt_everything() &&
-      encrypted_types.size() > SensitiveTypes().size()) {
+      !Difference(encrypted_types, SensitiveTypes()).Empty()) {
     set_encrypt_everything();
     return;
   }
@@ -335,38 +333,38 @@ void Cryptographer::UpdateNigoriFromEncryptedTypes(
     sync_pb::NigoriSpecifics* nigori) const {
   nigori->set_encrypt_everything(encrypt_everything_);
   nigori->set_encrypt_bookmarks(
-      encrypted_types_.count(syncable::BOOKMARKS) > 0);
+      encrypted_types_.Has(syncable::BOOKMARKS));
   nigori->set_encrypt_preferences(
-      encrypted_types_.count(syncable::PREFERENCES) > 0);
+      encrypted_types_.Has(syncable::PREFERENCES));
   nigori->set_encrypt_autofill_profile(
-      encrypted_types_.count(syncable::AUTOFILL_PROFILE) > 0);
-  nigori->set_encrypt_autofill(encrypted_types_.count(syncable::AUTOFILL) > 0);
-  nigori->set_encrypt_themes(encrypted_types_.count(syncable::THEMES) > 0);
+      encrypted_types_.Has(syncable::AUTOFILL_PROFILE));
+  nigori->set_encrypt_autofill(encrypted_types_.Has(syncable::AUTOFILL));
+  nigori->set_encrypt_themes(encrypted_types_.Has(syncable::THEMES));
   nigori->set_encrypt_typed_urls(
-      encrypted_types_.count(syncable::TYPED_URLS) > 0);
+      encrypted_types_.Has(syncable::TYPED_URLS));
   nigori->set_encrypt_extension_settings(
-      encrypted_types_.count(syncable::EXTENSION_SETTINGS) > 0);
+      encrypted_types_.Has(syncable::EXTENSION_SETTINGS));
   nigori->set_encrypt_extensions(
-      encrypted_types_.count(syncable::EXTENSIONS) > 0);
+      encrypted_types_.Has(syncable::EXTENSIONS));
   nigori->set_encrypt_search_engines(
-      encrypted_types_.count(syncable::SEARCH_ENGINES) > 0);
-  nigori->set_encrypt_sessions(encrypted_types_.count(syncable::SESSIONS) > 0);
+      encrypted_types_.Has(syncable::SEARCH_ENGINES));
+  nigori->set_encrypt_sessions(encrypted_types_.Has(syncable::SESSIONS));
   nigori->set_encrypt_app_settings(
-      encrypted_types_.count(syncable::APP_SETTINGS) > 0);
-  nigori->set_encrypt_apps(encrypted_types_.count(syncable::APPS) > 0);
+      encrypted_types_.Has(syncable::APP_SETTINGS));
+  nigori->set_encrypt_apps(encrypted_types_.Has(syncable::APPS));
   nigori->set_encrypt_app_notifications(
-      encrypted_types_.count(syncable::APP_NOTIFICATIONS) > 0);
+      encrypted_types_.Has(syncable::APP_NOTIFICATIONS));
 }
 
 void Cryptographer::set_encrypt_everything() {
   if (encrypt_everything_) {
-    DCHECK(encrypted_types_ == syncable::GetAllRealModelTypes());
+    DCHECK(encrypted_types_.Equals(syncable::ModelEnumSet::All()));
     return;
   }
   encrypt_everything_ = true;
   // Change |encrypted_types_| directly to avoid sending more than one
   // notification.
-  encrypted_types_ = syncable::GetAllRealModelTypes();
+  encrypted_types_ = syncable::ModelEnumSet::All();
   EmitEncryptedTypesChangedNotification();
 }
 
@@ -374,19 +372,18 @@ bool Cryptographer::encrypt_everything() const {
   return encrypt_everything_;
 }
 
-syncable::ModelTypeSet Cryptographer::GetEncryptedTypes() const {
+syncable::ModelEnumSet Cryptographer::GetEncryptedTypes() const {
   return encrypted_types_;
 }
 
 void Cryptographer::MergeEncryptedTypesForTest(
-    const syncable::ModelTypeSet& encrypted_types) {
+    syncable::ModelEnumSet encrypted_types) {
   MergeEncryptedTypes(encrypted_types);
 }
 
 void Cryptographer::MergeEncryptedTypes(
-    const syncable::ModelTypeSet& encrypted_types) {
-  if (std::includes(encrypted_types_.begin(), encrypted_types_.end(),
-                    encrypted_types.begin(), encrypted_types.end())) {
+    syncable::ModelEnumSet encrypted_types) {
+  if (encrypted_types_.HasAll(encrypted_types)) {
     return;
   }
   encrypted_types_ = encrypted_types;
diff --git a/chrome/browser/sync/util/cryptographer.h b/chrome/browser/sync/util/cryptographer.h
index 992c443..b370296 100644
--- a/chrome/browser/sync/util/cryptographer.h
+++ b/chrome/browser/sync/util/cryptographer.h
@@ -62,7 +62,7 @@ class Cryptographer {
     // set of encrypted types is SensitiveTypes() and that the encrypt
     // everything flag is false.
     virtual void OnEncryptedTypesChanged(
-        const syncable::ModelTypeSet& encrypted_types,
+        syncable::ModelEnumSet encrypted_types,
         bool encrypt_everything) = 0;
 
    protected:
@@ -163,7 +163,7 @@ class Cryptographer {
   UpdateResult Update(const sync_pb::NigoriSpecifics& nigori);
 
   // The set of types that are always encrypted.
-  static syncable::ModelTypeSet SensitiveTypes();
+  static syncable::ModelEnumSet SensitiveTypes();
 
   // Reset our set of encrypted types based on the contents of the nigori
   // specifics.
@@ -180,11 +180,11 @@ class Cryptographer {
   bool encrypt_everything() const;
 
   // Return the set of encrypted types.
-  syncable::ModelTypeSet GetEncryptedTypes() const;
+  syncable::ModelEnumSet GetEncryptedTypes() const;
 
   // Forwards to MergeEncryptedTypes.
   void MergeEncryptedTypesForTest(
-      const syncable::ModelTypeSet& encrypted_types);
+      syncable::ModelEnumSet encrypted_types);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(CryptographerTest, PackUnpack);
@@ -192,7 +192,7 @@ class Cryptographer {
 
   // Merges the given set of encrypted types with the existing set and emits a
   // notification if necessary.
-  void MergeEncryptedTypes(const syncable::ModelTypeSet& encrypted_types);
+  void MergeEncryptedTypes(syncable::ModelEnumSet encrypted_types);
 
   void EmitEncryptedTypesChangedNotification();
 
@@ -216,7 +216,7 @@ class Cryptographer {
 
   scoped_ptr<sync_pb::EncryptedData> pending_keys_;
 
-  syncable::ModelTypeSet encrypted_types_;
+  syncable::ModelEnumSet encrypted_types_;
   bool encrypt_everything_;
 
   DISALLOW_COPY_AND_ASSIGN(Cryptographer);
diff --git a/chrome/browser/sync/util/cryptographer_unittest.cc b/chrome/browser/sync/util/cryptographer_unittest.cc
index 73e3891..b596c11 100644
--- a/chrome/browser/sync/util/cryptographer_unittest.cc
+++ b/chrome/browser/sync/util/cryptographer_unittest.cc
@@ -11,21 +11,23 @@
 #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
@@ -206,41 +208,43 @@ TEST(CryptographerTest, NigoriEncryptionTypes) {
 
   // 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(),
-                                      false));
+              OnEncryptedTypesChanged(
+                  HasModelTypes(syncable::ModelEnumSet::All()),
+                  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);
 
@@ -249,28 +253,26 @@ TEST(CryptographerTest, EncryptEverythingExplicit) {
   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.
@@ -280,7 +282,7 @@ TEST(CryptographerTest, EncryptEverythingExplicit) {
 }
 
 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
 
@@ -289,28 +291,26 @@ TEST(CryptographerTest, EncryptEverythingImplicit) {
   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.
@@ -320,7 +320,7 @@ TEST(CryptographerTest, EncryptEverythingImplicit) {
 }
 
 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.
@@ -331,38 +331,36 @@ TEST(CryptographerTest, UnknownSensitiveTypes) {
   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);