Remove dependency on server generated type root folders

sync/engine/syncer_unittest.cc

 // Copyright 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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 1243 matching lines @@
     EXPECT_EQ(2u, delete_journal->GetDeleteJournalSize(&rt));
     syncable::EntryKernelSet journal_entries;
     directory()->delete_journal()->GetDeleteJournals(&rt, BOOKMARKS,
                                                      &journal_entries);
     EXPECT_EQ(parent_id_, (*journal_entries.begin())->ref(syncable::ID));
     EXPECT_EQ(child_id_, (*journal_entries.rbegin())->ref(syncable::ID));
   }
 }
 
 TEST_F(SyncerTest, ResetVersions) {
-  // Download the top level pref node and some pref items.
-  mock_server_->AddUpdateDirectory(
-      parent_id_, root_id_, "prefs", 1, 10, std::string(), std::string());
-  mock_server_->SetLastUpdateServerTag(ModelTypeToRootTag(PREFERENCES));
-  mock_server_->AddUpdatePref("id1", parent_id_.GetServerId(), "tag1", 20, 20);
-  mock_server_->AddUpdatePref("id2", parent_id_.GetServerId(), "tag2", 30, 30);
-  mock_server_->AddUpdatePref("id3", parent_id_.GetServerId(), "tag3", 40, 40);
+  // Download some pref items.
+  mock_server_->AddUpdatePref("id1", "", "tag1", 20, 20);
+  mock_server_->AddUpdatePref("id2", "", "tag2", 30, 30);
+  mock_server_->AddUpdatePref("id3", "", "tag3", 40, 40);
   SyncShareNudge();
 
   {
     // Modify one of the preferences locally, mark another one as unapplied,
     // and create another unsynced preference.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_CLIENT_TAG, "tag1");
     entry.PutIsUnsynced(true);
 
     MutableEntry entry2(&wtrans, GET_BY_CLIENT_TAG, "tag2");
     entry2.PutIsUnappliedUpdate(true);
 
-    MutableEntry entry4(&wtrans, CREATE, PREFERENCES, parent_id_, "name");
+    MutableEntry entry4(&wtrans, CREATE, PREFERENCES, "name");
     entry4.PutUniqueClientTag("tag4");
     entry4.PutIsUnsynced(true);
   }
 
   {
     // Reset the versions.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     ASSERT_TRUE(directory()->ResetVersionsForType(&wtrans, PREFERENCES));
   }
 
@@ skipping 1185 matching lines @@
   SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetMtime()== test_time);
   }
 }
 
 TEST_F(SyncerTest, ParentAndChildBothMatch) {
+  // Disable PREFERENCES which is enabled at the setup step to avoid
+  // auto-creating
+  // PREFERENCES root folder and failing the test below that verifies the number
+  // of children at the root.
+  DisableDatatype(PREFERENCES);
+
   const FullModelTypeSet all_types = FullModelTypeSet::All();
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id child_id = ids_.NewServerId();
   syncable::Id parent_local_id;
   syncable::Id child_local_id;
 
-
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent_local_id = parent.GetId();
     parent.PutIsDir(true);
     parent.PutIsUnsynced(true);
     parent.PutId(parent_id);
     parent.PutBaseVersion(1);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
@@ skipping 1573 matching lines @@
   }
 }
 
 TEST_F(SyncerTest, ClientTagUpdateClashesWithLocalEntry) {
   // This test is written assuming that ID comparison
   // will work out in a particular way.
   EXPECT_TRUE(ids_.FromNumber(1) < ids_.FromNumber(2));
   EXPECT_TRUE(ids_.FromNumber(3) < ids_.FromNumber(4));
 
   syncable::Id id1 = TestIdFactory::MakeServer("1");
-  mock_server_->AddUpdatePref(id1.GetServerId(), ids_.root().GetServerId(),
-                              "tag1", 10, 100);
+  mock_server_->AddUpdatePref(id1.GetServerId(), "", "tag1", 10, 100);
 
   syncable::Id id4 = TestIdFactory::MakeServer("4");
-  mock_server_->AddUpdatePref(id4.GetServerId(), ids_.root().GetServerId(),
-                              "tag2", 11, 110);
+  mock_server_->AddUpdatePref(id4.GetServerId(), "", "tag2", 11, 110);
 
   mock_server_->set_conflict_all_commits(true);
 
   SyncShareNudge();
   int64 tag1_metahandle = syncable::kInvalidMetaHandle;
   int64 tag2_metahandle = syncable::kInvalidMetaHandle;
   // This should cause client tag overwrite.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
@@ skipping 12 matching lines @@
     ASSERT_TRUE(tag2.good());
     ASSERT_TRUE(tag2.GetId().ServerKnows());
     ASSERT_TRUE(id4 == tag2.GetId());
     EXPECT_FALSE(tag2.GetIsDel());
     EXPECT_FALSE(tag2.GetIsUnappliedUpdate());
     EXPECT_FALSE(tag2.GetIsUnsynced());
     EXPECT_EQ(11, tag2.GetBaseVersion());
     EXPECT_EQ("tag2", tag2.GetUniqueClientTag());
     tag2_metahandle = tag2.GetMetahandle();
 
+    // Preferences type root should have been created by the updates above.
+    Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
+    ASSERT_TRUE(pref_root.good());
+
     syncable::Directory::Metahandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
+    directory()->GetChildHandlesById(&trans, pref_root.GetId(), &children);
     ASSERT_EQ(2U, children.size());
   }
 
   syncable::Id id2 = TestIdFactory::MakeServer("2");
-  mock_server_->AddUpdatePref(id2.GetServerId(), ids_.root().GetServerId(),
-                              "tag1", 12, 120);
+  mock_server_->AddUpdatePref(id2.GetServerId(), "", "tag1", 12, 120);
   syncable::Id id3 = TestIdFactory::MakeServer("3");
-  mock_server_->AddUpdatePref(id3.GetServerId(), ids_.root().GetServerId(),
-                              "tag2", 13, 130);
+  mock_server_->AddUpdatePref(id3.GetServerId(), "", "tag2", 13, 130);
   SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
     ASSERT_TRUE(tag1.good());
     ASSERT_TRUE(tag1.GetId().ServerKnows());
     ASSERT_EQ(id1, tag1.GetId())
         << "ID 1 should be kept, since it was less than ID 2.";
     EXPECT_FALSE(tag1.GetIsDel());
     EXPECT_FALSE(tag1.GetIsUnappliedUpdate());
     EXPECT_FALSE(tag1.GetIsUnsynced());
     EXPECT_EQ(10, tag1.GetBaseVersion());
     EXPECT_EQ("tag1", tag1.GetUniqueClientTag());
     EXPECT_EQ(tag1_metahandle, tag1.GetMetahandle());
 
     Entry tag2(&trans, GET_BY_CLIENT_TAG, "tag2");
     ASSERT_TRUE(tag2.good());
     ASSERT_TRUE(tag2.GetId().ServerKnows());
     ASSERT_EQ(id3, tag2.GetId())
         << "ID 3 should be kept, since it was less than ID 4.";
     EXPECT_FALSE(tag2.GetIsDel());
     EXPECT_FALSE(tag2.GetIsUnappliedUpdate());
     EXPECT_FALSE(tag2.GetIsUnsynced());
     EXPECT_EQ(13, tag2.GetBaseVersion());
     EXPECT_EQ("tag2", tag2.GetUniqueClientTag());
     EXPECT_EQ(tag2_metahandle, tag2.GetMetahandle());
 
+    // Preferences type root should have been created by the updates above.
+    Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
+    ASSERT_TRUE(pref_root.good());
+
     syncable::Directory::Metahandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
+    directory()->GetChildHandlesById(&trans, pref_root.GetId(), &children);
     ASSERT_EQ(2U, children.size());
   }
 }
 
 TEST_F(SyncerTest, ClientTagClashWithinBatchOfUpdates) {
   // This test is written assuming that ID comparison
   // will work out in a particular way.
   EXPECT_TRUE(ids_.FromNumber(1) < ids_.FromNumber(4));
   EXPECT_TRUE(ids_.FromNumber(201) < ids_.FromNumber(205));
 
   // Least ID: winner.
-  mock_server_->AddUpdatePref(ids_.FromNumber(1).GetServerId(),
-                              ids_.root().GetServerId(), "tag a", 1, 10);
-  mock_server_->AddUpdatePref(ids_.FromNumber(2).GetServerId(),
-                              ids_.root().GetServerId(), "tag a", 11, 110);
-  mock_server_->AddUpdatePref(ids_.FromNumber(3).GetServerId(),
-                              ids_.root().GetServerId(), "tag a", 12, 120);
-  mock_server_->AddUpdatePref(ids_.FromNumber(4).GetServerId(),
-                              ids_.root().GetServerId(), "tag a", 13, 130);
+  mock_server_->AddUpdatePref(ids_.FromNumber(1).GetServerId(), "", "tag a", 1,
+                              10);
+  mock_server_->AddUpdatePref(ids_.FromNumber(2).GetServerId(), "", "tag a", 11,
+                              110);
+  mock_server_->AddUpdatePref(ids_.FromNumber(3).GetServerId(), "", "tag a", 12,
+                              120);
+  mock_server_->AddUpdatePref(ids_.FromNumber(4).GetServerId(), "", "tag a", 13,
+                              130);
+  mock_server_->AddUpdatePref(ids_.FromNumber(105).GetServerId(), "", "tag b",
+                              14, 140);
+  mock_server_->AddUpdatePref(ids_.FromNumber(102).GetServerId(), "", "tag b",
+                              15, 150);
+  // Least ID: winner.
+  mock_server_->AddUpdatePref(ids_.FromNumber(101).GetServerId(), "", "tag b",
+                              16, 160);
+  mock_server_->AddUpdatePref(ids_.FromNumber(104).GetServerId(), "", "tag b",
+                              17, 170);
 
-  mock_server_->AddUpdatePref(ids_.FromNumber(105).GetServerId(),
-                              ids_.root().GetServerId(), "tag b", 14, 140);
-  mock_server_->AddUpdatePref(ids_.FromNumber(102).GetServerId(),
-                              ids_.root().GetServerId(), "tag b", 15, 150);
+  mock_server_->AddUpdatePref(ids_.FromNumber(205).GetServerId(), "", "tag c",
+                              18, 180);
+  mock_server_->AddUpdatePref(ids_.FromNumber(202).GetServerId(), "", "tag c",
+                              19, 190);
+  mock_server_->AddUpdatePref(ids_.FromNumber(204).GetServerId(), "", "tag c",
+                              20, 200);
   // Least ID: winner.
-  mock_server_->AddUpdatePref(ids_.FromNumber(101).GetServerId(),
-                              ids_.root().GetServerId(), "tag b", 16, 160);
-  mock_server_->AddUpdatePref(ids_.FromNumber(104).GetServerId(),
-                              ids_.root().GetServerId(), "tag b", 17, 170);
-
-  mock_server_->AddUpdatePref(ids_.FromNumber(205).GetServerId(),
-                              ids_.root().GetServerId(), "tag c", 18, 180);
-  mock_server_->AddUpdatePref(ids_.FromNumber(202).GetServerId(),
-                              ids_.root().GetServerId(), "tag c", 19, 190);
-  mock_server_->AddUpdatePref(ids_.FromNumber(204).GetServerId(),
-                              ids_.root().GetServerId(), "tag c", 20, 200);
-  // Least ID: winner.
-  mock_server_->AddUpdatePref(ids_.FromNumber(201).GetServerId(),
-                              ids_.root().GetServerId(), "tag c", 21, 210);
+  mock_server_->AddUpdatePref(ids_.FromNumber(201).GetServerId(), "", "tag c",
+                              21, 210);
 
   mock_server_->set_conflict_all_commits(true);
 
   SyncShareNudge();
   // This should cause client tag overwrite.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry tag_a(&trans, GET_BY_CLIENT_TAG, "tag a");
     ASSERT_TRUE(tag_a.good());
@@ skipping 18 matching lines @@
     Entry tag_c(&trans, GET_BY_CLIENT_TAG, "tag c");
     ASSERT_TRUE(tag_c.good());
     EXPECT_TRUE(tag_c.GetId().ServerKnows());
     EXPECT_EQ(ids_.FromNumber(201), tag_c.GetId());
     EXPECT_FALSE(tag_c.GetIsDel());
     EXPECT_FALSE(tag_c.GetIsUnappliedUpdate());
     EXPECT_FALSE(tag_c.GetIsUnsynced());
     EXPECT_EQ(21, tag_c.GetBaseVersion());
     EXPECT_EQ("tag c", tag_c.GetUniqueClientTag());
 
+    // Preferences type root should have been created by the updates above.
+    Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
+    ASSERT_TRUE(pref_root.good());
+
+    // Verify that we have exactly 3 tagged nodes under the type root.
     syncable::Directory::Metahandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
+    directory()->GetChildHandlesById(&trans, pref_root.GetId(), &children);
     ASSERT_EQ(3U, children.size());
   }
 }
 
+// This verifies transition to implicit permanent folders.
+TEST_F(SyncerTest, EntryWithParentIdUpdatedWithEntryWithoutParentId) {
+  // Make sure SPECIFICS root exists so that we can get its parent ID.
+  mock_server_->AddUpdateSpecifics(1, 0, "Folder", 10, 10, true, 1,
+                                   DefaultPreferencesSpecifics());
+  mock_server_->SetLastUpdateServerTag(ModelTypeToRootTag(PREFERENCES));
+  SyncShareNudge();
+
+  Id pref_root_id;
+  {
+    // Preferences type root should have been created by the update above.
+    // We need it in order to get its ID.
+    syncable::ReadTransaction trans(FROM_HERE, directory());
+    Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
+    ASSERT_TRUE(pref_root.good());
+    pref_root_id = pref_root.GetId();
+  }
+
+  // Add a preference item with explicit parent ID.
+  mock_server_->AddUpdatePref(ids_.FromNumber(2).GetServerId(),
+                              ids_.FromNumber(1).GetServerId(), "tag", 1, 10);
+
+  SyncShareNudge();
+
+  {
+    syncable::ReadTransaction trans(FROM_HERE, directory());
+    Entry pref_entry(&trans, GET_BY_CLIENT_TAG, "tag");
+    ASSERT_TRUE(pref_entry.good());
+    ASSERT_EQ(pref_root_id, pref_entry.GetParentId());
+  }
+
+  // Make another update where the same item get updated, this time
+  // with implicit parent ID.
+  mock_server_->AddUpdatePref(ids_.FromNumber(2).GetServerId(), "", "tag", 2,
+                              20);
+
+  SyncShareNudge();
+
+  {
+    syncable::ReadTransaction trans(FROM_HERE, directory());
+    Entry pref_entry(&trans, GET_BY_CLIENT_TAG, "tag");
+    ASSERT_TRUE(pref_entry.good());
+    ASSERT_TRUE(pref_entry.GetParentId().IsNull());
+
+    // Verify that there is still one node under the type root.
+    syncable::Directory::Metahandles children;
+    directory()->GetChildHandlesById(&trans, pref_root_id, &children);
+    ASSERT_EQ(1U, children.size());
+  }
+}
+
 TEST_F(SyncerTest, UniqueServerTagUpdates) {
   // As a hurdle, introduce an item whose name is the same as the tag value
   // we'll use later.
   int64 hurdle_handle = CreateUnsyncedDirectory("bob", "id_bob");
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry hurdle(&trans, GET_BY_HANDLE, hurdle_handle);
     ASSERT_TRUE(hurdle.good());
     ASSERT_TRUE(!hurdle.GetIsDel());
     ASSERT_TRUE(hurdle.GetUniqueServerTag().empty());
@@ skipping 1022 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer