[Sync] Rename ModelEnumSet to ModelTypeSet

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::ModelEnumSet;
+using syncable::ModelTypeSet;
 
 namespace {
 
 class MockObserver : public Cryptographer::Observer {
  public:
   MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(syncable::ModelEnumSet, bool));
+               void(syncable::ModelTypeSet, 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).
-  ModelEnumSet encrypted_types(Cryptographer::SensitiveTypes());
+  ModelTypeSet encrypted_types(Cryptographer::SensitiveTypes());
   cryptographer.MergeEncryptedTypesForTest(encrypted_types);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   EXPECT_TRUE(encrypted_types.Equals(cryptographer.GetEncryptedTypes()));
   EXPECT_TRUE(encrypted_types.Equals(cryptographer2.GetEncryptedTypes()));
 
   Mock::VerifyAndClearExpectations(&observer);
   Mock::VerifyAndClearExpectations(&observer2);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelEnumSet::All()),
+                  HasModelTypes(syncable::ModelTypeSet::All()),
                   false));
   EXPECT_CALL(observer2,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelEnumSet::All()),
+                  HasModelTypes(syncable::ModelTypeSet::All()),
                   false));
 
   // Set all encrypted types
-  encrypted_types = syncable::ModelEnumSet::All();
+  encrypted_types = syncable::ModelTypeSet::All();
   cryptographer.MergeEncryptedTypesForTest(encrypted_types);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   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_TRUE(encrypted_types.Equals(cryptographer.GetEncryptedTypes()));
 }
 
 TEST(CryptographerTest, EncryptEverythingExplicit) {
-  ModelEnumSet real_types = syncable::ModelEnumSet::All();
+  ModelTypeSet real_types = syncable::ModelTypeSet::All();
   sync_pb::NigoriSpecifics specifics;
   specifics.set_encrypt_everything(true);
 
   Cryptographer cryptographer;
   StrictMock<MockObserver> observer;
   cryptographer.AddObserver(&observer);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelEnumSet::All()), true));
+                  HasModelTypes(syncable::ModelTypeSet::All()), true));
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
-  ModelEnumSet encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelEnumSet::Iterator iter = real_types.First();
+  ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
+  for (ModelTypeSet::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_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_TRUE(cryptographer.encrypt_everything());
   encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelEnumSet::Iterator iter = real_types.First();
+  for (ModelTypeSet::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) {
-  ModelEnumSet real_types = syncable::ModelEnumSet::All();
+  ModelTypeSet real_types = syncable::ModelTypeSet::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(
-                  HasModelTypes(syncable::ModelEnumSet::All()), true));
+                  HasModelTypes(syncable::ModelTypeSet::All()), true));
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
-  ModelEnumSet encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelEnumSet::Iterator iter = real_types.First();
+  ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
+  for (ModelTypeSet::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_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_TRUE(cryptographer.encrypt_everything());
   encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelEnumSet::Iterator iter = real_types.First();
+  for (ModelTypeSet::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) {
-  ModelEnumSet real_types = syncable::ModelEnumSet::All();
+  ModelTypeSet real_types = syncable::ModelTypeSet::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::ModelEnumSet expected_encrypted_types =
+  syncable::ModelTypeSet expected_encrypted_types =
       Cryptographer::SensitiveTypes();
   expected_encrypted_types.Put(syncable::BOOKMARKS);
 
   EXPECT_CALL(observer,
               OnEncryptedTypesChanged(
                   HasModelTypes(expected_encrypted_types), false));
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
-  ModelEnumSet encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelEnumSet::Iterator iter = real_types.First();
+  ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
+  for (ModelTypeSet::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_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.UpdateEncryptedTypesFromNigori(specifics);
 
   EXPECT_FALSE(cryptographer.encrypt_everything());
   encrypted_types = cryptographer.GetEncryptedTypes();
-  for (ModelEnumSet::Iterator iter = real_types.First();
+  for (ModelTypeSet::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_FALSE(encrypted_types.Has(iter.Get()));
   }
 
   cryptographer.RemoveObserver(&observer);
 }
 
 }  // namespace browser_sync