sync: Add location info to unrecoverable error.

chrome/browser/sync/glue/bookmark_change_processor.cc

 // Copyright (c) 2006-2009 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/string_util.h"
@@ skipping 59 matching lines @@
   // Re-encode the BookmarkNode's favicon as a PNG, and pass the data to the
   // sync subsystem.
   if (!gfx::PNGCodec::EncodeBGRASkBitmap(favicon, false, dst))
     return;
 }
 
 void BookmarkChangeProcessor::RemoveOneSyncNode(
     sync_api::WriteTransaction* trans, const BookmarkNode* node) {
   sync_api::WriteNode sync_node(trans);
   if (!model_associator_->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE, std::string());
     return;
   }
   // This node should have no children.
   DCHECK(sync_node.GetFirstChildId() == sync_api::kInvalidId);
   // Remove association and delete the sync node.
   model_associator_->Disassociate(sync_node.GetId());
   sync_node.Remove();
 }
 
 void BookmarkChangeProcessor::RemoveSyncNodeHierarchy(
@@ skipping 60 matching lines @@
     UnrecoverableErrorHandler* 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)) {
-    LOG(WARNING) << "Sync node creation failed; recovery unlikely";
-    error_handler->OnUnrecoverableError();
+    error_handler->OnUnrecoverableError(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());
 
   return sync_child.GetId();
@@ skipping 16 matching lines @@
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
 
   // Acquire a scoped write lock via a transaction.
   sync_api::WriteTransaction trans(share_handle());
 
   // Lookup the sync node that's associated with |node|.
   sync_api::WriteNode sync_node(&trans);
   if (!model_associator_->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE, std::string());
     return;
   }
 
   UpdateSyncNodeProperties(node, model, &sync_node);
 
   DCHECK_EQ(sync_node.GetIsFolder(), node->is_folder());
   DCHECK_EQ(model_associator_->GetChromeNodeFromSyncId(
             sync_node.GetParentId()),
             node->GetParent());
   // This node's index should be one more than the predecessor's index.
@@ skipping 13 matching lines @@
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
 
   // Acquire a scoped write lock via a transaction.
   sync_api::WriteTransaction trans(share_handle());
 
   // 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()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE, std::string());
     return;
   }
 
   if (!PlaceSyncNode(MOVE, new_parent, new_index, &trans, &sync_node,
                      model_associator_, error_handler())) {
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE, std::string());
     return;
   }
 }
 
 void BookmarkChangeProcessor::BookmarkNodeFavIconLoaded(BookmarkModel* model,
       const BookmarkNode* node) {
   DCHECK(running());
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkChangeProcessor::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
 
   // Acquire a scoped write lock via a transaction.
   sync_api::WriteTransaction trans(share_handle());
 
   // 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->GetChildCount(); ++i) {
     sync_api::WriteNode sync_child(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(node->GetChild(i)->id(),
                                                      &sync_child)) {
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(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())) {
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(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,
       UnrecoverableErrorHandler* error_handler) {
   sync_api::ReadNode sync_parent(trans);
   if (!associator->InitSyncNodeFromChromeId(parent->id(), &sync_parent)) {
     LOG(WARNING) << "Parent lookup failed";
-    error_handler->OnUnrecoverableError();
+    error_handler->OnUnrecoverableError(FROM_HERE, std::string());
     return false;
   }
 
   bool success = false;
   if (index == 0) {
     // Insert into first position.
     success = (operation == CREATE) ?
         dst->InitByCreation(syncable::BOOKMARKS, sync_parent, NULL) :
         dst->SetPosition(sync_parent, NULL);
     if (success) {
@@ skipping 110 matching lines @@
       model_associator_->Disassociate(changes[i].id);
       model->Remove(parent, parent->IndexOfChild(dst));
       dst = NULL;
     } else {
       DCHECK_EQ((changes[i].action ==
           sync_api::SyncManager::ChangeRecord::ACTION_ADD), (dst == NULL))
           << "ACTION_ADD should be seen if and only if the node is unknown.";
 
       sync_api::ReadNode src(trans);
       if (!src.InitByIdLookup(changes[i].id)) {
-        LOG(ERROR) << "ApplyModelChanges was passed a bad ID";
-        error_handler()->OnUnrecoverableError();
+        error_handler()->OnUnrecoverableError(FROM_HERE,
+            "ApplyModelChanges was passed a bad ID");
         return;
       }
 
       CreateOrUpdateBookmarkNode(&src, model);
     }
   }
   // Clean up the temporary node.
   if (foster_parent) {
     // There should be no nodes left under the foster parent.
     DCHECK_EQ(foster_parent->GetChildCount(), 0);
@@ skipping 101 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