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

chrome/browser/sync/glue/password_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/password_model_associator.h"
 
 #include <set>
 
 #include "base/location.h"
 #include "base/stl_util.h"
@@ skipping 56 matching lines @@
         "Could not get the password entries.",
         model_type());
   }
 
   std::set<std::string> current_passwords;
   PasswordVector new_passwords;
   PasswordVector updated_passwords;
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     sync_api::ReadNode password_root(&trans);
-    if (!password_root.InitByTagLookup(kPasswordTag)) {
+    if (password_root.InitByTagLookup(kPasswordTag) !=
+            sync_api::BaseNode::INIT_OK) {
       return error_handler_->CreateAndUploadError(
           FROM_HERE,
           "Server did not create the top-level password node. We "
           "might be running against an out-of-date server.",
           model_type());
     }
 
     for (std::vector<webkit::forms::PasswordForm*>::iterator ix =
              passwords.begin();
          ix != passwords.end(); ++ix) {
       if (IsAbortPending()) {
         return SyncError();
       }
       std::string tag = MakeTag(**ix);
 
       sync_api::ReadNode node(&trans);
-      if (node.InitByClientTagLookup(syncable::PASSWORDS, tag)) {
+      if (node.InitByClientTagLookup(syncable::PASSWORDS, tag) ==
+              sync_api::BaseNode::INIT_OK) {
         const sync_pb::PasswordSpecificsData& password =
             node.GetPasswordSpecifics();
         DCHECK_EQ(tag, MakeTag(password));
 
         webkit::forms::PasswordForm new_password;
 
         if (MergePasswords(password, **ix, &new_password)) {
           sync_api::WriteNode write_node(&trans);
-          if (!write_node.InitByClientTagLookup(syncable::PASSWORDS, tag)) {
+          if (write_node.InitByClientTagLookup(syncable::PASSWORDS, tag) !=
+                  sync_api::BaseNode::INIT_OK) {
             STLDeleteElements(&passwords);
             return error_handler_->CreateAndUploadError(
                 FROM_HERE,
                 "Failed to edit password sync node.",
                 model_type());
           }
           WriteToSyncNode(new_password, &write_node);
           updated_passwords.push_back(new_password);
         }
 
@@ skipping 15 matching lines @@
       }
 
       current_passwords.insert(tag);
     }
 
     STLDeleteElements(&passwords);
 
     int64 sync_child_id = password_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) {
         return error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Failed to fetch child node.",
             model_type());
       }
       const sync_pb::PasswordSpecificsData& password =
           sync_child_node.GetPasswordSpecifics();
       std::string tag = MakeTag(password);
 
       // The password only exists on the server.  Add it to the local
@@ skipping 22 matching lines @@
 
   return error;
 }
 
 bool PasswordModelAssociator::DeleteAllNodes(
     sync_api::WriteTransaction* trans) {
   DCHECK(expected_loop_ == MessageLoop::current());
   for (PasswordToSyncIdMap::iterator node_id = id_map_.begin();
        node_id != id_map_.end(); ++node_id) {
     sync_api::WriteNode sync_node(trans);
-    if (!sync_node.InitByIdLookup(node_id->second)) {
+    if (sync_node.InitByIdLookup(node_id->second) !=
+            sync_api::BaseNode::INIT_OK) {
       LOG(ERROR) << "Typed url node lookup failed.";
       return false;
     }
     sync_node.Remove();
   }
 
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
 SyncError PasswordModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
   return SyncError();
 }
 
 bool PasswordModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(has_nodes);
   *has_nodes = false;
   int64 password_sync_id;
   if (!GetSyncIdForTaggedNode(kPasswordTag, &password_sync_id)) {
     LOG(ERROR) << "Server did not create the top-level password node. We "
                << "might be running against an out-of-date server.";
     return false;
   }
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
   sync_api::ReadNode password_node(&trans);
-  if (!password_node.InitByIdLookup(password_sync_id)) {
+  if (password_node.InitByIdLookup(password_sync_id) !=
+          sync_api::BaseNode::INIT_OK) {
     LOG(ERROR) << "Server did not create the top-level password node. We "
                << "might be running against an out-of-date server.";
     return false;
   }
 
   // The sync model has user created nodes if the password folder has any
   // children.
   *has_nodes = password_node.HasChildren();
   return true;
 }
@@ skipping 49 matching lines @@
   if (iter == id_map_inverse_.end())
     return;
   CHECK(id_map_.erase(iter->second));
   id_map_inverse_.erase(iter);
 }
 
 bool PasswordModelAssociator::GetSyncIdForTaggedNode(const std::string& tag,
                                                      int64* sync_id) {
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   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 PasswordModelAssociator::WriteToPasswordStore(
     const PasswordVector* new_passwords,
     const PasswordVector* updated_passwords,
     const PasswordVector* deleted_passwords) {
   if (new_passwords) {
@@ skipping 136 matching lines @@
     const std::string& password_element,
     const std::string& signon_realm) {
   return net::EscapePath(origin_url) + "|" +
          net::EscapePath(username_element) + "|" +
          net::EscapePath(username_value) + "|" +
          net::EscapePath(password_element) + "|" +
          net::EscapePath(signon_realm);
 }
 
 }  // namespace browser_sync