[Sync] Cache encrypted types info in ProfileSyncService

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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using syncable::ModelTypeSet;
-
 namespace browser_sync {
 
+using ::testing::Mock;
+using ::testing::StrictMock;
+using syncable::ModelTypeSet;
+
+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;
   EXPECT_FALSE(cryptographer.is_ready());
 
   sync_pb::EncryptedData encrypted;
   encrypted.set_key_name("foo");
   encrypted.set_blob("bar");
 
   EXPECT_FALSE(cryptographer.CanDecrypt(encrypted));
 }
@@ skipping 144 matching lines @@
   EXPECT_NE(static_cast<Nigori*>(NULL), unpacked.get());
 
   std::string user_key, encryption_key, mac_key;
   ASSERT_TRUE(unpacked->ExportKeys(&user_key, &encryption_key, &mac_key));
 
   EXPECT_EQ(expected_user, user_key);
   EXPECT_EQ(expected_encryption, encryption_key);
   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);
   cryptographer.SetEncryptedTypes(encrypted_types);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   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);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   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);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   cryptographer3.UpdateEncryptedTypesFromNigori(nigori);
   encrypted_types = syncable::GetAllRealModelTypes();
   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) {
   ModelTypeSet real_types = syncable::GetAllRealModelTypes();
   sync_pb::NigoriSpecifics specifics;
   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();
        iter != real_types.end();
        ++iter) {
     if (*iter == syncable::PASSWORDS || *iter == syncable::NIGORI)
       EXPECT_EQ(1U, encrypted_types.count(*iter));
     else
       EXPECT_EQ(0U, encrypted_types.count(*iter));
   }
 
   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));
   }
+
+  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();
        iter != real_types.end();
        ++iter) {
     if (*iter == syncable::PASSWORDS || *iter == syncable::NIGORI)
       EXPECT_EQ(1U, encrypted_types.count(*iter));
     else
       EXPECT_EQ(0U, encrypted_types.count(*iter));
   }
 
   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));
   }
+
+  cryptographer.RemoveObserver(&observer);
 }
 
 TEST(CryptographerTest, UnknownSensitiveTypes) {
   ModelTypeSet real_types = syncable::GetAllRealModelTypes();
   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 =
+      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();
        iter != real_types.end();
        ++iter) {
     if (*iter == syncable::PASSWORDS || *iter == syncable::NIGORI)
       EXPECT_EQ(1U, encrypted_types.count(*iter));
     else
       EXPECT_EQ(0U, encrypted_types.count(*iter));
   }
 
   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));
     else
       EXPECT_EQ(0U, encrypted_types.count(*iter));
   }
+
+  cryptographer.RemoveObserver(&observer);
 }
 
 }  // namespace browser_sync