[Sync] - Upload the callstacks for errors so that the line number of error is in callstack.

chrome/browser/sync/glue/bookmark_model_associator.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_model_associator.h"
 
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 195 matching lines @@
 
 void BookmarkModelAssociator::UpdatePermanentNodeVisibility() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_->IsLoaded());
 
   bookmark_model_->SetPermanentNodeVisible(
       BookmarkNode::MOBILE,
       id_map_.find(bookmark_model_->mobile_node()->id()) != id_map_.end());
 }
 
-bool BookmarkModelAssociator::DisassociateModels(SyncError* error) {
+SyncError BookmarkModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
   dirty_associations_sync_ids_.clear();
-  return true;
+  return SyncError();
 }
 
 int64 BookmarkModelAssociator::GetSyncIdFromChromeId(const int64& node_id) {
   BookmarkIdToSyncIdMap::const_iterator iter = id_map_.find(node_id);
   return iter == id_map_.end() ? sync_api::kInvalidId : iter->second;
 }
 
 const BookmarkNode* BookmarkModelAssociator::GetChromeNodeFromSyncId(
     int64 sync_id) {
   SyncIdToBookmarkNodeMap::const_iterator iter = id_map_inverse_.find(sync_id);
@@ skipping 90 matching lines @@
   if (bookmark->is_url()) {
     if (bookmark->url() != sync_node->GetURL())
       return false;
   }
   // Don't compare favicons here, because they are not really
   // user-updated and we don't have versioning information -- a site changing
   // its favicon shouldn't result in a bookmark mismatch.
   return true;
 }
 
-bool BookmarkModelAssociator::AssociateTaggedPermanentNode(
+SyncError BookmarkModelAssociator::AssociateTaggedPermanentNode(
     const BookmarkNode* permanent_node, const std::string&tag) {
   // Do nothing if |permanent_node| is already initialized and associated.
   int64 sync_id = GetSyncIdFromChromeId(permanent_node->id());
   if (sync_id != sync_api::kInvalidId)
-    return true;
+    return SyncError();
   if (!GetSyncIdForTaggedNode(tag, &sync_id))
-    return false;
+    return unrecoverable_error_handler_->CreateAndUploadError(
+        FROM_HERE,
+        "Permanent node not found",
+        model_type());
 
   Associate(permanent_node, sync_id);
-  return true;
+  return SyncError();
 }
 
 bool BookmarkModelAssociator::GetSyncIdForTaggedNode(const std::string& tag,
                                                      int64* sync_id) {
   sync_api::ReadTransaction trans(FROM_HERE, user_share_);
   sync_api::ReadNode sync_node(&trans);
   if (!sync_node.InitByTagLookup(tag.c_str()))
     return false;
   *sync_id = sync_node.GetId();
   return true;
 }
 
-bool BookmarkModelAssociator::AssociateModels(SyncError* error) {
+SyncError BookmarkModelAssociator::AssociateModels() {
   scoped_ptr<ScopedAssociationUpdater> association_updater(
       new ScopedAssociationUpdater(bookmark_model_));
   // Try to load model associations from persisted associations first. If that
   // succeeds, we don't need to run the complex model matching algorithm.
   if (LoadAssociations())
-    return true;
+    return SyncError();
 
-  DisassociateModels(error);
+  DisassociateModels();
 
   // We couldn't load model associations from persisted associations. So build
   // them.
-  return BuildAssociations(error);
+  return BuildAssociations();
 }
 
-bool BookmarkModelAssociator::BuildAssociations(SyncError* error) {
+SyncError BookmarkModelAssociator::BuildAssociations() {
   // Algorithm description:
   // Match up the roots and recursively do the following:
   // * For each sync node for the current sync parent node, find the best
   //   matching bookmark node under the corresponding bookmark parent node.
   //   If no matching node is found, create a new bookmark node in the same
   //   position as the corresponding sync node.
   //   If a matching node is found, update the properties of it from the
   //   corresponding sync node.
   // * When all children sync nodes are done, add the extra children bookmark
   //   nodes to the sync parent node.
   //
   // This algorithm will do a good job of merging when folder names are a good
   // indicator of the two folders being the same. It will handle reordering and
   // new node addition very well (without creating duplicates).
   // This algorithm will not do well if the folder name has changes but the
   // children under them are all the same.
 
+  SyncError error;
   DCHECK(bookmark_model_->IsLoaded());
 
   // To prime our association, we associate the top-level nodes, Bookmark Bar
   // and Other Bookmarks.
-  if (!AssociateTaggedPermanentNode(bookmark_model_->other_node(),
-                                    kOtherBookmarksTag)) {
-    error->Reset(FROM_HERE, kServerError, model_type());
-    return false;
+  error = AssociateTaggedPermanentNode(bookmark_model_->other_node(),
+                                       kOtherBookmarksTag);
+  if (error.IsSet()) {
+    return error;
   }
-  if (!AssociateTaggedPermanentNode(bookmark_model_->bookmark_bar_node(),
-                                    kBookmarkBarTag)) {
-    error->Reset(FROM_HERE, kServerError, model_type());
-    return false;
+
+  error = AssociateTaggedPermanentNode(bookmark_model_->bookmark_bar_node(),
+                                       kBookmarkBarTag);
+  if (error.IsSet()) {
+    return error;
   }
-  if (!AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
-                                    kMobileBookmarksTag) &&
-      expect_mobile_bookmarks_folder_) {
-    error->Reset(FROM_HERE, kServerError, model_type());
-    return false;
+
+  if (expect_mobile_bookmarks_folder_) {
+    error = AssociateTaggedPermanentNode(bookmark_model_->mobile_node(),
+                                         kMobileBookmarksTag);
+    if (error.IsSet()) {
+      return error;
+    }
   }
 
   int64 bookmark_bar_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->bookmark_bar_node()->id());
   DCHECK_NE(bookmark_bar_sync_id, sync_api::kInvalidId);
   int64 other_bookmarks_sync_id = GetSyncIdFromChromeId(
       bookmark_model_->other_node()->id());
   DCHECK_NE(other_bookmarks_sync_id, sync_api::kInvalidId);
   int64 mobile_bookmarks_sync_id = GetSyncIdFromChromeId(
        bookmark_model_->mobile_node()->id());
   if (expect_mobile_bookmarks_folder_) {
     DCHECK_NE(sync_api::kInvalidId, mobile_bookmarks_sync_id);
   }
 
   std::stack<int64> dfs_stack;
   if (mobile_bookmarks_sync_id != sync_api::kInvalidId)
     dfs_stack.push(mobile_bookmarks_sync_id);
   dfs_stack.push(other_bookmarks_sync_id);
   dfs_stack.push(bookmark_bar_sync_id);
 
   sync_api::WriteTransaction trans(FROM_HERE, user_share_);
 
   while (!dfs_stack.empty()) {
     int64 sync_parent_id = dfs_stack.top();
     dfs_stack.pop();
 
     sync_api::ReadNode sync_parent(&trans);
     if (!sync_parent.InitByIdLookup(sync_parent_id)) {
-      error->Reset(FROM_HERE, "Failed to lookup node.", model_type());
-      return false;
+      return unrecoverable_error_handler_->CreateAndUploadError(
+          FROM_HERE,
+          "Failed to lookup node.",
+          model_type());
     }
     // Only folder nodes are pushed on to the stack.
     DCHECK(sync_parent.GetIsFolder());
 
     const BookmarkNode* parent_node = GetChromeNodeFromSyncId(sync_parent_id);
     DCHECK(parent_node->is_folder());
 
     BookmarkNodeFinder node_finder(parent_node);
 
     int index = 0;
     int64 sync_child_id = sync_parent.GetFirstChildId();
     while (sync_child_id != sync_api::kInvalidId) {
       sync_api::WriteNode sync_child_node(&trans);
       if (!sync_child_node.InitByIdLookup(sync_child_id)) {
-        error->Reset(FROM_HERE, "Failed to lookup node.", model_type());
-        return false;
+        return unrecoverable_error_handler_->CreateAndUploadError(
+            FROM_HERE,
+            "Failed to lookup node.",
+            model_type());
       }
 
       const BookmarkNode* child_node = NULL;
       child_node = node_finder.FindBookmarkNode(sync_child_node);
       if (child_node) {
         bookmark_model_->Move(child_node, parent_node, index);
         // Set the favicon for bookmark node from sync node or vice versa.
         if (BookmarkChangeProcessor::SetBookmarkFavicon(
             &sync_child_node, child_node, bookmark_model_)) {
           BookmarkChangeProcessor::SetSyncNodeFavicon(
@@ skipping 25 matching lines @@
     // At this point all the children nodes of the parent sync node have
     // corresponding children in the parent bookmark node and they are all in
     // the right positions: from 0 to index - 1.
     // So the children starting from index in the parent bookmark node are the
     // ones that are not present in the parent sync node. So create them.
     for (int i = index; i < parent_node->child_count(); ++i) {
       sync_child_id = BookmarkChangeProcessor::CreateSyncNode(
           parent_node, bookmark_model_, i, &trans, this,
           unrecoverable_error_handler_);
       if (sync_api::kInvalidId == sync_child_id) {
-        error->Reset(FROM_HERE, "Failed to create sync node.", model_type());
-        return false; // Creation failed.
+        return unrecoverable_error_handler_->CreateAndUploadError(
+            FROM_HERE,
+            "Failed to create sync node.",
+            model_type());
       }
       if (parent_node->GetChild(i)->is_folder())
         dfs_stack.push(sync_child_id);
       number_of_new_sync_nodes_created_at_association_++;
     }
   }
 
-  return true;
+  return SyncError();
 }
 
 void BookmarkModelAssociator::PostPersistAssociationsTask() {
   // No need to post a task if a task is already pending.
   if (weak_factory_.HasWeakPtrs())
     return;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(
           &BookmarkModelAssociator::PersistAssociations,
@@ skipping 127 matching lines @@
 bool BookmarkModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, user_share_);
   const syncable::ModelTypeSet encrypted_types =
       sync_api::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(syncable::BOOKMARKS) ||
       trans.GetCryptographer()->is_ready();
 }
 
 }  // namespace browser_sync