Enable Null Syncable ID which is different than Root ID.

sync/syncable/parent_child_index_unittest.cc

 // Copyright (c) 2013 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 "sync/syncable/parent_child_index.h"
 
 #include <list>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 31 matching lines @@
     return syncable::Id::CreateFromServerId("c" + base::IntToString(n));
   }
 
   EntryKernel* MakeRoot() {
     // Mimics the root node.
     EntryKernel* root = new EntryKernel();
     root->put(META_HANDLE, 1);
     root->put(BASE_VERSION, -1);
     root->put(SERVER_VERSION, 0);
     root->put(IS_DIR, true);
-    root->put(ID, syncable::Id());
-    root->put(PARENT_ID, syncable::Id());
-    root->put(SERVER_PARENT_ID, syncable::Id());
+    root->put(ID, syncable::Id::GetRoot());
+    root->put(PARENT_ID, syncable::Id::GetRoot());
 
     owned_entry_kernels_.push_back(root);
     return root;
   }
 
   EntryKernel* MakeBookmarkRoot() {
     // Mimics a server-created bookmark folder.
     EntryKernel* folder = new EntryKernel;
     folder->put(META_HANDLE, 1);
     folder->put(BASE_VERSION, 9);
     folder->put(SERVER_VERSION, 9);
     folder->put(IS_DIR, true);
     folder->put(ID, GetBookmarkRootId());
-    folder->put(SERVER_PARENT_ID, syncable::Id());
-    folder->put(PARENT_ID, syncable::Id());
+    folder->put(PARENT_ID, syncable::Id::GetRoot());
     folder->put(UNIQUE_SERVER_TAG, "google_chrome_bookmarks");
 
     owned_entry_kernels_.push_back(folder);
     return folder;
   }
 
   EntryKernel* MakeBookmark(int n, int pos, bool is_dir) {
     // Mimics a regular bookmark or folder.
     EntryKernel* bm = new EntryKernel();
     bm->put(META_HANDLE, n);
     bm->put(BASE_VERSION, 10);
     bm->put(SERVER_VERSION, 10);
     bm->put(IS_DIR, is_dir);
     bm->put(ID, GetBookmarkId(n));
     bm->put(PARENT_ID, GetBookmarkRootId());
-    bm->put(SERVER_PARENT_ID, GetBookmarkRootId());
 
     bm->put(UNIQUE_BOOKMARK_TAG,
             syncable::GenerateSyncableBookmarkHash(kCacheGuid,
                                                    bm->ref(ID).GetServerId()));
 
     UniquePosition unique_pos =
         UniquePosition::FromInt64(pos, bm->ref(UNIQUE_BOOKMARK_TAG));
     bm->put(UNIQUE_POSITION, unique_pos);
     bm->put(SERVER_UNIQUE_POSITION, unique_pos);
 
     owned_entry_kernels_.push_back(bm);
     return bm;
   }
 
   EntryKernel* MakeUniqueClientItem(int n) {
     EntryKernel* item = new EntryKernel();
     item->put(META_HANDLE, n);
     item->put(BASE_VERSION, 10);
     item->put(SERVER_VERSION, 10);
     item->put(IS_DIR, false);
     item->put(ID, GetClientUniqueId(n));
-    item->put(PARENT_ID, syncable::Id());
-    item->put(SERVER_PARENT_ID, syncable::Id());
+    item->put(PARENT_ID, syncable::Id::GetRoot());
     item->put(UNIQUE_CLIENT_TAG, base::IntToString(n));
 
     owned_entry_kernels_.push_back(item);
     return item;
   }
 
   ParentChildIndex index_;
 
  private:
   std::list<EntryKernel*> owned_entry_kernels_;
@@ skipping 176 matching lines @@
   // Make two unique client tag items under the root node.
   EntryKernel* u1 = MakeUniqueClientItem(1);
   EntryKernel* u2 = MakeUniqueClientItem(2);
 
   EXPECT_FALSE(u1->ShouldMaintainPosition());
   EXPECT_FALSE(u2->ShouldMaintainPosition());
 
   index_.Insert(u1);
   index_.Insert(u2);
 
-  const OrderedChildSet* children = index_.GetChildren(syncable::Id());
+  const OrderedChildSet* children = index_.GetChildren(syncable::Id::GetRoot());
   EXPECT_EQ(children->count(u1), 1UL);
   EXPECT_EQ(children->count(u2), 1UL);
   EXPECT_EQ(children->size(), 2UL);
 }
 
 // Test ordered and non-ordered entries under the same parent.
 // TODO(rlarocque): We should not need to support this.
 TEST_F(ParentChildIndexTest, OrderedAndUnorderedChildren) {
   EntryKernel* bm_folder = MakeBookmarkRoot();
   index_.Insert(bm_folder);
@@ skipping 19 matching lines @@
   it++;
   EXPECT_EQ(*it, u1);
   it++;
   EXPECT_TRUE(it == children->end());
 }
 
 }  // namespace
 }  // namespace syncable
 }  // namespace syncer