Add additional error logging to investigate Autocomplete Sync failures.

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 113 matching lines @@
 
 // Makes a non-folder child of the root node.  Returns the id of the
 // newly-created node.
 int64 MakeNode(UserShare* share,
                ModelType model_type,
                const std::string& client_tag) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
-  EXPECT_TRUE(node.InitUniqueByCreation(model_type, root_node, client_tag));
+  sync_api::WriteNode::InitUniqueByCreationResult result =
+      node.InitUniqueByCreation(model_type, root_node, client_tag);
+  EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
   node.SetIsFolder(false);
   return node.GetId();
 }
 
 // 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_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
   WriteNode node(&trans);
-  EXPECT_TRUE(node.InitUniqueByCreation(model_type, parent_node, client_tag));
+  sync_api::WriteNode::InitUniqueByCreationResult result =
+      node.InitUniqueByCreation(model_type, parent_node, client_tag);
+  EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
   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) {
@@ skipping 208 matching lines @@
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     // we'll use this spare folder later
     WriteNode folder_node(&trans);
     EXPECT_TRUE(folder_node.InitByCreation(syncable::BOOKMARKS,
         root_node, NULL));
     folder_id = folder_node.GetId();
 
     WriteNode wnode(&trans);
-    EXPECT_TRUE(wnode.InitUniqueByCreation(syncable::BOOKMARKS,
-        root_node, "testtag"));
+    sync_api::WriteNode::InitUniqueByCreationResult result =
+        wnode.InitUniqueByCreation(syncable::BOOKMARKS, root_node, "testtag");
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     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);
@@ skipping 19 matching lines @@
     EXPECT_EQ(node.GetTitle(), test_title);
   }
 
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode folder_node(&trans);
     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"));
+    sync_api::WriteNode::InitUniqueByCreationResult result =
+        wnode.InitUniqueByCreation(syncable::BOOKMARKS, folder_node, "testtag");
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     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());
@@ skipping 11 matching lines @@
   {
     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_api::WriteNode::InitUniqueByCreationResult result =
+        password_node.InitUniqueByCreation(syncable::PASSWORDS,
+                                           root_node, "foo");
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     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);
@@ skipping 12 matching lines @@
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     trans.GetCryptographer()->AddKey(params);
     trans.GetCryptographer()->set_encrypt_everything();
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode bookmark_node(&trans);
-    EXPECT_TRUE(bookmark_node.InitUniqueByCreation(syncable::BOOKMARKS,
-                                                   root_node, "foo"));
+    sync_api::WriteNode::InitUniqueByCreationResult result =
+        bookmark_node.InitUniqueByCreation(syncable::BOOKMARKS,
+                                           root_node, "foo");
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     bookmark_node.SetTitle(UTF8ToWide("foo"));
 
     WriteNode pref_node(&trans);
-    EXPECT_TRUE(pref_node.InitUniqueByCreation(syncable::PREFERENCES,
-                                               root_node, "bar"));
+    result =
+        pref_node.InitUniqueByCreation(syncable::PREFERENCES, root_node, "bar");
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     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_EQ(BaseNode::INIT_OK,
               bookmark_node.InitByClientTagLookup(syncable::BOOKMARKS,
@@ skipping 117 matching lines @@
     ADD_FAILURE();
   }
 }
 
 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));
+  sync_api::WriteNode::InitUniqueByCreationResult result =
+      node.InitUniqueByCreation(syncable::TYPED_URLS, root_node, empty_tag);
+  EXPECT_NE(sync_api::WriteNode::INIT_SUCCESS, result);
   EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
             node.InitByTagLookup(empty_tag));
 }
 
 namespace {
 
 class TestHttpPostProviderInterface : public HttpPostProviderInterface {
  public:
   virtual ~TestHttpPostProviderInterface() {}
 
@@ skipping 937 matching lines @@
     // Store the default (soon to be old) key.
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     verifier.Bootstrap(bootstrap_token);
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    EXPECT_TRUE(password_node.InitUniqueByCreation(syncable::PASSWORDS,
-                                                   root_node, "foo"));
+    sync_api::WriteNode::InitUniqueByCreationResult result =
+        password_node.InitUniqueByCreation(syncable::PASSWORDS,
+                                           root_node, "foo");
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
@@ skipping 210 matching lines @@
 TEST_F(SyncManagerTest, SetPassphraseWithEmptyPasswordNode) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   int64 node_id = 0;
   std::string tag = "foo";
   {
     WriteTransaction trans(FROM_HERE, 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_api::WriteNode::InitUniqueByCreationResult result =
+        password_node.InitUniqueByCreation(syncable::PASSWORDS, root_node, tag);
+    EXPECT_EQ(sync_api::WriteNode::INIT_SUCCESS, result);
     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);
@@ skipping 677 matching lines @@
     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