[Sync] Make GetFirstChildId return a flag indicating success

chrome/browser/sync/engine/process_commit_response_command_unittest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/location.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/mock_model_safe_workers.h"
 #include "chrome/browser/sync/engine/process_commit_response_command.h"
@@ skipping 74 matching lines @@
   // Returns the methandle of the created item in |metahandle_out| if not NULL.
   void CreateUnsyncedItem(const Id& item_id,
                           const Id& parent_id,
                           const string& name,
                           bool is_folder,
                           syncable::ModelType model_type,
                           int64* metahandle_out) {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
-    Id predecessor_id = dir->GetLastChildId(&trans, parent_id);
+    Id predecessor_id;
+    ASSERT_TRUE(
+        dir->GetLastChildIdForTest(&trans, parent_id, &predecessor_id));
     MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::ID, item_id);
     entry.Put(syncable::BASE_VERSION,
         item_id.ServerKnows() ? next_old_revision_++ : 0);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, is_folder);
     entry.Put(syncable::IS_DEL, false);
     entry.Put(syncable::PARENT_ID, parent_id);
     entry.PutPredecessor(predecessor_id);
@@ skipping 121 matching lines @@
   CreateUnprocessedCommitResult(autofill_id1, id_factory_.root(),
                                 "Autofill 1", syncable::AUTOFILL);
   CreateUnprocessedCommitResult(autofill_id2, id_factory_.root(),
                                 "Autofill 2", syncable::AUTOFILL);
 
   command_.ExecuteImpl(session());
 
   ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
   ASSERT_TRUE(dir.good());
   ReadTransaction trans(FROM_HERE, dir);
-  Id new_fid = dir->GetFirstChildId(&trans, id_factory_.root());
+  Id new_fid;
+  ASSERT_TRUE(dir->GetFirstChildId(&trans, id_factory_.root(), &new_fid));
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(bookmark_folder_id.ServerKnows());
   EXPECT_FALSE(new_fid == bookmark_folder_id);
   Entry b_folder(&trans, syncable::GET_BY_ID, new_fid);
   ASSERT_TRUE(b_folder.good());
   ASSERT_EQ("A bookmark folder", b_folder.Get(NON_UNIQUE_NAME))
       << "Name of bookmark folder should not change.";
   ASSERT_LT(0, b_folder.Get(BASE_VERSION))
       << "Bookmark folder should have a valid (positive) server base revision";
 
   // Look at the two bookmarks in bookmark_folder.
-  Id cid = dir->GetFirstChildId(&trans, new_fid);
+  Id cid;
+  ASSERT_TRUE(dir->GetFirstChildId(&trans, new_fid, &cid));
   Entry b1(&trans, syncable::GET_BY_ID, cid);
   Entry b2(&trans, syncable::GET_BY_ID, b1.Get(syncable::NEXT_ID));
   CheckEntry(&b1, "bookmark 1", syncable::BOOKMARKS, new_fid);
   CheckEntry(&b2, "bookmark 2", syncable::BOOKMARKS, new_fid);
   ASSERT_TRUE(b2.Get(syncable::NEXT_ID).IsRoot());
 
   // Look at the prefs and autofill items.
   Entry p1(&trans, syncable::GET_BY_ID, b_folder.Get(syncable::NEXT_ID));
   Entry p2(&trans, syncable::GET_BY_ID, p1.Get(syncable::NEXT_ID));
   CheckEntry(&p1, "Pref 1", syncable::PREFERENCES, id_factory_.root());
@@ skipping 20 matching lines @@
   // Create the parent folder, a new item whose ID will change on commit.
   Id folder_id = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(folder_id, id_factory_.root(), "A",
                                 syncable::BOOKMARKS);
 
   // Verify that the item is reachable.
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     ReadTransaction trans(FROM_HERE, dir);
-    ASSERT_EQ(folder_id, dir->GetFirstChildId(&trans, id_factory_.root()));
+    Id child_id;
+    ASSERT_TRUE(dir->GetFirstChildId(&trans, id_factory_.root(), &child_id));
+    ASSERT_EQ(folder_id, child_id);
   }
 
   // The first 25 children of the parent folder will be part of the commit
   // batch.
   int batch_size = 25;
   int i = 0;
   for (; i < batch_size; ++i) {
     // Alternate between new and old child items, just for kicks.
     Id id = (i % 4 < 2) ? id_factory_.NewLocalId() : id_factory_.NewServerId();
     CreateUnprocessedCommitResult(
@@ skipping 14 matching lines @@
   // 25 items.  This should apply the values indicated by
   // each CommitResponse_EntryResponse to the syncable Entries.  All new
   // items in the commit batch should have their IDs changed to server IDs.
   command_.ExecuteImpl(session());
 
   ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
   ASSERT_TRUE(dir.good());
   ReadTransaction trans(FROM_HERE, dir);
   // Lookup the parent folder by finding a child of the root.  We can't use
   // folder_id here, because it changed during the commit.
-  Id new_fid = dir->GetFirstChildId(&trans, id_factory_.root());
+  Id new_fid;
+  ASSERT_TRUE(dir->GetFirstChildId(&trans, id_factory_.root(), &new_fid));
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(folder_id.ServerKnows());
   EXPECT_TRUE(new_fid != folder_id);
   Entry parent(&trans, syncable::GET_BY_ID, new_fid);
   ASSERT_TRUE(parent.good());
   ASSERT_EQ("A", parent.Get(NON_UNIQUE_NAME))
       << "Name of parent folder should not change.";
   ASSERT_LT(0, parent.Get(BASE_VERSION))
       << "Parent should have a valid (positive) server base revision";
 
-  Id cid = dir->GetFirstChildId(&trans, new_fid);
+  Id cid;
+  ASSERT_TRUE(dir->GetFirstChildId(&trans, new_fid, &cid));
   int child_count = 0;
   // Now loop over all the children of the parent folder, verifying
   // that they are in their original order by checking to see that their
   // names are still sequential.
   while (!cid.IsRoot()) {
     SCOPED_TRACE(::testing::Message("Examining item #") << child_count);
     Entry c(&trans, syncable::GET_BY_ID, cid);
     DCHECK(c.good());
     ASSERT_EQ(base::StringPrintf("Item %d", child_count),
               c.Get(NON_UNIQUE_NAME));
@@ skipping 82 matching lines @@
     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 browser_sync