[Sync] Expose change location in GenericChangeProcessor errors

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 190 matching lines @@
     syncer::ModelType type,
     const std::string& type_str,
     syncer::WriteNode* node,
     DataTypeErrorHandler* error_handler) {
   DCHECK_EQ(change.change_type(), syncer::SyncChange::ACTION_DELETE);
   if (change.sync_data().IsLocal()) {
     const std::string& tag = change.sync_data().GetTag();
     if (tag.empty()) {
       syncer::SyncError error(
           FROM_HERE,
-          "Failed to delete " + type_str + " node. Local data, empty tag.",
+          "Failed to delete " + type_str + " node. Local data, empty tag. " +
+              change.location().ToString(),
           type);
       error_handler->OnSingleDatatypeUnrecoverableError(error.location(),
                                                         error.message());
       NOTREACHED();
       return error;
     }
 
     syncer::BaseNode::InitByLookupResult result =
         node->InitByClientTagLookup(change.sync_data().GetDataType(), tag);
     if (result != syncer::BaseNode::INIT_OK) {
       return LogLookupFailure(
           result, FROM_HERE,
-          "Failed to delete " + type_str + " node. Local data, ",
+          "Failed to delete " + type_str + " node. Local data. " +
+              change.location().ToString(),
           type, error_handler);
     }
   } else {
     syncer::BaseNode::InitByLookupResult result =
         node->InitByIdLookup(change.sync_data().GetRemoteId());
     if (result != syncer::BaseNode::INIT_OK) {
       return LogLookupFailure(
           result, FROM_HERE,
-          "Failed to delete " + type_str + " node. Non-local data, ",
+          "Failed to delete " + type_str + " node. Non-local data. " +
+              change.location().ToString(),
           type, error_handler);
     }
   }
   node->Remove();
   return syncer::SyncError();
 }
 
 }  // namespace
 
 // WARNING: this code is sensitive to compiler optimizations. Be careful
@@ skipping 36 matching lines @@
                                                             error.message());
         NOTREACHED();
         LOG(ERROR) << "Create: no root node.";
         return error;
       }
       syncer::WriteNode::InitUniqueByCreationResult result =
           sync_node.InitUniqueByCreation(change.sync_data().GetDataType(),
                                           root_node,
                                           change.sync_data().GetTag());
       if (result != syncer::WriteNode::INIT_SUCCESS) {
-        std::string error_prefix = "Failed to create " + type_str + " node: ";
+        std::string error_prefix = "Failed to create " + type_str + " node: " +
+            change.location().ToString() + ", ";
         switch (result) {
           case syncer::WriteNode::INIT_FAILED_EMPTY_TAG: {
             syncer::SyncError error;
             error.Reset(FROM_HERE, error_prefix + "empty tag", type);
             error_handler()->OnSingleDatatypeUnrecoverableError(
                 FROM_HERE, error.message());
             LOG(ERROR) << "Create: Empty tag.";
             return error;
           }
           case syncer::WriteNode::INIT_FAILED_ENTRY_ALREADY_EXISTS: {
@@ skipping 33 matching lines @@
         }
       }
       sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
     } else if (change.change_type() == syncer::SyncChange::ACTION_UPDATE) {
       // TODO(zea): consider having this logic for all possible changes?
       syncer::BaseNode::InitByLookupResult result =
           sync_node.InitByClientTagLookup(change.sync_data().GetDataType(),
                                           change.sync_data().GetTag());
       if (result != syncer::BaseNode::INIT_OK) {
+        std::string error_prefix = "Failed to load " + type_str + " node. " +
+            change.location().ToString() + ", ";
         if (result == syncer::BaseNode::INIT_FAILED_PRECONDITION) {
           syncer::SyncError error;
           error.Reset(FROM_HERE,
-                      "Failed to load entry w/empty tag for " + type_str + ".",
+                      error_prefix + "empty tag",
                       type);
           error_handler()->OnSingleDatatypeUnrecoverableError(
               FROM_HERE, error.message());
           LOG(ERROR) << "Update: Empty tag.";
           return error;
         } else if (result == syncer::BaseNode::INIT_FAILED_ENTRY_NOT_GOOD) {
           syncer::SyncError error;
           error.Reset(FROM_HERE,
-                      "Failed to load bad entry for " + type_str + ".",
+                      error_prefix + "bad entry",
                       type);
           error_handler()->OnSingleDatatypeUnrecoverableError(
               FROM_HERE, error.message());
           LOG(ERROR) << "Update: bad entry.";
           return error;
         } else if (result == syncer::BaseNode::INIT_FAILED_ENTRY_IS_DEL) {
           syncer::SyncError error;
           error.Reset(FROM_HERE,
-                      "Failed to load deleted entry for " + type_str + ".",
+                      error_prefix + "deleted entry",
                       type);
           error_handler()->OnSingleDatatypeUnrecoverableError(
               FROM_HERE, error.message());
           LOG(ERROR) << "Update: deleted entry.";
           return error;
         } else {
           syncer::Cryptographer* crypto = trans.GetCryptographer();
           syncer::ModelTypeSet encrypted_types(crypto->GetEncryptedTypes());
           const sync_pb::EntitySpecifics& specifics =
               sync_node.GetEntry()->Get(syncer::syncable::SPECIFICS);
@@ skipping 44 matching lines @@
         }
       } else {
         sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
         sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
         // TODO(sync): Support updating other parts of the sync node (title,
         // successor, parent, etc.).
       }
     } else {
       syncer::SyncError error(
           FROM_HERE,
-          "Received unset syncer::SyncChange in the change processor.",
+          "Received unset SyncChange in the change processor, " +
+              change.location().ToString(),
           type);
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           error.message());
       NOTREACHED();
       LOG(ERROR) << "Unset sync change.";
       return error;
     }
   }
   return syncer::SyncError();
 }
@@ skipping 39 matching lines @@
 void GenericChangeProcessor::StopImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync