sync: Introduce control data types

sync/internal_api/sync_encryption_handler_impl_unittest.cc

 // Copyright (c) 2012 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 "sync/internal_api/sync_encryption_handler_impl.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 135 matching lines @@
   EXPECT_TRUE(encrypted_types.Equals(
       encryption_handler()->GetEncryptedTypesUnsafe()));
   EXPECT_TRUE(encrypted_types.Equals(
       handler2.GetEncryptedTypesUnsafe()));
 
   Mock::VerifyAndClearExpectations(observer());
   Mock::VerifyAndClearExpectations(&observer2);
 
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), false));
+                  HasModelTypes(UserTypes()), false));
   EXPECT_CALL(observer2,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), false));
+                  HasModelTypes(UserTypes()), false));
 
   // Set all encrypted types
-  encrypted_types = ModelTypeSet::All();
+  encrypted_types = UserTypes();
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->MergeEncryptedTypes(
         encrypted_types,
         trans.GetWrappedTrans());
     encryption_handler()->UpdateNigoriFromEncryptedTypes(
         &nigori,
         trans.GetWrappedTrans());
     handler2.UpdateEncryptedTypesFromNigori(nigori, trans.GetWrappedTrans());
   }
@@ skipping 10 matching lines @@
     WriteTransaction trans(FROM_HERE, user_share());
     handler2.UpdateEncryptedTypesFromNigori(nigori, trans.GetWrappedTrans());
   }
   EXPECT_TRUE(encrypted_types.Equals(
       encryption_handler()->GetEncryptedTypesUnsafe()));
 }
 
 // Verify the encryption handler processes the encrypt everything field
 // properly.
 TEST_F(SyncEncryptionHandlerImplTest, EncryptEverythingExplicit) {
-  ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics nigori;
   nigori.set_encrypt_everything(true);
 
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(UserTypes()), true));
 
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   ModelTypeSet encrypted_types =
       encryption_handler()->GetEncryptedTypesUnsafe();
-  for (ModelTypeSet::Iterator iter = real_types.First();
-       iter.Good(); iter.Inc()) {
-    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
-      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
-    else
-      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
-  }
+  EXPECT_TRUE(encrypted_types.Equals(ModelTypeSet(PASSWORDS)));
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->UpdateEncryptedTypesFromNigori(
         nigori,
         trans.GetWrappedTrans());
   }
 
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   encrypted_types = encryption_handler()->GetEncryptedTypesUnsafe();
-  for (ModelTypeSet::Iterator iter = real_types.First();
-       iter.Good(); iter.Inc()) {
-    EXPECT_TRUE(encrypted_types.Has(iter.Get()));
-  }
+  EXPECT_TRUE(encrypted_types.HasAll(UserTypes()));
 
   // Receiving the nigori node again shouldn't trigger another notification.
   Mock::VerifyAndClearExpectations(observer());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->UpdateEncryptedTypesFromNigori(
         nigori,
         trans.GetWrappedTrans());
   }
 }
 
 // Verify the encryption handler can detect an implicit encrypt everything state
 // (from clients that failed to write the encrypt everything field).
 TEST_F(SyncEncryptionHandlerImplTest, EncryptEverythingImplicit) {
-  ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics nigori;
   nigori.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything
 
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(UserTypes()), true));
 
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   ModelTypeSet encrypted_types =
       encryption_handler()->GetEncryptedTypesUnsafe();
-  for (ModelTypeSet::Iterator iter = real_types.First();
-       iter.Good(); iter.Inc()) {
-    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
-      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
-    else
-      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
-  }
+  EXPECT_TRUE(encrypted_types.Equals(ModelTypeSet(PASSWORDS)));
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->UpdateEncryptedTypesFromNigori(
         nigori,
         trans.GetWrappedTrans());
   }
 
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   encrypted_types = encryption_handler()->GetEncryptedTypesUnsafe();
-  for (ModelTypeSet::Iterator iter = real_types.First();
-       iter.Good(); iter.Inc()) {
-    EXPECT_TRUE(encrypted_types.Has(iter.Get()));
-  }
+  EXPECT_TRUE(encrypted_types.HasAll(UserTypes()));
 
   // Receiving a nigori node with encrypt everything explicitly set shouldn't
   // trigger another notification.
   Mock::VerifyAndClearExpectations(observer());
   nigori.set_encrypt_everything(true);
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->UpdateEncryptedTypesFromNigori(
         nigori,
         trans.GetWrappedTrans());
   }
 }
 
 // Verify the encryption handler can deal with new versions treating new types
 // as Sensitive, and that it does not consider this an implicit encrypt
 // everything case.
 TEST_F(SyncEncryptionHandlerImplTest, UnknownSensitiveTypes) {
-  ModelTypeSet real_types = ModelTypeSet::All();
   sync_pb::NigoriSpecifics nigori;
   nigori.set_encrypt_everything(false);
   nigori.set_encrypt_bookmarks(true);
 
   ModelTypeSet expected_encrypted_types =
       SyncEncryptionHandler::SensitiveTypes();
   expected_encrypted_types.Put(BOOKMARKS);
 
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(
                   HasModelTypes(expected_encrypted_types), false));
 
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   ModelTypeSet encrypted_types =
       encryption_handler()->GetEncryptedTypesUnsafe();
-  for (ModelTypeSet::Iterator iter = real_types.First();
-       iter.Good(); iter.Inc()) {
-    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
-      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
-    else
-      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
-  }
+  EXPECT_TRUE(encrypted_types.Equals(ModelTypeSet(PASSWORDS)));
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->UpdateEncryptedTypesFromNigori(
         nigori,
         trans.GetWrappedTrans());
   }
 
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   encrypted_types = encryption_handler()->GetEncryptedTypesUnsafe();
-  for (ModelTypeSet::Iterator iter = real_types.First();
-       iter.Good(); iter.Inc()) {
-    if (iter.Get() == PASSWORDS ||
-        iter.Get() == NIGORI ||
-        iter.Get() == BOOKMARKS)
-      EXPECT_TRUE(encrypted_types.Has(iter.Get()));
-    else
-      EXPECT_FALSE(encrypted_types.Has(iter.Get()));
-  }
+  EXPECT_TRUE(encrypted_types.Equals(ModelTypeSet(BOOKMARKS, PASSWORDS)));
 }
 
 // Receive an old nigori with old encryption keys and encrypted types. We should
 // not revert our default key or encrypted types, and should post a task to
 // overwrite the existing nigori with the correct data.
 TEST_F(SyncEncryptionHandlerImplTest, ReceiveOldNigori) {
   KeyParams old_key = {"localhost", "dummy", "old"};
   KeyParams current_key = {"localhost", "dummy", "cur"};
 
   // Data for testing encryption/decryption.
   Cryptographer other_cryptographer(GetCryptographer()->encryptor());
   other_cryptographer.AddKey(old_key);
   sync_pb::EntitySpecifics other_encrypted_specifics;
   other_encrypted_specifics.mutable_bookmark()->set_title("title");
   other_cryptographer.Encrypt(
       other_encrypted_specifics,
       other_encrypted_specifics.mutable_encrypted());
   sync_pb::EntitySpecifics our_encrypted_specifics;
   our_encrypted_specifics.mutable_bookmark()->set_title("title2");
-  ModelTypeSet encrypted_types = ModelTypeSet::All();
+  ModelTypeSet encrypted_types = UserTypes();
 
   // Set up the current encryption state (containing both keys and encrypt
   // everything).
   sync_pb::NigoriSpecifics current_nigori_specifics;
   GetCryptographer()->AddKey(old_key);
   GetCryptographer()->AddKey(current_key);
   GetCryptographer()->Encrypt(
       our_encrypted_specifics,
       our_encrypted_specifics.mutable_encrypted());
   GetCryptographer()->GetKeys(
       current_nigori_specifics.mutable_encrypted());
   current_nigori_specifics.set_encrypt_everything(true);
 
   EXPECT_CALL(*observer(), OnCryptographerStateChanged(_));
   EXPECT_CALL(*observer(), OnEncryptedTypesChanged(
-      HasModelTypes(ModelTypeSet::All()), true));
+      HasModelTypes(UserTypes()), true));
   {
     // Update the encryption handler.
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->ApplyNigoriUpdate(
         current_nigori_specifics,
         trans.GetWrappedTrans());
   }
   Mock::VerifyAndClearExpectations(observer());
 
   // Now set up the old nigori specifics and apply it on top.
@@ skipping 32 matching lines @@
         other_encrypted_specifics.encrypted()));
     EXPECT_TRUE(GetCryptographer()->CanDecrypt(nigori.encrypted()));
     EXPECT_TRUE(nigori.encrypt_everything());
     EXPECT_TRUE(
         GetCryptographer()->CanDecryptUsingDefaultKey(nigori.encrypted()));
   }
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
 }
 
 }  // namespace syncer