sync: Make BaseNode lookup-related Init functions return specific failures.

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 220 matching lines @@
   return iter == id_map_inverse_.end() ? NULL : iter->second;
 }
 
 bool BookmarkModelAssociator::InitSyncNodeFromChromeId(
     const int64& node_id,
     sync_api::BaseNode* sync_node) {
   DCHECK(sync_node);
   int64 sync_id = GetSyncIdFromChromeId(node_id);
   if (sync_id == sync_api::kInvalidId)
     return false;
-  if (!sync_node->InitByIdLookup(sync_id))
+  if (sync_node->InitByIdLookup(sync_id) != sync_api::BaseNode::INIT_OK)
     return false;
   DCHECK(sync_node->GetId() == sync_id);
   return true;
 }
 
 void BookmarkModelAssociator::Associate(const BookmarkNode* node,
                                         int64 sync_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int64 node_id = node->id();
   DCHECK_NE(sync_id, sync_api::kInvalidId);
@@ skipping 29 matching lines @@
     return false;
   }
   int64 mobile_bookmarks_sync_id;
   if (!GetSyncIdForTaggedNode(kMobileBookmarksTag, &mobile_bookmarks_sync_id)) {
     has_mobile_folder = false;
   }
 
   sync_api::ReadTransaction trans(FROM_HERE, user_share_);
 
   sync_api::ReadNode bookmark_bar_node(&trans);
-  if (!bookmark_bar_node.InitByIdLookup(bookmark_bar_sync_id)) {
+  if (bookmark_bar_node.InitByIdLookup(bookmark_bar_sync_id) !=
+          sync_api::BaseNode::INIT_OK) {
     return false;
   }
 
   sync_api::ReadNode other_bookmarks_node(&trans);
-  if (!other_bookmarks_node.InitByIdLookup(other_bookmarks_sync_id)) {
+  if (other_bookmarks_node.InitByIdLookup(other_bookmarks_sync_id) !=
+          sync_api::BaseNode::INIT_OK) {
     return false;
   }
 
   sync_api::ReadNode mobile_bookmarks_node(&trans);
   if (has_mobile_folder &&
-      !mobile_bookmarks_node.InitByIdLookup(mobile_bookmarks_sync_id)) {
+      mobile_bookmarks_node.InitByIdLookup(mobile_bookmarks_sync_id) !=
+          sync_api::BaseNode::INIT_OK) {
     return false;
   }
 
   // Sync model has user created nodes if any of the permanent nodes has
   // children.
   *has_nodes = bookmark_bar_node.HasChildren() ||
       other_bookmarks_node.HasChildren() ||
       (has_mobile_folder && mobile_bookmarks_node.HasChildren());
   return true;
 }
@@ skipping 28 matching lines @@
         model_type());
 
   Associate(permanent_node, sync_id);
   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()))
+  if (sync_node.InitByTagLookup(tag.c_str()) != sync_api::BaseNode::INIT_OK)
     return false;
   *sync_id = sync_node.GetId();
   return true;
 }
 
 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.
@@ skipping 68 matching lines @@
   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)) {
+    if (sync_parent.InitByIdLookup(sync_parent_id) !=
+            sync_api::BaseNode::INIT_OK) {
       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)) {
+      if (sync_child_node.InitByIdLookup(sync_child_id) !=
+              sync_api::BaseNode::INIT_OK) {
         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);
@@ skipping 71 matching lines @@
     return;
   }
 
   sync_api::WriteTransaction trans(FROM_HERE, user_share_);
   DirtyAssociationsSyncIds::iterator iter;
   for (iter = dirty_associations_sync_ids_.begin();
        iter != dirty_associations_sync_ids_.end();
        ++iter) {
     int64 sync_id = *iter;
     sync_api::WriteNode sync_node(&trans);
-    if (!sync_node.InitByIdLookup(sync_id)) {
+    if (sync_node.InitByIdLookup(sync_id) != sync_api::BaseNode::INIT_OK) {
       unrecoverable_error_handler_->OnUnrecoverableError(FROM_HERE,
           "Could not lookup bookmark node for ID persistence.");
       return;
     }
     const BookmarkNode* node = GetChromeNodeFromSyncId(sync_id);
     if (node)
       sync_node.SetExternalId(node->id());
     else
       NOTREACHED();
   }
@@ skipping 43 matching lines @@
   sync_api::ReadTransaction trans(FROM_HERE, user_share_);
 
   // Count total number of nodes in sync model so that we can compare that
   // with the total number of nodes in the bookmark model.
   size_t sync_node_count = 0;
   while (!dfs_stack.empty()) {
     int64 parent_id = dfs_stack.top();
     dfs_stack.pop();
     ++sync_node_count;
     sync_api::ReadNode sync_parent(&trans);
-    if (!sync_parent.InitByIdLookup(parent_id)) {
+    if (sync_parent.InitByIdLookup(parent_id) != sync_api::BaseNode::INIT_OK) {
       return false;
     }
 
     int64 external_id = sync_parent.GetExternalId();
     if (external_id == 0)
       return false;
 
     const BookmarkNode* node = id_index.Find(external_id);
     if (!node)
       return false;
 
     // Don't try to call NodesMatch on permanent nodes like bookmark bar and
     // other bookmarks. They are not expected to match.
     if (node != bookmark_model_->bookmark_bar_node() &&
         node != bookmark_model_->mobile_node() &&
         node != bookmark_model_->other_node() &&
         !NodesMatch(node, &sync_parent))
       return false;
 
     Associate(node, sync_parent.GetId());
 
     // Add all children of the current node to the stack.
     int64 child_id = sync_parent.GetFirstChildId();
     while (child_id != sync_api::kInvalidId) {
       dfs_stack.push(child_id);
       sync_api::ReadNode child_node(&trans);
-      if (!child_node.InitByIdLookup(child_id)) {
+      if (child_node.InitByIdLookup(child_id) != sync_api::BaseNode::INIT_OK) {
         return false;
       }
       child_id = child_node.GetSuccessorId();
     }
   }
   DCHECK(dfs_stack.empty());
 
   // It's possible that the number of nodes in the bookmark model is not the
   // same as number of nodes in the sync model. This can happen when the sync
   // model doesn't get a chance to persist its changes, for example when
   // Chrome does not shut down gracefully. In such cases we can't trust the
   // loaded associations.
   return sync_node_count == id_index.count();
 }
 
 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