[Sync] Cache encrypted types info in ProfileSyncService

chrome/browser/sync/util/cryptographer_unittest.cc

Index: chrome/browser/sync/util/cryptographer_unittest.cc
diff --git a/chrome/browser/sync/util/cryptographer_unittest.cc b/chrome/browser/sync/util/cryptographer_unittest.cc
index 9e51ada52e215e6f5ecf60a8215dedcf77036665..7f3983caeb4d549250819bcf33a59e8e33d9cb0b 100644
--- a/chrome/browser/sync/util/cryptographer_unittest.cc
+++ b/chrome/browser/sync/util/cryptographer_unittest.cc
@@ -11,11 +11,25 @@
 #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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace browser_sync {
+
+using ::testing::Mock;
+using ::testing::StrictMock;
 using syncable::ModelTypeSet;
 
-namespace browser_sync {
+namespace {
+
+class MockObserver : public Cryptographer::Observer {
+ public:
+  MOCK_METHOD2(OnEncryptedTypesChanged,
+               void(const syncable::ModelTypeSet&, bool));
+  MOCK_METHOD0(OnEncryptionComplete, void());
+};
+
+}  // namespace
 
 TEST(CryptographerTest, EmptyCantDecrypt) {
   Cryptographer cryptographer;
@@ -181,12 +195,36 @@ TEST(CryptographerTest, MAYBE_PackUnpack) {
   EXPECT_EQ(expected_mac, mac_key);
 }
 
+TEST(CryptographerTest, MarkEncryptionComplete) {
+  Cryptographer cryptographer;
+  StrictMock<MockObserver> observer;
+  cryptographer.AddObserver(&observer);
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(Cryptographer::SensitiveTypes(),
+                                      false));
+  EXPECT_CALL(observer, OnEncryptionComplete());
+
+  cryptographer.MarkEncryptionComplete();
+}
+
 TEST(CryptographerTest, NigoriEncryptionTypes) {
   Cryptographer cryptographer;
   Cryptographer cryptographer2;
   sync_pb::NigoriSpecifics nigori;
   ModelTypeSet encrypted_types;
 
+  StrictMock<MockObserver> observer;
+  cryptographer.AddObserver(&observer);
+  StrictMock<MockObserver> observer2;
+  cryptographer2.AddObserver(&observer2);
+
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(Cryptographer::SensitiveTypes(),
+                                      false));
+  EXPECT_CALL(observer2,
+              OnEncryptedTypesChanged(Cryptographer::SensitiveTypes(),
+                                      false));
+
   // Just set the sensitive types.
   encrypted_types.insert(syncable::PASSWORDS);
   encrypted_types.insert(syncable::NIGORI);
@@ -196,6 +234,16 @@ TEST(CryptographerTest, NigoriEncryptionTypes) {
   EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
   EXPECT_EQ(encrypted_types, cryptographer2.GetEncryptedTypes());
 
+  Mock::VerifyAndClearExpectations(&observer);
+  Mock::VerifyAndClearExpectations(&observer2);
+
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      false));
+  EXPECT_CALL(observer2,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      false));
+
   // Set all encrypted types
   encrypted_types = syncable::GetAllRealModelTypes();
   cryptographer.SetEncryptedTypes(encrypted_types);
@@ -204,8 +252,24 @@ TEST(CryptographerTest, NigoriEncryptionTypes) {
   EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
   EXPECT_EQ(encrypted_types, cryptographer2.GetEncryptedTypes());
 
+  Mock::VerifyAndClearExpectations(&observer);
+  Mock::VerifyAndClearExpectations(&observer2);
+
   // Ensure encrypted types are never unset.
   Cryptographer cryptographer3;  // Empty cryptographer.
+  StrictMock<MockObserver> observer3;
+  cryptographer3.AddObserver(&observer3);
+
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      false));
+  EXPECT_CALL(observer2,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      false));
+  EXPECT_CALL(observer3,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      false));
+
   encrypted_types.erase(syncable::BOOKMARKS);
   encrypted_types.erase(syncable::SESSIONS);
   cryptographer.SetEncryptedTypes(encrypted_types);
@@ -216,6 +280,10 @@ TEST(CryptographerTest, NigoriEncryptionTypes) {
   EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
   EXPECT_EQ(encrypted_types, cryptographer2.GetEncryptedTypes());
   EXPECT_EQ(encrypted_types, cryptographer3.GetEncryptedTypes());
+
+  cryptographer3.RemoveObserver(&observer3);
+  cryptographer2.RemoveObserver(&observer2);
+  cryptographer.RemoveObserver(&observer);
 }
 
 TEST(CryptographerTest, EncryptEverythingExplicit) {
@@ -224,6 +292,13 @@ TEST(CryptographerTest, EncryptEverythingExplicit) {
   specifics.set_encrypt_everything(true);
 
   Cryptographer cryptographer;
+  StrictMock<MockObserver> observer;
+  cryptographer.AddObserver(&observer);
+
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      true));
+
   EXPECT_FALSE(cryptographer.encrypt_everything());
   ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
   for (ModelTypeSet::iterator iter = real_types.begin();
@@ -244,14 +319,23 @@ TEST(CryptographerTest, EncryptEverythingExplicit) {
        ++iter) {
     EXPECT_EQ(1U, encrypted_types.count(*iter));
   }
+
+  cryptographer.RemoveObserver(&observer);
 }
 
 TEST(CryptographerTest, EncryptEverythingImplicit) {
   ModelTypeSet real_types = syncable::GetAllRealModelTypes();
   sync_pb::NigoriSpecifics specifics;
-  specifics.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything.
+  specifics.set_encrypt_bookmarks(true);  // Non-passwords = encrypt everything
 
   Cryptographer cryptographer;
+  StrictMock<MockObserver> observer;
+  cryptographer.AddObserver(&observer);
+
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(syncable::GetAllRealModelTypes(),
+                                      true));
+
   EXPECT_FALSE(cryptographer.encrypt_everything());
   ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
   for (ModelTypeSet::iterator iter = real_types.begin();
@@ -272,6 +356,8 @@ TEST(CryptographerTest, EncryptEverythingImplicit) {
        ++iter) {
     EXPECT_EQ(1U, encrypted_types.count(*iter));
   }
+
+  cryptographer.RemoveObserver(&observer);
 }
 
 TEST(CryptographerTest, UnknownSensitiveTypes) {
@@ -283,6 +369,17 @@ TEST(CryptographerTest, UnknownSensitiveTypes) {
   specifics.set_encrypt_bookmarks(true);
 
   Cryptographer cryptographer;
+  StrictMock<MockObserver> observer;
+  cryptographer.AddObserver(&observer);
+
+  syncable::ModelTypeSet expected_encrypted_types =
+      Cryptographer::SensitiveTypes();
+  expected_encrypted_types.insert(syncable::BOOKMARKS);
+
+  EXPECT_CALL(observer,
+              OnEncryptedTypesChanged(expected_encrypted_types,
+                                      false));
+
   EXPECT_FALSE(cryptographer.encrypt_everything());
   ModelTypeSet encrypted_types = cryptographer.GetEncryptedTypes();
   for (ModelTypeSet::iterator iter = real_types.begin();
@@ -308,6 +405,8 @@ TEST(CryptographerTest, UnknownSensitiveTypes) {
     else
       EXPECT_EQ(0U, encrypted_types.count(*iter));
   }
+
+  cryptographer.RemoveObserver(&observer);
 }
 
 }  // namespace browser_sync