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

chrome/browser/sync/glue/generic_change_processor.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/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/sync/api/sync_change.h"
@@ skipping 37 matching lines @@
     if (it->action == sync_api::ChangeRecord::ACTION_DELETE) {
       syncer_changes_.push_back(
           SyncChange(SyncChange::ACTION_DELETE,
                      SyncData::CreateRemoteData(it->id, it->specifics)));
     } else {
       SyncChange::SyncChangeType action =
           (it->action == sync_api::ChangeRecord::ACTION_ADD) ?
           SyncChange::ACTION_ADD : SyncChange::ACTION_UPDATE;
       // Need to load specifics from node.
       sync_api::ReadNode read_node(trans);
-      if (!read_node.InitByIdLookup(it->id)) {
+      if (read_node.InitByIdLookup(it->id) != sync_api::BaseNode::INIT_OK) {
         error_handler()->OnUnrecoverableError(
             FROM_HERE,
             "Failed to look up data for received change with id " +
                 base::Int64ToString(it->id));
         return;
       }
       syncer_changes_.push_back(
           SyncChange(action,
                      SyncData::CreateRemoteData(
                          it->id, read_node.GetEntitySpecifics())));
@@ skipping 21 matching lines @@
   }
 }
 
 SyncError GenericChangeProcessor::GetSyncDataForType(
     syncable::ModelType type,
     SyncDataList* current_sync_data) {
   DCHECK(CalledOnValidThread());
   std::string type_name = syncable::ModelTypeToString(type);
   sync_api::ReadTransaction trans(FROM_HERE, share_handle());
   sync_api::ReadNode root(&trans);
-  if (!root.InitByTagLookup(syncable::ModelTypeToRootTag(type))) {
+  if (root.InitByTagLookup(syncable::ModelTypeToRootTag(type)) !=
+          sync_api::BaseNode::INIT_OK) {
     SyncError error(FROM_HERE,
                     "Server did not create the top-level " + type_name +
                     " node. We might be running against an out-of-date server.",
                     type);
     return error;
   }
 
   // TODO(akalin): We'll have to do a tree traversal for bookmarks.
   DCHECK_NE(type, syncable::BOOKMARKS);
 
   int64 sync_child_id = root.GetFirstChildId();
   while (sync_child_id != sync_api::kInvalidId) {
     sync_api::ReadNode 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) {
       SyncError error(FROM_HERE,
                       "Failed to fetch child node for type " + type_name + ".",
                        type);
       return error;
     }
     current_sync_data->push_back(SyncData::CreateRemoteData(
         sync_child_node.GetId(), sync_child_node.GetEntitySpecifics()));
     sync_child_id = sync_child_node.GetSuccessorId();
   }
   return SyncError();
 }
 
 namespace {
 
 bool AttemptDelete(const SyncChange& change, sync_api::WriteNode* node) {
   DCHECK_EQ(change.change_type(), SyncChange::ACTION_DELETE);
   if (change.sync_data().IsLocal()) {
     const std::string& tag = change.sync_data().GetTag();
     if (tag.empty()) {
       return false;
     }
-    if (!node->InitByClientTagLookup(
-            change.sync_data().GetDataType(), tag)) {
+    if (node->InitByClientTagLookup(
+            change.sync_data().GetDataType(), tag) !=
+            sync_api::BaseNode::INIT_OK) {
       return false;
     }
   } else {
-    if (!node->InitByIdLookup(change.sync_data().GetRemoteId())) {
+    if (node->InitByIdLookup(change.sync_data().GetRemoteId()) !=
+            sync_api::BaseNode::INIT_OK) {
       return false;
     }
   }
   node->Remove();
   return true;
 }
 
 }  // namespace
 
 SyncError GenericChangeProcessor::ProcessSyncChanges(
@@ skipping 17 matching lines @@
                         "Failed to delete " + type_str + " node.",
                         type);
         error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                             error.message());
         return error;
       }
     } else if (change.change_type() == SyncChange::ACTION_ADD) {
       // TODO(sync): Handle other types of creation (custom parents, folders,
       // etc.).
       sync_api::ReadNode root_node(&trans);
-      if (!root_node.InitByTagLookup(
-              syncable::ModelTypeToRootTag(change.sync_data().GetDataType()))) {
+      if (root_node.InitByTagLookup(
+              syncable::ModelTypeToRootTag(change.sync_data().GetDataType())) !=
+                  sync_api::BaseNode::INIT_OK) {
         NOTREACHED();
         SyncError error(FROM_HERE,
                         "Failed to look up root node for type " + type_str,
                         type);
         error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                             error.message());
         return error;
       }
       if (!sync_node.InitUniqueByCreation(change.sync_data().GetDataType(),
                                           root_node,
                                           change.sync_data().GetTag())) {
         NOTREACHED();
         SyncError error(FROM_HERE,
                         "Failed to create " + type_str + " node.",
                         type);
         error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                             error.message());
         return error;
       }
       sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
     } else if (change.change_type() == SyncChange::ACTION_UPDATE) {
       if (change.sync_data().GetTag() == "" ||
-          !sync_node.InitByClientTagLookup(change.sync_data().GetDataType(),
-                                           change.sync_data().GetTag())) {
+          sync_node.InitByClientTagLookup(change.sync_data().GetDataType(),
+                                          change.sync_data().GetTag()) !=
+              sync_api::BaseNode::INIT_OK) {
         NOTREACHED();
         SyncError error(FROM_HERE,
                         "Failed to update " + type_str + " node.",
                         type);
         error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                             error.message());
         return error;
       }
       sync_node.SetTitle(UTF8ToWide(change.sync_data().GetTitle()));
       sync_node.SetEntitySpecifics(change.sync_data().GetSpecifics());
@@ skipping 17 matching lines @@
     bool* has_nodes) {
   DCHECK(CalledOnValidThread());
   DCHECK(has_nodes);
   DCHECK_NE(type, syncable::UNSPECIFIED);
   std::string type_name = syncable::ModelTypeToString(type);
   std::string err_str = "Server did not create the top-level " + type_name +
       " node. We might be running against an out-of-date server.";
   *has_nodes = false;
   sync_api::ReadTransaction trans(FROM_HERE, share_handle());
   sync_api::ReadNode type_root_node(&trans);
-  if (!type_root_node.InitByTagLookup(syncable::ModelTypeToRootTag(type))) {
+  if (type_root_node.InitByTagLookup(syncable::ModelTypeToRootTag(type)) !=
+          sync_api::BaseNode::INIT_OK) {
     LOG(ERROR) << err_str;
     return false;
   }
 
   // The sync model has user created nodes if the type's root node has any
   // children.
   *has_nodes = type_root_node.HasChildren();
   return true;
 }
 
@@ skipping 14 matching lines @@
 void GenericChangeProcessor::StopImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 sync_api::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync