[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 1303 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));
+    sync_pb::PasswordSpecificsData data;
+    password_node.SetPasswordSpecifics(data);

[tim (not reviewing), 2011/06/13 17:43:22]

Is this legal?

[Nicolas Zea, 2011/06/13 18:38:22]

Not really, but I primarily want to test that SetPassphrase doesn't choke when
it happens (we shouldn't deliberately get into this situation, but it might be
possible if chrome crashes in the middle of writing a node). I've modified it to
just not set the password specifics, and brought back the notreached in there.

+    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