[Sync] Refactor sync datatype error handling.

chrome/browser/sync/glue/bookmark_model_associator.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/syncable/nigori_util.h"
 #include "chrome/browser/sync/util/cryptographer.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/browser/browser_thread.h"
 
 namespace browser_sync {
 
 // The sync protocol identifies top-level entities by means of well-known tags,
@@ skipping 10 matching lines @@
 // the sync server) to create these tagged nodes when initializing sync
 // for the first time for a user.  Thus, once the backend finishes
 // initializing, the ProfileSyncService can rely on the presence of tagged
 // nodes.
 //
 // TODO(ncarter): Pull these tags from an external protocol specification
 // rather than hardcoding them here.
 static const char kBookmarkBarTag[] = "bookmark_bar";
 static const char kSyncedBookmarksTag[] = "synced_bookmarks";
 static const char kOtherBookmarksTag[] = "other_bookmarks";
+static const char kServerError[] =
+    "Server did not create top-level nodes.  Possibly we are running against "
+    "an out-of-date server?";
 
 // Bookmark comparer for map of bookmark nodes.
 class BookmarkComparer {
  public:
   // Compares the two given nodes and returns whether node1 should appear
   // before node2 in strict weak ordering.
   bool operator()(const BookmarkNode* node1,
                   const BookmarkNode* node2) const {
     DCHECK(node1);
     DCHECK(node2);
@@ skipping 114 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(bookmark_model_);
   DCHECK(user_share_);
   DCHECK(unrecoverable_error_handler_);
 }
 
 BookmarkModelAssociator::~BookmarkModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-bool BookmarkModelAssociator::DisassociateModels() {
+bool BookmarkModelAssociator::DisassociateModels(SyncError* error) {
   id_map_.clear();
   id_map_inverse_.clear();
   dirty_associations_sync_ids_.clear();
   return true;
 }
 
 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;
 }
@@ skipping 116 matching lines @@
 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() {
+bool BookmarkModelAssociator::AssociateModels(SyncError* error) {
   // 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;
 
-  DisassociateModels();
+  DisassociateModels(error);
 
   // We couldn't load model associations from persisted associations. So build
   // them.
-  return BuildAssociations();
+  return BuildAssociations(error);
 }
 
-bool BookmarkModelAssociator::BuildAssociations() {
+bool BookmarkModelAssociator::BuildAssociations(SyncError* error) {
   // 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.
 
   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)) {
-    LOG(ERROR) << "Server did not create top-level nodes.  Possibly we "
-               << "are running against an out-of-date server?";
+    error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
   if (!AssociateTaggedPermanentNode(bookmark_model_->bookmark_bar_node(),
                                     kBookmarkBarTag)) {
-    LOG(ERROR) << "Server did not create top-level nodes.  Possibly we "
-               << "are running against an out-of-date server?";
+    error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
   if (!AssociateTaggedPermanentNode(bookmark_model_->synced_node(),
                                     kSyncedBookmarksTag) &&
       // We only need to ensure that the "synced bookmarks" folder exists on the
       // server if the command line flag is set.
       CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSyncedBookmarksFolder)) {
-    LOG(ERROR) << "Server did not create top-level synced nodes.  Possibly "
-               << "we are running against an out-of-date server?";
+    error->Reset(FROM_HERE, kServerError, model_type());
     return false;
   }
   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 synced_bookmarks_sync_id = GetSyncIdFromChromeId(
        bookmark_model_->synced_node()->id());
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSyncedBookmarksFolder)) {
     DCHECK_NE(synced_bookmarks_sync_id, sync_api::kInvalidId);
   }
 
   std::stack<int64> dfs_stack;
   if (synced_bookmarks_sync_id != sync_api::kInvalidId)
     dfs_stack.push(synced_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;
     }
     // 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;
       }
 
       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_)) {
@@ skipping 171 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.count(syncable::BOOKMARKS) == 0 ||
       trans.GetCryptographer()->is_ready();
 }
 
 }  // namespace browser_sync