WIP: The Bookmark Position Megapatch

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 <map>
 #include <queue>
@@ skipping 63 matching lines @@
   // 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) {
     syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
     syncer::WriteNode node(trans_);
     if (predecessor_id == 0) {
-      EXPECT_TRUE(node.InitByCreation(syncer::BOOKMARKS, parent, NULL));
+      EXPECT_TRUE(node.InitBookmarkByCreation(parent, NULL));
     } else {
       syncer::ReadNode predecessor(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
-      EXPECT_TRUE(node.InitByCreation(syncer::BOOKMARKS, parent,
-                                      &predecessor));
+      EXPECT_TRUE(node.InitBookmarkByCreation(parent, &predecessor));
     }
     EXPECT_EQ(node.GetPredecessorId(), predecessor_id);
     EXPECT_EQ(node.GetParentId(), parent_id);
     node.SetIsFolder(is_folder);
     node.SetTitle(title);
     if (!is_folder) {
       sync_pb::BookmarkSpecifics specifics(node.GetBookmarkSpecifics());
       specifics.set_url(url);
       node.SetBookmarkSpecifics(specifics);
     }
@@ skipping 18 matching lines @@
                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.
       syncer::WriteNode node(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
-      EXPECT_FALSE(node.GetFirstChildId());
+      if (node.GetIsFolder())
+        EXPECT_FALSE(node.GetFirstChildId());
       node.Remove();
     }
     {
       // Verify the deletion.
       syncer::ReadNode node(trans_);
       EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL, node.InitByIdLookup(id));
     }
 
     syncer::ChangeRecord record;
     record.action = syncer::ChangeRecord::ACTION_DELETE;
@@ skipping 214 matching lines @@
       // If it doesn't exist, create the permanent node at the end of the
       // ordering.
       syncer::ReadNode predecessor_node(&trans);
       syncer::ReadNode* predecessor = NULL;
       if (last_child_id != syncer::kInvalidId) {
         EXPECT_EQ(BaseNode::INIT_OK,
                   predecessor_node.InitByIdLookup(last_child_id));
         predecessor = &predecessor_node;
       }
       syncer::WriteNode node(&trans);
-      if (!node.InitByCreation(type, root, predecessor))
+      if (!node.InitBookmarkByCreation(root, predecessor))
         return false;
       node.SetIsFolder(true);
       node.GetMutableEntryForTest()->Put(
           syncer::syncable::UNIQUE_SERVER_TAG, permanent_tags[i]);
       node.SetTitle(UTF8ToWide(permanent_tags[i]));
       node.SetExternalId(0);
       last_child_id = node.GetId();
     }
     return true;
   }
@@ skipping 179 matching lines @@
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
       int64 id = stack.top();
       stack.pop();
       if (!id) continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
       syncer::ReadNode gnode(trans);
       ASSERT_EQ(BaseNode::INIT_OK, gnode.InitByIdLookup(id));
-      stack.push(gnode.GetFirstChildId());
       stack.push(gnode.GetSuccessorId());
+      if (gnode.GetIsFolder())
+        stack.push(gnode.GetFirstChildId());
     }
   }
 
   void ExpectModelMatch() {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
   int64 mobile_bookmarks_id() {
     return
@@ skipping 1139 matching lines @@
 
   // Verify model version is incremented and bookmark node versions remain
   // the same.
   const BookmarkNode* bookmark_bar = model_->bookmark_bar_node();
   model_->Remove(bookmark_bar, 0);
   MessageLoop::current()->RunUntilIdle();
   BookmarkNodeVersionMap new_versions;
   GetTransactionVersions(model_->root_node(), &new_versions);
   EXPECT_EQ(initial_versions[model_->root_node()->id()] + 1,
             new_versions[model_->root_node()->id()]);
-  // HACK(haitaol): siblings of removed node are actually updated in sync model
-  //                because of NEXT_ID/PREV_ID. After switching to ordinal,
-  //                siblings will not get updated and the hack below can be
-  //                removed.
-  model_->SetNodeMetaInfo(bookmark_bar->GetChild(0),
-                          kBookmarkTransactionVersionKey, "41");
-  initial_versions[bookmark_bar->GetChild(0)->id()] = 41;
   ExpectTransactionVersionMatch(model_->bookmark_bar_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->other_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->mobile_node(), initial_versions);
 
   // Verify model version and version of changed bookmark are incremented and
   // versions of others remain same.
   const BookmarkNode* changed_bookmark =
       model_->bookmark_bar_node()->GetChild(0);
   model_->SetTitle(changed_bookmark, WideToUTF16Hack(L"test"));
   MessageLoop::current()->RunUntilIdle();
   GetTransactionVersions(model_->root_node(), &new_versions);
   EXPECT_EQ(initial_versions[model_->root_node()->id()] + 2,
             new_versions[model_->root_node()->id()]);
-  EXPECT_EQ(initial_versions[changed_bookmark->id()] + 1,
+  EXPECT_LT(initial_versions[changed_bookmark->id()],
             new_versions[changed_bookmark->id()]);
   initial_versions.erase(changed_bookmark->id());
   ExpectTransactionVersionMatch(model_->bookmark_bar_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->other_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->mobile_node(), initial_versions);
 }
 
 }  // namespace
 
 }  // namespace browser_sync