[Sync] Use OnSingleDataTypeUnrecoverableError for all errors

chrome/browser/sync/glue/bookmark_change_processor.cc

 // Copyright 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/bookmark_change_processor.h"
 
 #include <map>
 #include <stack>
 #include <vector>
 
@@ skipping 102 matching lines @@
 
 void BookmarkChangeProcessor::RemoveSyncNodeHierarchy(
     const BookmarkNode* topmost) {
   int64 new_version =
       syncer::syncable::kInvalidTransactionVersion;
   {
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
     syncer::WriteNode topmost_sync_node(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(topmost->id(),
                                                      &topmost_sync_node)) {
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          std::string());
+      syncer::SyncError error(FROM_HERE,
+                              syncer::SyncError::DATATYPE_ERROR,
+                              "Failed to init sync node from chrome node",
+                              syncer::BOOKMARKS);
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       return;
     }
     // Check that |topmost| has been unlinked.
     DCHECK(topmost->is_root());
     RemoveAllChildNodes(&trans, topmost->id());
     // Remove the node itself.
     RemoveOneSyncNode(&topmost_sync_node);
   }
 
   // Don't need to update versions of deleted nodes.
@@ skipping 21 matching lines @@
   // Don't need to update versions of deleted nodes.
   UpdateTransactionVersion(new_version, bookmark_model_,
                            std::vector<const BookmarkNode*>());
 }
 
 void BookmarkChangeProcessor::RemoveAllChildNodes(
     syncer::WriteTransaction* trans, const int64& topmost_node_id) {
   syncer::WriteNode topmost_node(trans);
   if (!model_associator_->InitSyncNodeFromChromeId(topmost_node_id,
                                                    &topmost_node)) {
-    error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                        std::string());
+    syncer::SyncError error(FROM_HERE,
+                            syncer::SyncError::DATATYPE_ERROR,
+                            "Failed to init sync node from chrome node",
+                            syncer::BOOKMARKS);
+    error_handler()->OnSingleDataTypeUnrecoverableError(error);
     return;
   }
   const int64 topmost_sync_id = topmost_node.GetId();
 
   // Do a DFS and delete all the child sync nodes, use sync id instead of
   // bookmark node ids since the bookmark nodes may already be deleted.
   // The equivalent recursive version of this iterative DFS:
   // remove_all_children(node_id, topmost_node_id):
   //    node.initByIdLookup(node_id)
   //    while(node.GetFirstChildId() != syncer::kInvalidId)
@@ skipping 87 matching lines @@
     BookmarkModelAssociator* associator,
     sync_driver::DataTypeErrorHandler* error_handler) {
   const BookmarkNode* child = parent->GetChild(index);
   DCHECK(child);
 
   // Create a WriteNode container to hold the new node.
   syncer::WriteNode sync_child(trans);
 
   // Actually create the node with the appropriate initial position.
   if (!PlaceSyncNode(CREATE, parent, index, trans, &sync_child, associator)) {
-    error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-        "Sync node creation failed; recovery unlikely");
+    syncer::SyncError error(FROM_HERE,
+                            syncer::SyncError::DATATYPE_ERROR,
+                            "Failed ot creat sync node.",
+                            syncer::BOOKMARKS);
+    error_handler->OnSingleDataTypeUnrecoverableError(error);
     return syncer::kInvalidId;
   }
 
   UpdateSyncNodeProperties(child, model, &sync_child);
 
   // Associate the ID from the sync domain with the bookmark node, so that we
   // can refer back to this item later.
   associator->Associate(child, sync_child.GetId());
 
   return sync_child.GetId();
@@ skipping 27 matching lines @@
 // Static.
 int64 BookmarkChangeProcessor::UpdateSyncNode(
     const BookmarkNode* node,
     BookmarkModel* model,
     syncer::WriteTransaction* trans,
     BookmarkModelAssociator* associator,
     sync_driver::DataTypeErrorHandler* error_handler) {
   // Lookup the sync node that's associated with |node|.
   syncer::WriteNode sync_node(trans);
   if (!associator->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
-    error_handler->OnSingleDatatypeUnrecoverableError(
-        FROM_HERE, "Could not load bookmark node on update.");
+    syncer::SyncError error(FROM_HERE,
+                            syncer::SyncError::DATATYPE_ERROR,
+                            "Failed to init sync node from chrome node",
+                            syncer::BOOKMARKS);
+    error_handler->OnSingleDataTypeUnrecoverableError(error);
     return syncer::kInvalidId;
   }
   UpdateSyncNodeProperties(node, model, &sync_node);
   DCHECK_EQ(sync_node.GetIsFolder(), node->is_folder());
   DCHECK_EQ(associator->GetChromeNodeFromSyncId(sync_node.GetParentId()),
             node->parent());
   DCHECK_EQ(node->parent()->GetIndexOf(node), sync_node.GetPositionIndex());
   return sync_node.GetId();
 }
 
@@ skipping 13 matching lines @@
   }
 
   int64 new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
 
     // Lookup the sync node that's associated with |child|.
     syncer::WriteNode sync_node(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(child->id(), &sync_node)) {
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          std::string());
+      syncer::SyncError error(FROM_HERE,
+                              syncer::SyncError::DATATYPE_ERROR,
+                              "Failed to init sync node from chrome node",
+                              syncer::BOOKMARKS);
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       return;
     }
 
     if (!PlaceSyncNode(MOVE, new_parent, new_index, &trans, &sync_node,
                        model_associator_)) {
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                          std::string());
+      syncer::SyncError error(FROM_HERE,
+                              syncer::SyncError::DATATYPE_ERROR,
+                              "Failed to place sync node",
+                              syncer::BOOKMARKS);
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       return;
     }
   }
 
   UpdateTransactionVersion(new_version, model,
                            std::vector<const BookmarkNode*>(1, child));
 }
 
 void BookmarkChangeProcessor::BookmarkNodeFaviconChanged(
     BookmarkModel* model,
@@ skipping 11 matching lines @@
 
     // The given node's children got reordered. We need to reorder all the
     // children of the corresponding sync node.
     for (int i = 0; i < node->child_count(); ++i) {
       const BookmarkNode* child = node->GetChild(i);
       children.push_back(child);
 
       syncer::WriteNode sync_child(&trans);
       if (!model_associator_->InitSyncNodeFromChromeId(child->id(),
                                                        &sync_child)) {
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            std::string());
+        syncer::SyncError error(FROM_HERE,
+                                syncer::SyncError::DATATYPE_ERROR,
+                                "Failed to init sync node from chrome node",
+                                syncer::BOOKMARKS);
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         return;
       }
       DCHECK_EQ(sync_child.GetParentId(),
                 model_associator_->GetSyncIdFromChromeId(node->id()));
 
       if (!PlaceSyncNode(MOVE, node, i, &trans, &sync_child,
                          model_associator_)) {
-        error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-                                                            std::string());
+        syncer::SyncError error(FROM_HERE,
+                                syncer::SyncError::DATATYPE_ERROR,
+                                "Failed to place sync node",
+                                syncer::BOOKMARKS);
+        error_handler()->OnSingleDataTypeUnrecoverableError(error);
         return;
       }
     }
   }
 
   // TODO(haitaol): Filter out children that didn't actually change.
   UpdateTransactionVersion(new_version, model, children);
 }
 
 // static
@@ skipping 101 matching lines @@
       continue;
 
     // Children of a deleted node should not be deleted; they may be
     // reparented by a later change record.  Move them to a temporary place.
     if (!dst->empty()) {
       if (!foster_parent) {
         foster_parent = model->AddFolder(model->other_node(),
                                          model->other_node()->child_count(),
                                          base::string16());
         if (!foster_parent) {
-          error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-              "Failed to create foster parent.");
+          syncer::SyncError error(FROM_HERE,
+                                  syncer::SyncError::DATATYPE_ERROR,
+                                  "Failed to create foster parent",
+                                  syncer::BOOKMARKS);
+          error_handler()->OnSingleDataTypeUnrecoverableError(error);
           return;
         }
       }
       for (int i = dst->child_count() - 1; i >= 0; --i) {
         model->Move(dst->GetChild(i), foster_parent,
                     foster_parent->child_count());
       }
     }
     DCHECK_EQ(dst->child_count(), 0) << "Node being deleted has children";
 
@@ skipping 36 matching lines @@
       // This is a newly created Synced Bookmarks node. Associate it.
       model_associator_->Associate(model->mobile_node(), it->id);
       continue;
     }
 
     DCHECK_NE(it->action, ChangeRecord::ACTION_DELETE)
         << "We should have passed all deletes by this point.";
 
     syncer::ReadNode src(trans);
     if (src.InitByIdLookup(it->id) != syncer::BaseNode::INIT_OK) {
-      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
-          "ApplyModelChanges was passed a bad ID");
+      syncer::SyncError error(FROM_HERE,
+                              syncer::SyncError::DATATYPE_ERROR,
+                              "Failed to load sync node",
+                              syncer::BOOKMARKS);
+      error_handler()->OnSingleDataTypeUnrecoverableError(error);
       return;
     }
 
     const BookmarkNode* parent =
         model_associator_->GetChromeNodeFromSyncId(src.GetParentId());
     if (!parent) {
       LOG(ERROR) << "Could not find parent of node being added/updated."
         << " Node title: " << src.GetTitle()
         << ", parent id = " << src.GetParentId();
       continue;
@@ skipping 237 matching lines @@
     sync_pb::BookmarkSpecifics updated_specifics(
         sync_node->GetBookmarkSpecifics());
     updated_specifics.set_favicon(favicon_bytes->front(),
                                   favicon_bytes->size());
     updated_specifics.set_icon_url(bookmark_node->icon_url().spec());
     sync_node->SetBookmarkSpecifics(updated_specifics);
   }
 }
 
 }  // namespace browser_sync