sync: don't make DataTypeErrorHandler inherit UnrecoverableErrorHandler

chrome/browser/sync/glue/bookmark_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/bookmark_change_processor.h"
 
 #include <stack>
 #include <vector>
 
 #include "base/location.h"
@@ skipping 159 matching lines @@
     BookmarkModelAssociator* associator,
     DataTypeErrorHandler* error_handler) {
   const BookmarkNode* child = parent->GetChild(index);
   DCHECK(child);
 
   // Create a WriteNode container to hold the new node.
   sync_api::WriteNode sync_child(trans);
 
   // Actually create the node with the appropriate initial position.
   if (!PlaceSyncNode(CREATE, parent, index, trans, &sync_child, associator)) {
-    error_handler->OnUnrecoverableError(FROM_HERE,
+    error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
         "Sync node creation failed; recovery unlikely");
     return sync_api::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());
 
@@ skipping 105 matching lines @@
   // Lookup the sync node that's associated with |child|.
   sync_api::WriteNode sync_node(&trans);
   if (!model_associator_->InitSyncNodeFromChromeId(child->id(), &sync_node)) {
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         std::string());
     return;
   }
 
   if (!PlaceSyncNode(MOVE, new_parent, new_index, &trans, &sync_node,
                      model_associator_)) {
-    error_handler()->OnUnrecoverableError(FROM_HERE, std::string());
+    error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
+                                                        std::string());
     return;
   }
 }
 
 void BookmarkChangeProcessor::BookmarkNodeFaviconChanged(
     BookmarkModel* model,
     const BookmarkNode* node) {
   DCHECK(running());
   BookmarkNodeChanged(model, node);
 }
@@ skipping 12 matching lines @@
                                                      &sync_child)) {
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           std::string());
       return;
     }
     DCHECK_EQ(sync_child.GetParentId(),
               model_associator_->GetSyncIdFromChromeId(node->id()));
 
     if (!PlaceSyncNode(MOVE, node, i, &trans, &sync_child,
                        model_associator_)) {
-      error_handler()->OnUnrecoverableError(FROM_HERE, std::string());
+      error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
+                                                          std::string());
       return;
     }
   }
 }
 
 // static
 bool BookmarkChangeProcessor::PlaceSyncNode(MoveOrCreate operation,
       const BookmarkNode* parent, int index, sync_api::WriteTransaction* trans,
       sync_api::WriteNode* dst, BookmarkModelAssociator* associator) {
   sync_api::ReadNode sync_parent(trans);
@@ skipping 111 matching lines @@
       // reparented by a later change record.  Move them to a temporary place.
       if (!dst) // Can't do anything if we can't find the chrome node.
         continue;
       const BookmarkNode* parent = dst->parent();
       if (!dst->empty()) {
         if (!foster_parent) {
           foster_parent = model->AddFolder(model->other_node(),
                                            model->other_node()->child_count(),
                                            string16());
           if (!foster_parent) {
-            error_handler()->OnUnrecoverableError(FROM_HERE,
+            error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                 "Failed to create foster parent.");
             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 166 matching lines @@
     const BookmarkNode* bookmark_node,
     BookmarkModel* model,
     sync_api::WriteNode* sync_node) {
   std::vector<unsigned char> favicon_bytes;
   EncodeFavicon(bookmark_node, model, &favicon_bytes);
   if (!favicon_bytes.empty())
     sync_node->SetFaviconBytes(favicon_bytes);
 }
 
 }  // namespace browser_sync