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

chrome/browser/sync/profile_sync_service_bookmark_unittest.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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <stack>
 #include <vector>
@@ skipping 24 matching lines @@
 #include "chrome/browser/sync/test/engine/test_user_share.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
+using content::BrowserThread;
+using sync_api::BaseNode;

[Nicolas Zea, 2012/04/19 23:55:43]

same here

 using testing::_;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::StrictMock;
-using content::BrowserThread;
 
 class TestBookmarkModelAssociator : public BookmarkModelAssociator {
  public:
   TestBookmarkModelAssociator(
       BookmarkModel* bookmark_model,
       sync_api::UserShare* user_share,
       DataTypeErrorHandler* error_handler)
       : BookmarkModelAssociator(bookmark_model, user_share,
                                 error_handler,
                                 true /* expect_mobile_bookmarks_folder */),
         user_share_(user_share) {}
 
   // TODO(akalin): This logic lazily creates any tagged node that is
   // requested.  A better way would be to have utility functions to
   // create sync nodes from some bookmark structure and to use that.
   virtual bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id) {
     std::string tag_str = std::string(tag.c_str(), tag.length());
     bool root_exists = false;
     syncable::ModelType type = model_type();
     {
       sync_api::WriteTransaction trans(FROM_HERE, user_share_);
       sync_api::ReadNode uber_root(&trans);
       uber_root.InitByRootLookup();
 
       sync_api::ReadNode root(&trans);
       root_exists = root.InitByTagLookup(
-          ProfileSyncServiceTestHelper::GetTagForType(type));
+          ProfileSyncServiceTestHelper::GetTagForType(type)) ==
+              BaseNode::INIT_OK;
     }
 
     if (!root_exists) {
       bool created = ProfileSyncServiceTestHelper::CreateRoot(
           type,
           user_share_,
           &id_factory_);
       if (!created)
         return false;
     }
 
     sync_api::WriteTransaction trans(FROM_HERE, user_share_);
     sync_api::ReadNode root(&trans);
-    EXPECT_TRUE(root.InitByTagLookup(
+    EXPECT_EQ(BaseNode::INIT_OK, root.InitByTagLookup(
         ProfileSyncServiceTestHelper::GetTagForType(type)));
 
     // First, try to find a node with the title among the root's children.
     // This will be the case if we are testing model persistence, and
     // are reloading a sync repository created earlier in the test.
     int64 last_child_id = sync_api::kInvalidId;
     for (int64 id = root.GetFirstChildId(); id != sync_api::kInvalidId; /***/) {
       sync_api::ReadNode child(&trans);
-      child.InitByIdLookup(id);
+      EXPECT_EQ(BaseNode::INIT_OK, child.InitByIdLookup(id));
       last_child_id = id;
       if (tag_str == child.GetTitle()) {
         *sync_id = id;
         return true;
       }
       id = child.GetSuccessorId();
     }
 
     sync_api::ReadNode predecessor_node(&trans);
     sync_api::ReadNode* predecessor = NULL;
     if (last_child_id != sync_api::kInvalidId) {
-      predecessor_node.InitByIdLookup(last_child_id);
+      EXPECT_EQ(BaseNode::INIT_OK,
+                predecessor_node.InitByIdLookup(last_child_id));
       predecessor = &predecessor_node;
     }
     sync_api::WriteNode node(&trans);
     // Create new fake tagged nodes at the end of the ordering.
     node.InitByCreation(type, root, predecessor);
     node.SetIsFolder(true);
     node.entry_->Put(syncable::UNIQUE_SERVER_TAG, tag);
     node.SetTitle(UTF8ToWide(tag_str));
     node.SetExternalId(0);
     *sync_id = node.GetId();
@@ skipping 18 matching lines @@
   explicit FakeServerChange(sync_api::WriteTransaction* trans) : trans_(trans) {
   }
 
   // Pretend that the server told the syncer to add a bookmark object.
   int64 Add(const std::wstring& title,
             const std::string& url,
             bool is_folder,
             int64 parent_id,
             int64 predecessor_id) {
     sync_api::ReadNode parent(trans_);
-    EXPECT_TRUE(parent.InitByIdLookup(parent_id));
+    EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
     sync_api::WriteNode node(trans_);
     if (predecessor_id == 0) {
       EXPECT_TRUE(node.InitByCreation(syncable::BOOKMARKS, parent, NULL));
     } else {
       sync_api::ReadNode predecessor(trans_);
-      EXPECT_TRUE(predecessor.InitByIdLookup(predecessor_id));
+      EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
       EXPECT_TRUE(node.InitByCreation(syncable::BOOKMARKS, parent,
                                       &predecessor));
     }
     EXPECT_EQ(node.GetPredecessorId(), predecessor_id);
     EXPECT_EQ(node.GetParentId(), parent_id);
     node.SetIsFolder(is_folder);
     node.SetTitle(title);
     if (!is_folder)
       node.SetURL(GURL(url));
@@ skipping 17 matching lines @@
                int64 parent_id,
                int64 predecessor_id) {
     return Add(title, url, false, parent_id, predecessor_id);
   }
 
   // Pretend that the server told the syncer to delete an object.
   void Delete(int64 id) {
     {
       // Delete the sync node.
       sync_api::WriteNode node(trans_);
-      EXPECT_TRUE(node.InitByIdLookup(id));
+      EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
       EXPECT_FALSE(node.GetFirstChildId());
       node.Remove();
     }
     {
       // Verify the deletion.
       sync_api::ReadNode node(trans_);
-      EXPECT_FALSE(node.InitByIdLookup(id));
+      EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL, node.InitByIdLookup(id));
     }
 
     sync_api::ChangeRecord record;
     record.action = sync_api::ChangeRecord::ACTION_DELETE;
     record.id = id;
     // Deletions are always first in the changelist, but we can't actually do
     // WriteNode::Remove() on the node until its children are moved. So, as
     // a practical matter, users of FakeServerChange must move or delete
     // children before parents.  Thus, we must insert the deletion record
     // at the front of the vector.
     changes_.insert(changes_.begin(), record);
   }
 
   // Set a new title value, and return the old value.
   std::wstring ModifyTitle(int64 id, const std::wstring& new_title) {
     sync_api::WriteNode node(trans_);
-    EXPECT_TRUE(node.InitByIdLookup(id));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     std::string old_title = node.GetTitle();
     node.SetTitle(new_title);
     SetModified(id);
     return UTF8ToWide(old_title);
   }
 
   // Set a new parent and predecessor value.  Return the old parent id.
   // We could return the old predecessor id, but it turns out not to be
   // very useful for assertions.
   int64 ModifyPosition(int64 id, int64 parent_id, int64 predecessor_id) {
     sync_api::ReadNode parent(trans_);
-    EXPECT_TRUE(parent.InitByIdLookup(parent_id));
+    EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
     sync_api::WriteNode node(trans_);
-    EXPECT_TRUE(node.InitByIdLookup(id));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     int64 old_parent_id = node.GetParentId();
     if (predecessor_id == 0) {
       EXPECT_TRUE(node.SetPosition(parent, NULL));
     } else {
       sync_api::ReadNode predecessor(trans_);
-      EXPECT_TRUE(predecessor.InitByIdLookup(predecessor_id));
+      EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
       EXPECT_TRUE(node.SetPosition(parent, &predecessor));
     }
     SetModified(id);
     return old_parent_id;
   }
 
   // Pass the fake change list to |service|.
   void ApplyPendingChanges(ChangeProcessor* processor) {
     processor->ApplyChangesFromSyncModel(
@@ skipping 256 matching lines @@
     std::stack<int64> stack;
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
       int64 id = stack.top();
       stack.pop();
       if (!id) continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
       sync_api::ReadNode gnode(trans);
-      ASSERT_TRUE(gnode.InitByIdLookup(id));
+      ASSERT_EQ(BaseNode::INIT_OK, gnode.InitByIdLookup(id));
       stack.push(gnode.GetFirstChildId());
       stack.push(gnode.GetSuccessorId());
     }
   }
 
   void ExpectModelMatch() {
     sync_api::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
@@ skipping 960 matching lines @@
   EXPECT_EQ(1, observer.get_started());
   EXPECT_EQ(0, observer.get_completed_count_at_started());
   EXPECT_EQ(1, observer.get_completed());
 
   model_->RemoveObserver(&observer);
 }
 
 }  // namespace
 
 }  // namespace browser_sync