[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));
+};
+
+}  // 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 148 matching lines @@
 
   EXPECT_EQ(expected_user, user_key);
   EXPECT_EQ(expected_encryption, encryption_key);
   EXPECT_EQ(expected_mac, mac_key);
 }
 
 TEST(CryptographerTest, NigoriEncryptionTypes) {
   Cryptographer cryptographer;
   Cryptographer cryptographer2;
   sync_pb::NigoriSpecifics nigori;
-  ModelTypeSet encrypted_types;
 
-  // Just set the sensitive types.
-  encrypted_types.insert(syncable::PASSWORDS);
-  encrypted_types.insert(syncable::NIGORI);
-  cryptographer.SetEncryptedTypes(encrypted_types);
+  StrictMock<MockObserver> observer;
+  cryptographer.AddObserver(&observer);
+  StrictMock<MockObserver> observer2;
+  cryptographer2.AddObserver(&observer2);
+
+  // Just set the sensitive types (shouldn't trigger any
+  // notifications).
+  ModelTypeSet encrypted_types(Cryptographer::SensitiveTypes());
+  cryptographer.SetEncryptedTypesForTest(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.SetEncryptedTypesForTest(encrypted_types);
   cryptographer.UpdateNigoriFromEncryptedTypes(&nigori);
   cryptographer2.UpdateEncryptedTypesFromNigori(nigori);
   EXPECT_EQ(encrypted_types, cryptographer.GetEncryptedTypes());
   EXPECT_EQ(encrypted_types, cryptographer2.GetEncryptedTypes());
-
-  // Ensure encrypted types are never unset.

[Nicolas Zea, 2011/10/24 19:18:17]

Any reason this was removed?

[akalin, 2011/10/24 19:34:13]

The old public SetEncryptedTypes was more like MergeEncryptedTypes.  The new
SetEncryptedTypes is either private, or used by test, so it didn't make sense to
me to make it merge.  So we don't need to test the merge behavior anymore.

-  Cryptographer cryptographer3;  // Empty cryptographer.
-  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());
 }
 
 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));
   }
+
+  // Shouldn't trigger another notification.
+  specifics.set_encrypt_everything(true);
+
+  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));
   }
+
+  // Shouldn't trigger another notification.
+  specifics.set_encrypt_everything(true);
+
+  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