Add additional error logging to investigate Autocomplete Sync failures.

sync/internal_api/write_node.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.
 
 #include "sync/internal_api/write_node.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "sync/engine/nigori_util.h"
 #include "sync/internal_api/base_transaction.h"
@@ skipping 346 matching lines @@
   // Now set the predecessor, which sets IS_UNSYNCED as necessary.
   return PutPredecessor(predecessor);
 }
 
 // Create a new node with default properties and a client defined unique tag,
 // and bind this WriteNode to it.
 // Return true on success. If the tag exists in the database, then
 // we will attempt to undelete the node.
 // TODO(chron): Code datatype into hash tag.
 // TODO(chron): Is model type ever lost?
-bool WriteNode::InitUniqueByCreation(syncable::ModelType model_type,
-                                     const BaseNode& parent,
-                                     const std::string& tag) {
-  DCHECK(!entry_) << "Init called twice";
+WriteNode::InitUniqueByCreationResult WriteNode::InitUniqueByCreation(
+    syncable::ModelType model_type,
+    const BaseNode& parent,
+    const std::string& tag) {
+  // This DCHECK will only fail if init is called twice.

[tim (not reviewing), 2012/05/17 00:22:10]

Is there a reason to not stream this to the dcheck?

[Ilya Sherman, 2012/05/17 00:40:04]

I removed the streaming based on this thread: [1 (note: page 2 of 2)].  The
string adds to the binary size without adding any info that can't be inferred
from the call site.  

[1]
https://groups.google.com/a/chromium.org/group/chromium-dev/browse_thread/thr...

+  DCHECK(!entry_);
   if (tag.empty()) {
     LOG(WARNING) << "InitUniqueByCreation failed due to empty tag.";
-    return false;
+    return INIT_FAILED_EMPTY_TAG;
   }
 
   const std::string hash = GenerateSyncableHash(model_type, tag);
 
   syncable::Id parent_id = parent.GetEntry()->Get(syncable::ID);
 
   // Start out with a dummy name.  We expect
   // the caller to set a meaningful name after creation.
   string dummy(kDefaultNameForNewNodes);
 
@@ skipping 24 matching lines @@
       // Client tags are immutable and must be paired with the ID.
       // If a server update comes down with an ID and client tag combo,
       // and it already exists, always overwrite it and store only one copy.
       // We have to undelete entries because we can't disassociate IDs from
       // tags and updates.
 
       existing_entry->Put(syncable::NON_UNIQUE_NAME, dummy);
       existing_entry->Put(syncable::PARENT_ID, parent_id);
       entry_ = existing_entry.release();
     } else {
-      return false;
+      return INIT_FAILED_ENTRY_ALREADY_EXISTS;
     }
   } else {
     entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                         syncable::CREATE, parent_id, dummy);
-    if (!entry_->good()) {
-      return false;
-    }
+    if (!entry_->good())
+      return INIT_FAILED_COULD_NOT_CREATE_ENTRY;
 
     // Only set IS_DIR for new entries. Don't bitflip undeleted ones.
     entry_->Put(syncable::UNIQUE_CLIENT_TAG, hash);
   }
 
   // We don't support directory and tag combinations.
   entry_->Put(syncable::IS_DIR, false);
 
   // Will clear specifics data.
   PutModelType(model_type);
 
   // Now set the predecessor, which sets IS_UNSYNCED as necessary.
-  return PutPredecessor(NULL);
+  bool success = PutPredecessor(NULL);
+  if (!success)
+    return INIT_FAILED_SET_PREDECESSOR;
+
+  return INIT_SUCCESS;
 }
 
 bool WriteNode::SetPosition(const BaseNode& new_parent,
                             const BaseNode* predecessor) {
   // |predecessor| must be a child of |new_parent| or NULL.
   if (predecessor && predecessor->GetParentId() != new_parent.GetId()) {
     DCHECK(false);
     return false;
   }
 
@@ skipping 45 matching lines @@
   sync_pb::BookmarkSpecifics new_value = GetBookmarkSpecifics();
   new_value.set_favicon(bytes.empty() ? NULL : &bytes[0], bytes.size());
   SetBookmarkSpecifics(new_value);
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 } // namespace sync_api