[Sync] Use OnSingleDataTypeUnrecoverableError for all errors

components/sync_driver/generic_change_processor.cc

 // Copyright 2014 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 "components/sync_driver/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sync_driver/sync_api_component_factory.h"
@@ skipping 126 matching lines @@
                                  base::Time(),
                                  empty_list_of_attachment_ids,
                                  attachment_service_proxy_)));
     } else {
       syncer::SyncChange::SyncChangeType action =
           (it->action == syncer::ChangeRecord::ACTION_ADD) ?
           syncer::SyncChange::ACTION_ADD : syncer::SyncChange::ACTION_UPDATE;
       // Need to load specifics from node.
       syncer::ReadNode read_node(trans);
       if (read_node.InitByIdLookup(it->id) != syncer::BaseNode::INIT_OK) {
-        error_handler()->OnSingleDatatypeUnrecoverableError(
+        syncer::SyncError error(
             FROM_HERE,
+            syncer::SyncError::DATATYPE_ERROR,
             "Failed to look up data for received change with id " +
-                base::Int64ToString(it->id));
+                base::Int64ToString(it->id),
+            syncer::GetModelTypeFromSpecifics(it->specifics));
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         return;
       }
       syncer_changes_.push_back(syncer::SyncChange(
           FROM_HERE,
           action,
           BuildRemoteSyncData(it->id, read_node, attachment_service_proxy_)));
     }
   }
 }
 
 void GenericChangeProcessor::CommitChangesFromSyncModel() {
   DCHECK(CalledOnValidThread());
   if (syncer_changes_.empty())
     return;
   if (!local_service_.get()) {
     syncer::ModelType type = syncer_changes_[0].sync_data().GetDataType();
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
                             "Local service destroyed.",
                             type);
-    error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
-                                                        error.message());
+    error_handler()->OnSingleDataTypeUnrecoverableError(error);
     return;
   }
   syncer::SyncError error = local_service_->ProcessSyncChanges(FROM_HERE,
                                                        syncer_changes_);
   syncer_changes_.clear();
-  if (error.IsSet()) {
-    error_handler()->OnSingleDatatypeUnrecoverableError(
-        error.location(), error.message());
-  }
+  if (error.IsSet())
+    error_handler()->OnSingleDataTypeUnrecoverableError(error);
 }
 
 syncer::SyncDataList GenericChangeProcessor::GetAllSyncData(
     syncer::ModelType type) const {
   // This is slow / memory intensive.  Should be used sparingly by datatypes.
   syncer::SyncDataList data;
   GetAllSyncDataReturnError(type, &data);
   return data;
 }
 
@@ skipping 86 matching lines @@
   syncer::ReadNode root(&trans);
   if (root.InitTypeRoot(type) != syncer::BaseNode::INIT_OK)
     return 0;
 
   // Subtract one to account for type's root node.
   return root.GetTotalNodeCount() - 1;
 }
 
 namespace {
 
-// TODO(isherman): Investigating http://crbug.com/121592
 // WARNING: this code is sensitive to compiler optimizations. Be careful
-// modifying any code around an OnSingleDatatypeUnrecoverableError call, else
+// modifying any code around an OnSingleDataTypeUnrecoverableError call, else
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError LogLookupFailure(
     syncer::BaseNode::InitByLookupResult lookup_result,
     const tracked_objects::Location& from_here,
     const std::string& error_prefix,
     syncer::ModelType type,
     DataTypeErrorHandler* error_handler) {
   switch (lookup_result) {
     case syncer::BaseNode::INIT_FAILED_ENTRY_NOT_GOOD: {
       syncer::SyncError error;
       error.Reset(from_here,
                   error_prefix +
                       "could not find entry matching the lookup criteria.",
                   type);
-      error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        error.message());
+      error_handler->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Delete: Bad entry.";
       return error;
     }
     case syncer::BaseNode::INIT_FAILED_ENTRY_IS_DEL: {
       syncer::SyncError error;
       error.Reset(from_here, error_prefix + "entry is already deleted.", type);
-      error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        error.message());
+      error_handler->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Delete: Deleted entry.";
       return error;
     }
     case syncer::BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY: {
       syncer::SyncError error;
       error.Reset(from_here, error_prefix + "unable to decrypt", type);
-      error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        error.message());
+      error_handler->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Delete: Undecryptable entry.";
       return error;
     }
     case syncer::BaseNode::INIT_FAILED_PRECONDITION: {
       syncer::SyncError error;
       error.Reset(from_here,
                   error_prefix + "a precondition was not met for calling init.",
                   type);
-      error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        error.message());
+      error_handler->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Delete: Failed precondition.";
       return error;
     }
     default: {
       syncer::SyncError error;
       // Should have listed all the possible error cases above.
       error.Reset(from_here, error_prefix + "unknown error", type);
-      error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        error.message());
+      error_handler->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Delete: Unknown error.";
       return error;
     }
   }
 }
 
 syncer::SyncError AttemptDelete(const syncer::SyncChange& change,
                                 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 = syncer::SyncDataLocal(change.sync_data()).GetTag();
     if (tag.empty()) {
       syncer::SyncError error(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "Failed to delete " + type_str + " node. Local data, empty tag. " +
               change.location().ToString(),
           type);
-      error_handler->OnSingleDatatypeUnrecoverableError(error.location(),
-                                                        error.message());
+      error_handler->OnSingleDataTypeUnrecoverableError(error);
       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. " +
@@ skipping 81 matching lines @@
       if (error.IsSet()) {
         return error;
       }
     } else {
       syncer::SyncError error(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "Received unset SyncChange in the change processor, " +
               change.location().ToString(),
           type);
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          error.message());
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       NOTREACHED();
       LOG(ERROR) << "Unset sync change.";
       return error;
     }
   }
 
   if (!new_attachments.empty()) {
     StoreAttachments(attachment_service_.get(), new_attachments);
   }
 
   return syncer::SyncError();
 }
 
 // WARNING: this code is sensitive to compiler optimizations. Be careful
-// modifying any code around an OnSingleDatatypeUnrecoverableError call, else
+// modifying any code around an OnSingleDataTypeUnrecoverableError call, else
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError GenericChangeProcessor::HandleActionAdd(
     const syncer::SyncChange& change,
     const std::string& type_str,
     const syncer::ModelType& type,
     const syncer::WriteTransaction& trans,
     syncer::WriteNode* sync_node,
     syncer::AttachmentList* new_attachments) {
   // TODO(sync): Handle other types of creation (custom parents, folders,
   // etc.).
   syncer::ReadNode root_node(&trans);
   const syncer::SyncDataLocal sync_data_local(change.sync_data());
   if (root_node.InitTypeRoot(sync_data_local.GetDataType()) !=
       syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
                             "Failed to look up root node for type " + type_str,
                             type);
-    error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        error.message());
+    error_handler()->OnSingleDataTypeUnrecoverableError(error);
     NOTREACHED();
     LOG(ERROR) << "Create: no root node.";
     return error;
   }
   syncer::WriteNode::InitUniqueByCreationResult result =
       sync_node->InitUniqueByCreation(
           sync_data_local.GetDataType(), root_node, sync_data_local.GetTag());
   if (result != syncer::WriteNode::INIT_SUCCESS) {
     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());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Create: Empty tag.";
         return error;
       }
       case syncer::WriteNode::INIT_FAILED_ENTRY_ALREADY_EXISTS: {
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "entry already exists", type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Create: Entry exists.";
         return error;
       }
       case syncer::WriteNode::INIT_FAILED_COULD_NOT_CREATE_ENTRY: {
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "failed to create entry", type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Create: Could not create entry.";
         return error;
       }
       case syncer::WriteNode::INIT_FAILED_SET_PREDECESSOR: {
         syncer::SyncError error;
         error.Reset(
             FROM_HERE, error_prefix + "failed to set predecessor", type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Create: Bad predecessor.";
         return error;
       }
       default: {
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "unknown error", type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Create: Unknown error.";
         return error;
       }
     }
   }
   sync_node->SetTitle(change.sync_data().GetTitle());
   SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node);
 
   syncer::AttachmentIdList attachment_ids = sync_data_local.GetAttachmentIds();
   SetAttachmentMetadata(attachment_ids, sync_node);
 
   // Return any newly added attachments.
   const syncer::AttachmentList& local_attachments_for_upload =
       sync_data_local.GetLocalAttachmentsForUpload();
   new_attachments->insert(new_attachments->end(),
                           local_attachments_for_upload.begin(),
                           local_attachments_for_upload.end());
 
   if (merge_result_.get()) {
     merge_result_->set_num_items_added(merge_result_->num_items_added() + 1);
   }
   return syncer::SyncError();
 }
 // WARNING: this code is sensitive to compiler optimizations. Be careful
-// modifying any code around an OnSingleDatatypeUnrecoverableError call, else
+// modifying any code around an OnSingleDataTypeUnrecoverableError call, else
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError GenericChangeProcessor::HandleActionUpdate(
     const syncer::SyncChange& change,
     const std::string& type_str,
     const syncer::ModelType& type,
     const syncer::WriteTransaction& trans,
     syncer::WriteNode* sync_node,
     syncer::AttachmentList* new_attachments) {
   // TODO(zea): consider having this logic for all possible changes?
 
   const syncer::SyncDataLocal sync_data_local(change.sync_data());
   syncer::BaseNode::InitByLookupResult result =
       sync_node->InitByClientTagLookup(sync_data_local.GetDataType(),
                                        sync_data_local.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, error_prefix + "empty tag", type);
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          error.message());
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Update: Empty tag.";
       return error;
     } else if (result == syncer::BaseNode::INIT_FAILED_ENTRY_NOT_GOOD) {
       syncer::SyncError error;
       error.Reset(FROM_HERE, error_prefix + "bad entry", type);
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          error.message());
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Update: bad entry.";
       return error;
     } else if (result == syncer::BaseNode::INIT_FAILED_ENTRY_IS_DEL) {
       syncer::SyncError error;
       error.Reset(FROM_HERE, error_prefix + "deleted entry", type);
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          error.message());
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       LOG(ERROR) << "Update: deleted entry.";
       return error;
     } else {
       syncer::Cryptographer* crypto = trans.GetCryptographer();
       syncer::ModelTypeSet encrypted_types(trans.GetEncryptedTypes());
       const sync_pb::EntitySpecifics& specifics =
           sync_node->GetEntry()->GetSpecifics();
       CHECK(specifics.has_encrypted());
       const bool can_decrypt = crypto->CanDecrypt(specifics.encrypted());
       const bool agreement = encrypted_types.Has(type);
       if (!agreement && !can_decrypt) {
         syncer::SyncError error;
         error.Reset(FROM_HERE,
                     "Failed to load encrypted entry, missing key and "
                     "nigori mismatch for " +
                         type_str + ".",
                     type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Update: encr case 1.";
         return error;
       } else if (agreement && can_decrypt) {
         syncer::SyncError error;
         error.Reset(FROM_HERE,
                     "Failed to load encrypted entry, we have the key "
                     "and the nigori matches (?!) for " +
                         type_str + ".",
                     type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Update: encr case 2.";
         return error;
       } else if (agreement) {
         syncer::SyncError error;
         error.Reset(FROM_HERE,
                     "Failed to load encrypted entry, missing key and "
                     "the nigori matches for " +
                         type_str + ".",
                     type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Update: encr case 3.";
         return error;
       } else {
         syncer::SyncError error;
         error.Reset(FROM_HERE,
                     "Failed to load encrypted entry, we have the key"
                     "(?!) and nigori mismatch for " +
                         type_str + ".",
                     type);
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            error.message());
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         LOG(ERROR) << "Update: encr case 4.";
         return error;
       }
     }
   }
 
   sync_node->SetTitle(change.sync_data().GetTitle());
   SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node);
   SetAttachmentMetadata(sync_data_local.GetAttachmentIds(), sync_node);
 
@@ skipping 48 matching lines @@
 
 void GenericChangeProcessor::StartImpl() {
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace sync_driver