Add additional error logging to investigate Autocomplete Sync failures.

chrome/browser/sync/glue/generic_change_processor.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 "chrome/browser/sync/glue/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 173 matching lines @@
               syncable::ModelTypeToRootTag(change.sync_data().GetDataType())) !=
                   sync_api::BaseNode::INIT_OK) {
         NOTREACHED();
         SyncError error(FROM_HERE,
                         "Failed to look up root node for type " + type_str,
                         type);
         error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                             error.message());
         return error;
       }
-      if (!sync_node.InitUniqueByCreation(change.sync_data().GetDataType(),
+      sync_api::WriteNode::InitUniqueByCreationResult result =
+          sync_node.InitUniqueByCreation(change.sync_data().GetDataType(),
                                           root_node,
-                                          change.sync_data().GetTag())) {
+                                          change.sync_data().GetTag());
+      if (result != sync_api::WriteNode::INIT_SUCCESS) {
         NOTREACHED();
-        SyncError error(FROM_HERE,
-                        "Failed to create " + type_str + " node.",
+        std::string error_prefix = "Failed to create " + type_str + " node: ";
+        SyncError error;
+        switch (result) {
+          case sync_api::WriteNode::INIT_FAILED_EMPTY_TAG:
+            error.Reset(FROM_HERE, error_prefix + "empty tag", type);
+            error_handler()->OnSingleDatatypeUnrecoverableError(
+                error.location(), error.message());
+            return error;
+          case sync_api::WriteNode::INIT_FAILED_ENTRY_ALREADY_EXISTS:
+            error.Reset(FROM_HERE, error_prefix + "entry already exists", type);
+            error_handler()->OnSingleDatatypeUnrecoverableError(
+                error.location(), error.message());
+            return error;
+          case sync_api::WriteNode::INIT_FAILED_COULD_NOT_CREATE_ENTRY:
+            error.Reset(FROM_HERE, error_prefix + "failed to create entry",
                         type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
-                                                            error.message());
-        return error;
+            error_handler()->OnSingleDatatypeUnrecoverableError(
+                error.location(), error.message());
+            return error;
+          case sync_api::WriteNode::INIT_FAILED_SET_PREDECESSOR:
+            error.Reset(FROM_HERE, error_prefix + "failed to set predecessor",
+                        type);
+            error_handler()->OnSingleDatatypeUnrecoverableError(
+                error.location(), error.message());
+            return error;
+          default:
+            error.Reset(FROM_HERE, error_prefix + "unknown error", type);
+            error_handler()->OnSingleDatatypeUnrecoverableError(
+                error.location(), error.message());
+            return error;
+        }
       }
       sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
     } else if (change.change_type() == SyncChange::ACTION_UPDATE) {
       // TODO(zea): consider having this logic for all possible changes?
       sync_api::BaseNode::InitByLookupResult result =
           sync_node.InitByClientTagLookup(change.sync_data().GetDataType(),
                                           change.sync_data().GetTag());
       SyncError error;
       if (result != sync_api::BaseNode::INIT_OK) {
@@ skipping 121 matching lines @@
 void GenericChangeProcessor::StopImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 sync_api::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync