sync: Make BaseNode lookup-related Init functions return specific failures.

chrome/browser/sync/internal_api/syncapi_unittest.cc

 // Copyright (c) 2012 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 126 matching lines @@
 }
 
 // Makes a non-folder child of a non-root node. Returns the id of the
 // newly-created node.
 int64 MakeNodeWithParent(UserShare* share,
                          ModelType model_type,
                          const std::string& client_tag,
                          int64 parent_id) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode parent_node(&trans);
-  EXPECT_TRUE(parent_node.InitByIdLookup(parent_id));
+  EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
   WriteNode node(&trans);
   EXPECT_TRUE(node.InitUniqueByCreation(model_type, parent_node, client_tag));
   node.SetIsFolder(false);
   return node.GetId();
 }
 
 // Makes a folder child of a non-root node. Returns the id of the
 // newly-created node.
 int64 MakeFolderWithParent(UserShare* share,
                            ModelType model_type,
                            int64 parent_id,
                            BaseNode* predecessor) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode parent_node(&trans);
-  EXPECT_TRUE(parent_node.InitByIdLookup(parent_id));
+  EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
   WriteNode node(&trans);
   EXPECT_TRUE(node.InitByCreation(model_type, parent_node, predecessor));
   node.SetIsFolder(true);
   return node.GetId();
 }
 
 // Creates the "synced" root node for a particular datatype. We use the syncable
 // methods here so that the syncer treats these nodes as if they were already
 // received from the server.
 int64 MakeServerNodeForType(UserShare* share,
@@ skipping 76 matching lines @@
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     EXPECT_TRUE(trans.GetWrappedTrans() != NULL);
   }
   {
     // No entries but root should exist
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     // Metahandle 1 can be root, sanity check 2
-    EXPECT_FALSE(node.InitByIdLookup(2));
+    EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD, node.InitByIdLookup(2));
   }
 }
 
 TEST_F(SyncApiTest, BasicTagWrite) {
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     EXPECT_EQ(root_node.GetFirstChildId(), 0);
   }
 
   ignore_result(MakeNode(test_user_share_.user_share(),
                          syncable::BOOKMARKS, "testtag"));
 
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS,
-        "testtag"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, "testtag"));
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     EXPECT_NE(node.GetId(), 0);
     EXPECT_EQ(node.GetId(), root_node.GetFirstChildId());
   }
 }
 
 TEST_F(SyncApiTest, GenerateSyncableHash) {
   EXPECT_EQ("OyaXV5mEzrPS4wbogmtKvRfekAI=",
@@ skipping 23 matching lines @@
                          syncable::BOOKMARKS, "collideme"));
   ignore_result(MakeNode(test_user_share_.user_share(),
                          syncable::PREFERENCES, "collideme"));
   ignore_result(MakeNode(test_user_share_.user_share(),
                          syncable::AUTOFILL, "collideme"));
 
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
 
     ReadNode bookmarknode(&trans);
-    EXPECT_TRUE(bookmarknode.InitByClientTagLookup(syncable::BOOKMARKS,
-        "collideme"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              bookmarknode.InitByClientTagLookup(syncable::BOOKMARKS,
+                  "collideme"));
 
     ReadNode prefnode(&trans);
-    EXPECT_TRUE(prefnode.InitByClientTagLookup(syncable::PREFERENCES,
-        "collideme"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              prefnode.InitByClientTagLookup(syncable::PREFERENCES,
+                  "collideme"));
 
     ReadNode autofillnode(&trans);
-    EXPECT_TRUE(autofillnode.InitByClientTagLookup(syncable::AUTOFILL,
-        "collideme"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              autofillnode.InitByClientTagLookup(syncable::AUTOFILL,
+                  "collideme"));
 
     EXPECT_NE(bookmarknode.GetId(), prefnode.GetId());
     EXPECT_NE(autofillnode.GetId(), prefnode.GetId());
     EXPECT_NE(bookmarknode.GetId(), autofillnode.GetId());
   }
 }
 
 TEST_F(SyncApiTest, ReadMissingTagsFails) {
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
-    EXPECT_FALSE(node.InitByClientTagLookup(syncable::BOOKMARKS,
-        "testtag"));
+    EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
+              node.InitByClientTagLookup(syncable::BOOKMARKS,
+                  "testtag"));
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode node(&trans);
-    EXPECT_FALSE(node.InitByClientTagLookup(syncable::BOOKMARKS,
-        "testtag"));
+    EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
+              node.InitByClientTagLookup(syncable::BOOKMARKS,
+                  "testtag"));
   }
 }
 
 // TODO(chron): Hook this all up to the server and write full integration tests
 //              for update->undelete behavior.
 TEST_F(SyncApiTest, TestDeleteBehavior) {
   int64 node_id;
   int64 folder_id;
   std::string test_title("test1");
 
@@ skipping 14 matching lines @@
     wnode.SetIsFolder(false);
     wnode.SetTitle(UTF8ToWide(test_title));
 
     node_id = wnode.GetId();
   }
 
   // Ensure we can delete something with a tag.
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode wnode(&trans);
-    EXPECT_TRUE(wnode.InitByClientTagLookup(syncable::BOOKMARKS,
-        "testtag"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              wnode.InitByClientTagLookup(syncable::BOOKMARKS,
+                  "testtag"));
     EXPECT_FALSE(wnode.GetIsFolder());
     EXPECT_EQ(wnode.GetTitle(), test_title);
 
     wnode.Remove();
   }
 
   // Lookup of a node which was deleted should return failure,
   // but have found some data about the node.
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
-    EXPECT_FALSE(node.InitByClientTagLookup(syncable::BOOKMARKS,
-        "testtag"));
+    EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL,
+              node.InitByClientTagLookup(syncable::BOOKMARKS,
+                  "testtag"));
     // Note that for proper function of this API this doesn't need to be
     // filled, we're checking just to make sure the DB worked in this test.
     EXPECT_EQ(node.GetTitle(), test_title);
   }
 
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode folder_node(&trans);
-    EXPECT_TRUE(folder_node.InitByIdLookup(folder_id));
+    EXPECT_EQ(BaseNode::INIT_OK, folder_node.InitByIdLookup(folder_id));
 
     WriteNode wnode(&trans);
     // This will undelete the tag.
     EXPECT_TRUE(wnode.InitUniqueByCreation(syncable::BOOKMARKS,
         folder_node, "testtag"));
     EXPECT_EQ(wnode.GetIsFolder(), false);
     EXPECT_EQ(wnode.GetParentId(), folder_node.GetId());
     EXPECT_EQ(wnode.GetId(), node_id);
     EXPECT_NE(wnode.GetTitle(), test_title);  // Title should be cleared
     wnode.SetTitle(UTF8ToWide(test_title));
   }
 
   // Now look up should work.
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS,
-        "testtag"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS,
+                    "testtag"));
     EXPECT_EQ(node.GetTitle(), test_title);
     EXPECT_EQ(node.GetModelType(), syncable::BOOKMARKS);
   }
 }
 
 TEST_F(SyncApiTest, WriteAndReadPassword) {
   KeyParams params = {"localhost", "username", "passphrase"};
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     trans.GetCryptographer()->AddKey(params);
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     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);
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode password_node(&trans);
-    EXPECT_TRUE(password_node.InitByClientTagLookup(syncable::PASSWORDS,
-                                                    "foo"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              password_node.InitByClientTagLookup(syncable::PASSWORDS,
+                                                  "foo"));
     const sync_pb::PasswordSpecificsData& data =
         password_node.GetPasswordSpecifics();
     EXPECT_EQ("secret", data.password_value());
   }
 }
 
 TEST_F(SyncApiTest, WriteEncryptedTitle) {
   KeyParams params = {"localhost", "username", "passphrase"};
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
@@ skipping 14 matching lines @@
     EXPECT_TRUE(pref_node.InitUniqueByCreation(syncable::PREFERENCES,
                                                root_node, "bar"));
     pref_node.SetTitle(UTF8ToWide("bar"));
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode bookmark_node(&trans);
-    EXPECT_TRUE(bookmark_node.InitByClientTagLookup(syncable::BOOKMARKS,
-                                                    "foo"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              bookmark_node.InitByClientTagLookup(syncable::BOOKMARKS,
+                                                  "foo"));
     EXPECT_EQ("foo", bookmark_node.GetTitle());
     EXPECT_EQ(kEncryptedString,
               bookmark_node.GetEntry()->Get(syncable::NON_UNIQUE_NAME));
 
     ReadNode pref_node(&trans);
-    EXPECT_TRUE(pref_node.InitByClientTagLookup(syncable::PREFERENCES,
-                                                "bar"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              pref_node.InitByClientTagLookup(syncable::PREFERENCES,
+                                              "bar"));
     EXPECT_EQ(kEncryptedString, pref_node.GetTitle());
   }
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecifics) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
                             syncable::BOOKMARKS, "testtag");
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   WriteNode node(&trans);
-  EXPECT_TRUE(node.InitByIdLookup(child_id));
+  EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
 
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
 
   EXPECT_NE(entity_specifics.SerializeAsString(),
             node.GetEntitySpecifics().SerializeAsString());
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_EQ(entity_specifics.SerializeAsString(),
             node.GetEntitySpecifics().SerializeAsString());
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecificsPreservesUnknownFields) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
                             syncable::BOOKMARKS, "testtag");
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   WriteNode node(&trans);
-  EXPECT_TRUE(node.InitByIdLookup(child_id));
+  EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
   EXPECT_TRUE(node.GetEntitySpecifics().unknown_fields().empty());
 
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
   entity_specifics.mutable_unknown_fields()->AddFixed32(5, 100);
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
 
   entity_specifics.mutable_unknown_fields()->Clear();
   node.SetEntitySpecifics(entity_specifics);
@@ skipping 73 matching lines @@
 }
 
 TEST_F(SyncApiTest, EmptyTags) {
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
   std::string empty_tag;
   EXPECT_FALSE(node.InitUniqueByCreation(
       syncable::TYPED_URLS, root_node, empty_tag));
-  EXPECT_FALSE(node.InitByTagLookup(empty_tag));
+  EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
+            node.InitByTagLookup(empty_tag));
 }
 
 namespace {
 
 class TestHttpPostProviderInterface : public HttpPostProviderInterface {
  public:
   virtual ~TestHttpPostProviderInterface() {}
 
   virtual void SetUserAgent(const char* user_agent) OVERRIDE {}
   virtual void SetExtraRequestHeaders(const char* headers) OVERRIDE {}
@@ skipping 202 matching lines @@
     } else {
       DCHECK_NE(nigori_status, WRITE_TO_NIGORI);
     }
     if (encryption_status == FULL_ENCRYPTION)
       cryptographer->set_encrypt_everything();
     if (nigori_status == WRITE_TO_NIGORI) {
       sync_pb::NigoriSpecifics nigori;
       cryptographer->GetKeys(nigori.mutable_encrypted());
       cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
       WriteNode node(&trans);
-      EXPECT_TRUE(node.InitByIdLookup(nigori_id));
+      EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(nigori_id));
       node.SetNigoriSpecifics(nigori);
     }
     return cryptographer->is_ready();
   }
 
   int64 GetIdForDataType(ModelType type) {
     if (type_roots_.count(type) == 0)
       return 0;
     return type_roots_[type];
   }
@@ skipping 80 matching lines @@
   sync_manager_.UpdateEnabledTypes();
   EXPECT_EQ(2, update_enabled_types_call_count_);
 }
 
 TEST_F(SyncManagerTest, DoNotSyncTabsInNigoriNode) {
   const syncable::ModelTypeSet encrypted_types(syncable::TYPED_URLS);
   sync_manager_.MaybeSetSyncTabsInNigoriNode(encrypted_types);
 
   ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
   ReadNode node(&trans);
-  ASSERT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
+  ASSERT_EQ(BaseNode::INIT_OK,
+            node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
   EXPECT_FALSE(node.GetNigoriSpecifics().sync_tabs());
 }
 
 TEST_F(SyncManagerTest, SyncTabsInNigoriNode) {
   const syncable::ModelTypeSet encrypted_types(syncable::SESSIONS);
   sync_manager_.MaybeSetSyncTabsInNigoriNode(encrypted_types);
 
   ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
   ReadNode node(&trans);
-  ASSERT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
+  ASSERT_EQ(BaseNode::INIT_OK,
+            node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
   EXPECT_TRUE(node.GetNigoriSpecifics().sync_tabs());
 }
 
 TEST_F(SyncManagerTest, ProcessJsMessage) {
   const JsArgList kNoArgs;
 
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue false_args;
   false_args.Append(Value::CreateBooleanValue(false));
@@ skipping 41 matching lines @@
   EXPECT_EQ(1u, return_args.Get().GetSize());
   ListValue* nodes = NULL;
   ASSERT_TRUE(return_args.Get().GetList(0, &nodes));
   ASSERT_TRUE(nodes);
   EXPECT_EQ(1u, nodes->GetSize());
   DictionaryValue* node_info = NULL;
   EXPECT_TRUE(nodes->GetDictionary(0, &node_info));
   ASSERT_TRUE(node_info);
   ReadTransaction trans(FROM_HERE, sync_manager.GetUserShare());
   ReadNode node(&trans);
-  EXPECT_TRUE(node.InitByIdLookup(id));
+  EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
   CheckNodeValue(node, *node_info, is_detailed);
 }
 
 class SyncManagerGetNodesByIdTest : public SyncManagerTest {
  protected:
   virtual ~SyncManagerGetNodesByIdTest() {}
 
   void RunGetNodesByIdTest(const char* message_name, bool is_detailed) {
     int64 root_id = kInvalidId;
     {
@@ skipping 296 matching lines @@
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
   const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 // Attempt to refresh encryption when nigori not downloaded.
 TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
@@ skipping 18 matching lines @@
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
   const syncable::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
@@ skipping 124 matching lines @@
 TEST_F(SyncManagerTest, SetInitialGaiaPass) {
   EXPECT_FALSE(SetUpEncryption(DONT_WRITE_NIGORI, UNINITIALIZED));
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", false);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 // Test that when there are no pending keys and we have on the old GAIA
 // password, we update and re-encrypt everything with the new GAIA password.
 // (case 1 in SyncManager::SyncInternal::SetEncryptionPassphrase)
@@ skipping 55 matching lines @@
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     // Verify the default key has changed.
     sync_pb::EncryptedData encrypted;
     cryptographer->GetKeys(&encrypted);
     EXPECT_FALSE(verifier.CanDecrypt(encrypted));
 
     ReadNode password_node(&trans);
-    EXPECT_TRUE(password_node.InitByClientTagLookup(syncable::PASSWORDS,
-                                                    "foo"));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              password_node.InitByClientTagLookup(syncable::PASSWORDS,
+                                                  "foo"));
     const sync_pb::PasswordSpecificsData& data =
         password_node.GetPasswordSpecifics();
     EXPECT_EQ("secret", data.password_value());
   }
 }
 
 // Manually set the pending keys in the cryptographer/nigori to reflect the data
 // being encrypted with a new (unprovided) GAIA password, then supply the
 // password.
 // (case 7 in SyncManager::SyncInternal::SetDecryptionPassphrase)
 TEST_F(SyncManagerTest, SupplyPendingGAIAPass) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   Cryptographer other_cryptographer(&encryptor_);
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     other_cryptographer.Bootstrap(bootstrap_token);
 
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "passphrase2"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encrypted());
     cryptographer->Update(nigori);
     EXPECT_TRUE(cryptographer->has_pending_keys());
     node.SetNigoriSpecifics(nigori);
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetDecryptionPassphrase("passphrase2");
@@ skipping 23 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     other_cryptographer.Bootstrap(bootstrap_token);
 
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "old_gaia"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encrypted());
     node.SetNigoriSpecifics(nigori);
     cryptographer->Update(nigori);
 
     // other_cryptographer now contains all encryption keys, and is encrypting
     // with the newest gaia.
     KeyParams new_params = {"localhost", "dummy", "new_gaia"};
     other_cryptographer.AddKey(new_params);
   }
@@ skipping 50 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     other_cryptographer.Bootstrap(bootstrap_token);
 
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "explicit"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encrypted());
     cryptographer->Update(nigori);
     EXPECT_TRUE(cryptographer->has_pending_keys());
     nigori.set_using_explicit_passphrase(true);
     node.SetNigoriSpecifics(nigori);
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
@@ skipping 18 matching lines @@
   EXPECT_FALSE(SetUpEncryption(DONT_WRITE_NIGORI, UNINITIALIZED));
   Cryptographer other_cryptographer(&encryptor_);
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     // Now update the nigori to reflect the new keys, and update the
     // cryptographer to have pending keys.
     KeyParams params = {"localhost", "dummy", "passphrase"};
     other_cryptographer.AddKey(params);
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByTagLookup(kNigoriTag));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByTagLookup(kNigoriTag));
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encrypted());
     node.SetNigoriSpecifics(nigori);
     cryptographer->Update(nigori);
     EXPECT_FALSE(cryptographer->is_ready());
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("passphrase", false);
@@ skipping 20 matching lines @@
     node_id = password_node.GetId();
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
-    EXPECT_FALSE(password_node.InitByClientTagLookup(syncable::PASSWORDS,
-                                                     tag));
+    EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
+              password_node.InitByClientTagLookup(syncable::PASSWORDS,
+                                                  tag));
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
-    EXPECT_FALSE(password_node.InitByIdLookup(node_id));
+    EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
+              password_node.InitByIdLookup(node_id));
   }
 }
 
 TEST_F(SyncManagerTest, NudgeDelayTest) {
   EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::BOOKMARKS),
       base::TimeDelta::FromMilliseconds(
           SyncManager::kDefaultNudgeDelayMilliseconds));
 
   EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::AUTOFILL),
       base::TimeDelta::FromSeconds(
@@ skipping 18 matching lines @@
   // Create a bookmark using the legacy format.
   int64 node_id1 = MakeNode(sync_manager_.GetUserShare(),
       syncable::BOOKMARKS,
       "testtag");
   int64 node_id2 = MakeNode(sync_manager_.GetUserShare(),
       syncable::BOOKMARKS,
       "testtag2");
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByIdLookup(node_id1));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
 
     sync_pb::EntitySpecifics entity_specifics;
     entity_specifics.mutable_bookmark()->set_url(url);
     node.SetEntitySpecifics(entity_specifics);
 
     // Set the old style title.
     syncable::MutableEntry* node_entry = node.entry_;
     node_entry->Put(syncable::NON_UNIQUE_NAME, title);
 
     WriteNode node2(&trans);
-    EXPECT_TRUE(node2.InitByIdLookup(node_id2));
+    EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
 
     sync_pb::EntitySpecifics entity_specifics2;
     entity_specifics2.mutable_bookmark()->set_url(url2);
     node2.SetEntitySpecifics(entity_specifics2);
 
     // Set the old style title.
     syncable::MutableEntry* node_entry2 = node2.entry_;
     node_entry2->Put(syncable::NON_UNIQUE_NAME, title2);
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByIdLookup(node_id1));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
     EXPECT_EQ(syncable::BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
 
     ReadNode node2(&trans);
-    EXPECT_TRUE(node2.InitByIdLookup(node_id2));
+    EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
     EXPECT_EQ(syncable::BOOKMARKS, node2.GetModelType());
     // We should de-canonicalize the title in GetTitle(), but the title in the
     // specifics should be stored in the server legal form.
     EXPECT_EQ(raw_title2, node2.GetTitle());
     EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
     EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
@@ skipping 15 matching lines @@
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
         syncable::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         syncable::BOOKMARKS,
         true /* is encrypted */));
 
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByIdLookup(node_id1));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
     EXPECT_EQ(syncable::BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
 
     ReadNode node2(&trans);
-    EXPECT_TRUE(node2.InitByIdLookup(node_id2));
+    EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
     EXPECT_EQ(syncable::BOOKMARKS, node2.GetModelType());
     // We should de-canonicalize the title in GetTitle(), but the title in the
     // specifics should be stored in the server legal form.
     EXPECT_EQ(raw_title2, node2.GetTitle());
     EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
     EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
   }
 }
 
 // Create a bookmark and set the title/url, then verify the data was properly
@@ skipping 12 matching lines @@
     node.SetTitle(UTF8ToWide(title));
     node.SetURL(url);
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     int64 child_id = root_node.GetFirstChildId();
 
     ReadNode node(&trans);
-    ASSERT_TRUE(node.InitByIdLookup(child_id));
+    ASSERT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
     EXPECT_FALSE(node.GetIsFolder());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(url, node.GetURL());
   }
 }
 
 // Verifies WriteNode::UpdateEntryWithEncryption does not make unnecessary
 // changes.
 TEST_F(SyncManagerTest, UpdateEntryWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
                   HasModelTypes(syncable::ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
 
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Set a new passphrase. Should set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_FALSE(node_entry->Get(IS_UNSYNCED));
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     entity_specifics.mutable_bookmark()->set_url("url2");
     entity_specifics.mutable_bookmark()->set_title("title2");
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_TRUE(node_entry->Get(IS_UNSYNCED));
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
                     specifics.encrypted()));
   }
@@ skipping 20 matching lines @@
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Manually change to the same data via SetEntitySpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via SetPasswordSpecifics.
 TEST_F(SyncManagerTest, UpdatePasswordSetPasswordSpecifics) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
@@ skipping 13 matching lines @@
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Manually change to the same data via SetPasswordSpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
     node.SetPasswordSpecifics(node.GetPasswordSpecifics());
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PASSWORDS, client_tag));
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret2");
     cryptographer->Encrypt(
         data,
         entity_specifics.mutable_password()->mutable_encrypted());
     node.SetPasswordSpecifics(data);
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_TRUE(node_entry->Get(IS_UNSYNCED));
   }
@@ skipping 71 matching lines @@
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // bookmarks when we write the same data, but does set it when we write new
 // data.
 TEST_F(SyncManagerTest, SetBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
@@ skipping 15 matching lines @@
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 
   // Manually change to new title. Should set is_unsynced. NON_UNIQUE_NAME
   // should still be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for non-bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetNonBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_preference()->set_name("name");
   entity_specifics.mutable_preference()->set_value("value");
   MakeServerNode(sync_manager_.GetUserShare(),
                  syncable::PREFERENCES,
                  client_tag,
                  BaseNode::GenerateSyncableHash(syncable::PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // non-bookmarks when we write the same data or when we write new data
 // data (should remained kEncryptedString).
 TEST_F(SyncManagerTest, SetNonBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
@@ skipping 17 matching lines @@
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
 
   // Manually change to new title. Should not set is_unsynced because the
   // NON_UNIQUE_NAME should still be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     EXPECT_FALSE(node_entry->Get(IS_UNSYNCED));
   }
 }
 
 // Create an encrypted entry when the cryptographer doesn't think the type is
@@ skipping 19 matching lines @@
   }
   MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
 
   {
     // Verify the data.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url), node.GetURL());
   }
 
   {
     // Overwrite the url (which overwrites the specifics).
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     node.SetURL(GURL(url2));
   }
 
   {
     // Verify it's still encrypted and it has the most recent url.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_TRUE(node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
+    EXPECT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(syncable::BOOKMARKS, client_tag));
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url2), node.GetURL());
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
   }
 }
 
 }  // namespace browser_sync