[Sync] Ensure cryptographer ready before encrypting.

chrome/browser/sync/engine/syncapi_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 1222 matching lines @@
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
 
   js_backend->SetParentJsEventRouter(&event_router);
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
   js_backend->RemoveParentJsEventRouter();
 
   sync_manager_.TriggerOnIncomingNotificationForTest(empty_model_types);
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
 }
 
+TEST_F(SyncManagerTest, ReloadNigoriReady) {
+  EXPECT_TRUE(SetUpEncryption());
+  sync_manager_.ReloadNigori();
+  syncable::ModelTypeSet encrypted_types =
+      sync_manager_.GetEncryptedDataTypes();
+  EXPECT_EQ(1U, encrypted_types.count(syncable::PASSWORDS));
+}
+
+// Attempt to reload nigori when nigori not downloaded.
+TEST_F(SyncManagerTest, ReloadNigoriNotReady) {
+  // Don't set up encryption.
+  sync_manager_.ReloadNigori();  // Should fail.
+  syncable::ModelTypeSet encrypted_types =
+      sync_manager_.GetEncryptedDataTypes();
+  EXPECT_EQ(1U, encrypted_types.count(syncable::PASSWORDS));  // Hardcoded.
+}
+
 TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
   EXPECT_TRUE(SetUpEncryption());
   ModelTypeSet encrypted_types;
   encrypted_types.insert(syncable::BOOKMARKS);
   // Even though Passwords isn't marked for encryption, it's enabled, so it
   // should automatically be added to the response of OnEncryptionComplete.
   ModelTypeSet expected_types = encrypted_types;
   expected_types.insert(syncable::PASSWORDS);
   EXPECT_CALL(observer_, OnEncryptionComplete(expected_types));
   sync_manager_.EncryptDataTypes(encrypted_types);
@@ skipping 61 matching lines @@
                                                    true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryption(trans.GetWrappedTrans(),
                                                    syncable::SESSIONS,
                                                    true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryption(trans.GetWrappedTrans(),
                                                    syncable::THEMES,
                                                    false /* not encrypted */));
   }
 }
 
+TEST_F(SyncManagerTest, SetPassphraseWithPassword) {
+  EXPECT_TRUE(SetUpEncryption());
+  {
+    WriteTransaction trans(sync_manager_.GetUserShare());
+    ReadNode root_node(&trans);
+    root_node.InitByRootLookup();
+
+    WriteNode password_node(&trans);
+    EXPECT_TRUE(password_node.InitUniqueByCreation(syncable::PASSWORDS,
+                                                   root_node, "foo"));
+    sync_pb::PasswordSpecificsData data;
+    data.set_password_value("secret");
+    password_node.SetPasswordSpecifics(data);
+  }
+  EXPECT_CALL(observer_, OnPassphraseAccepted(_));
+  EXPECT_CALL(observer_, OnEncryptionComplete(_));
+  sync_manager_.SetPassphrase("new_passphrase", true);
+  {
+    ReadTransaction trans(sync_manager_.GetUserShare());
+    ReadNode root_node(&trans);
+    root_node.InitByRootLookup();
+
+    ReadNode password_node(&trans);
+    EXPECT_TRUE(password_node.InitByClientTagLookup(syncable::PASSWORDS,
+                                                    "foo"));
+    const sync_pb::PasswordSpecificsData& data =
+        password_node.GetPasswordSpecifics();
+    EXPECT_EQ("secret", data.password_value());
+  }
+}
+
+TEST_F(SyncManagerTest, SetPassphraseWithEmptyPasswordNode) {
+  EXPECT_TRUE(SetUpEncryption());
+  int64 node_id = 0;
+  std::string tag = "foo";
+  {
+    WriteTransaction trans(sync_manager_.GetUserShare());
+    ReadNode root_node(&trans);
+    root_node.InitByRootLookup();
+
+    WriteNode password_node(&trans);
+    EXPECT_TRUE(password_node.InitUniqueByCreation(syncable::PASSWORDS,
+                                                   root_node, tag));
+    node_id = password_node.GetId();
+  }
+  EXPECT_CALL(observer_, OnPassphraseAccepted(_));
+  EXPECT_CALL(observer_, OnEncryptionComplete(_));
+  sync_manager_.SetPassphrase("new_passphrase", true);
+  {
+    ReadTransaction trans(sync_manager_.GetUserShare());
+    ReadNode root_node(&trans);
+    root_node.InitByRootLookup();
+
+    ReadNode password_node(&trans);
+    EXPECT_FALSE(password_node.InitByClientTagLookup(syncable::PASSWORDS,
+                                                     tag));
+  }
+  {
+    ReadTransaction trans(sync_manager_.GetUserShare());
+    ReadNode root_node(&trans);
+    root_node.InitByRootLookup();
+
+    ReadNode password_node(&trans);
+    EXPECT_FALSE(password_node.InitByIdLookup(node_id));
+  }
+}
+
 }  // namespace
 
 }  // namespace browser_sync