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

chrome/browser/sync/glue/session_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/session_model_associator.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 126 matching lines @@
   NOTREACHED();
   return false;
 }
 
 bool SessionModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(CalledOnValidThread());
   CHECK(has_nodes);
   *has_nodes = false;
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::ReadNode root(&trans);
-  if (!root.InitByTagLookup(kSessionsTag)) {
+  if (root.InitByTagLookup(kSessionsTag) != sync_api::BaseNode::INIT_OK) {
     LOG(ERROR) << kNoSessionsFolderError;
     return false;
   }
   // The sync model has user created nodes iff the sessions folder has
   // any children.
   *has_nodes = root.HasChildren();
   return true;
 }
 
 int64 SessionModelAssociator::GetSyncIdFromChromeId(const size_t& id) {
   DCHECK(CalledOnValidThread());
   return GetSyncIdFromSessionTag(TabIdToTag(GetCurrentMachineTag(), id));
 }
 
 int64 SessionModelAssociator::GetSyncIdFromSessionTag(const std::string& tag) {
   DCHECK(CalledOnValidThread());
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::ReadNode node(&trans);
-  if (!node.InitByClientTagLookup(SESSIONS, tag))
+  if (node.InitByClientTagLookup(SESSIONS, tag) != sync_api::BaseNode::INIT_OK)
     return sync_api::kInvalidId;
   return node.GetId();
 }
 
 const SyncedTabDelegate*
 SessionModelAssociator::GetChromeNodeFromSyncId(int64 sync_id) {
   NOTREACHED();
   return NULL;
 }
 
@@ skipping 88 matching lines @@
             current_session->windows[window_id],
             &synced_session_tracker_);
       }
     }
   }
   // Free memory for closed windows and tabs.
   synced_session_tracker_.CleanupSession(local_tag);
 
   sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::WriteNode header_node(&trans);
-  if (!header_node.InitByIdLookup(local_session_syncid_)) {
+  if (header_node.InitByIdLookup(local_session_syncid_) !=
+          sync_api::BaseNode::INIT_OK) {
     if (error) {
       *error = error_handler_->CreateAndUploadError(
            FROM_HERE,
            "Failed to load local session header node.",
            model_type());
     }
     return false;
   }
   header_node.SetSessionSpecifics(specifics);
   if (waiting_for_change_) QuitLoopForSubtleTesting();
@@ skipping 134 matching lines @@
 
   // If the url changed, kick off the favicon load for the new url.
   bool url_changed = false;
   if (tab_link->url().is_valid() && tab_link->url() != old_tab_url) {
     url_changed = true;
     LoadFaviconForTab(tab_link);
   }
 
   sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::WriteNode tab_node(&trans);
-  if (!tab_node.InitByIdLookup(sync_id)) {
+  if (tab_node.InitByIdLookup(sync_id) != sync_api::BaseNode::INIT_OK) {
     if (error) {
       *error = error_handler_->CreateAndUploadError(
           FROM_HERE,
           "Failed to look up local tab node",
           model_type());
     }
     return false;
   }
 
   // Preserve the existing favicon only if the url didn't change.
@@ skipping 53 matching lines @@
   // up to date.
 
   if (favicon.is_valid()) {
     DCHECK_EQ(handle, tab_link->favicon_load_handle());
     tab_link->set_favicon_load_handle(0);
     DCHECK_EQ(favicon.icon_type, history::FAVICON);
     DCHECK_NE(tab_link->sync_id(), sync_api::kInvalidId);
     // Load the sync tab node and update the favicon data.
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     sync_api::WriteNode tab_node(&trans);
-    if (!tab_node.InitByIdLookup(tab_link->sync_id())) {
+    if (tab_node.InitByIdLookup(tab_link->sync_id()) !=
+            sync_api::BaseNode::INIT_OK) {
       LOG(WARNING) << "Failed to load sync tab node for tab id " << tab_id
                    << " and url " << tab_link->url().spec();
       return;
     }
     sync_pb::SessionSpecifics session_specifics =
         tab_node.GetSessionSpecifics();
     DCHECK(session_specifics.has_tab());
     sync_pb::SessionTab* tab = session_specifics.mutable_tab();
     if (favicon.image_data->size() > 0) {
       DVLOG(1) << "Storing session favicon for "
@@ skipping 137 matching lines @@
   DCHECK_EQ(0U, tab_pool_.capacity());
 
   local_session_syncid_ = sync_api::kInvalidId;
 
   // Read any available foreign sessions and load any session data we may have.
   // If we don't have any local session data in the db, create a header node.
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
     sync_api::ReadNode root(&trans);
-    if (!root.InitByTagLookup(syncable::ModelTypeToRootTag(model_type()))) {
+    if (root.InitByTagLookup(syncable::ModelTypeToRootTag(model_type())) !=
+            sync_api::BaseNode::INIT_OK) {
       return error_handler_->CreateAndUploadError(
           FROM_HERE,
           kNoSessionsFolderError,
           model_type());
     }
 
     // Make sure we have a machine tag.
     if (current_machine_tag_.empty()) {
       InitializeCurrentMachineTag(&trans);
       // The session name is retrieved asynchronously so it might not come back
@@ skipping 101 matching lines @@
     sync_api::WriteTransaction* trans,
     SyncError* error) {
   DCHECK(CalledOnValidThread());
   DCHECK(tab_pool_.empty());
   DCHECK_EQ(local_session_syncid_, sync_api::kInvalidId);
 
   // Iterate through the nodes and associate any foreign sessions.
   int64 id = root.GetFirstChildId();
   while (id != sync_api::kInvalidId) {
     sync_api::WriteNode sync_node(trans);
-    if (!sync_node.InitByIdLookup(id)) {
+    if (sync_node.InitByIdLookup(id) != sync_api::BaseNode::INIT_OK) {
       if (error) {
         *error = error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to load sync node",
             model_type());
       }
       return false;
     }
     int64 next_id = sync_node.GetSuccessorId();
 
@@ skipping 343 matching lines @@
   tab_syncid_pool_.resize(tab_syncid_pool_.size() + 1);
   tab_syncid_pool_[static_cast<size_t>(++tab_pool_fp_)] = sync_id;
 }
 
 int64 SessionModelAssociator::TabNodePool::GetFreeTabNode() {
   DCHECK_GT(machine_tag_.length(), 0U);
   if (tab_pool_fp_ == -1) {
     // Tab pool has no free nodes, allocate new one.
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     sync_api::ReadNode root(&trans);
-    if (!root.InitByTagLookup(kSessionsTag)) {
+    if (root.InitByTagLookup(kSessionsTag) != sync_api::BaseNode::INIT_OK) {
       LOG(ERROR) << kNoSessionsFolderError;
       return sync_api::kInvalidId;
     }
     size_t tab_node_id = tab_syncid_pool_.size();
     std::string tab_node_tag = TabIdToTag(machine_tag_, tab_node_id);
     sync_api::WriteNode tab_node(&trans);
     if (!tab_node.InitUniqueByCreation(SESSIONS, root, tab_node_tag)) {
       LOG(ERROR) << "Could not create new node with tag "
                  << tab_node_tag << "!";
       return sync_api::kInvalidId;
@@ skipping 112 matching lines @@
     return;
   }
 
   if (!DisassociateForeignSession(tag)) {
     // We don't have any data for this session, our work here is done!
     return;
   }
 
   sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::ReadNode root(&trans);
-  if (!root.InitByTagLookup(kSessionsTag)) {
+  if (root.InitByTagLookup(kSessionsTag) != sync_api::BaseNode::INIT_OK) {
     LOG(ERROR) << kNoSessionsFolderError;
     return;
   }
   int64 id = root.GetFirstChildId();
   while (id != sync_api::kInvalidId) {
     sync_api::WriteNode sync_node(&trans);
-    if (!sync_node.InitByIdLookup(id)) {
+    if (sync_node.InitByIdLookup(id) != sync_api::BaseNode::INIT_OK) {
       LOG(ERROR) << "Failed to fetch sync node for id " << id;
       continue;
     }
     id = sync_node.GetSuccessorId();
     const sync_pb::SessionSpecifics& specifics =
         sync_node.GetSessionSpecifics();
     if (specifics.session_tag() == tag)
       sync_node.Remove();
   }
 }
@@ skipping 65 matching lines @@
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncable::ModelTypeSet encrypted_types =
       sync_api::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(SESSIONS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync