sync: Remove IDs from OrderedCommitSet

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 375 matching lines @@
     ASSERT_TRUE(expected_positions.size() ==
                 mock_server_->committed_ids().size());
     // If this test starts failing, be aware other sort orders could be valid.
     for (size_t i = 0; i < expected_positions.size(); ++i) {
       EXPECT_EQ(1u, expected_positions.count(i));
       EXPECT_TRUE(expected_positions[i] == mock_server_->committed_ids()[i]);
     }
   }
 
   void DoTruncationTest(const vector<int64>& unsynced_handle_view,
-                        const vector<syncable::Id>& expected_id_order) {
-    for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
+                        const vector<int64>& expected_handle_order) {
+    for (size_t limit = expected_handle_order.size() + 2; limit > 0; --limit) {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
       ModelSafeRoutingInfo routes;
       GetModelSafeRoutingInfo(&routes);
       ModelTypeSet types = GetRoutingInfoTypes(routes);
       sessions::OrderedCommitSet output_set(routes);
       GetCommitIdsCommand command(&wtrans, types, limit, &output_set);
       std::set<int64> ready_unsynced_set;
       command.FilterUnreadyEntries(&wtrans, types,
                                    ModelTypeSet(), false,
                                    unsynced_handle_view, &ready_unsynced_set);
       command.BuildCommitIds(&wtrans, routes, ready_unsynced_set);
-      size_t truncated_size = std::min(limit, expected_id_order.size());
+      size_t truncated_size = std::min(limit, expected_handle_order.size());
       ASSERT_EQ(truncated_size, output_set.Size());
       for (size_t i = 0; i < truncated_size; ++i) {
-        ASSERT_EQ(expected_id_order[i], output_set.GetCommitIdAt(i))
+        ASSERT_EQ(expected_handle_order[i], output_set.GetCommitHandleAt(i))
             << "At index " << i << " with batch size limited to " << limit;
       }
       sessions::OrderedCommitSet::Projection proj;
       proj = output_set.GetCommitIdProjection(GROUP_PASSIVE);
       ASSERT_EQ(truncated_size, proj.size());
       for (size_t i = 0; i < truncated_size; ++i) {
         SCOPED_TRACE(::testing::Message("Projection mismatch with i = ") << i);
-        syncable::Id projected = output_set.GetCommitIdAt(proj[i]);
-        ASSERT_EQ(expected_id_order[proj[i]], projected);
+        int64 projected = output_set.GetCommitHandleAt(proj[i]);
+        ASSERT_EQ(expected_handle_order[proj[i]], projected);
         // Since this projection is the identity, the following holds.
-        ASSERT_EQ(expected_id_order[i], projected);
+        ASSERT_EQ(expected_handle_order[i], projected);
       }
     }
   }
 
   const StatusController& status() {
     return session_->status_controller();
   }
 
   Directory* directory() {
     return dir_maker_.directory();
@@ skipping 158 matching lines @@
                                    foreign_cache_guid(), "-2");
   SyncShareNudge();
 
   // Create some new client entries.
   CreateUnsyncedDirectory("C", ids_.MakeLocal("c"));
   CreateUnsyncedDirectory("B", ids_.MakeLocal("b"));
   CreateUnsyncedDirectory("D", ids_.MakeLocal("d"));
   CreateUnsyncedDirectory("E", ids_.MakeLocal("e"));
   CreateUnsyncedDirectory("J", ids_.MakeLocal("j"));
 
+  vector<int64> expected_order;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry_x(&wtrans, GET_BY_ID, ids_.MakeServer("x"));
     MutableEntry entry_b(&wtrans, GET_BY_ID, ids_.MakeLocal("b"));
     MutableEntry entry_c(&wtrans, GET_BY_ID, ids_.MakeLocal("c"));
     MutableEntry entry_d(&wtrans, GET_BY_ID, ids_.MakeLocal("d"));
     MutableEntry entry_e(&wtrans, GET_BY_ID, ids_.MakeLocal("e"));
     MutableEntry entry_w(&wtrans, GET_BY_ID, ids_.MakeServer("w"));
     MutableEntry entry_j(&wtrans, GET_BY_ID, ids_.MakeLocal("j"));
     entry_x.Put(IS_UNSYNCED, true);
     entry_b.Put(PARENT_ID, entry_x.Get(ID));
     entry_d.Put(PARENT_ID, entry_b.Get(ID));
     entry_c.Put(PARENT_ID, entry_x.Get(ID));
     entry_c.PutPredecessor(entry_b.Get(ID));
     entry_e.Put(PARENT_ID, entry_c.Get(ID));
     entry_w.PutPredecessor(entry_x.Get(ID));
     entry_w.Put(IS_UNSYNCED, true);
     entry_w.Put(SERVER_VERSION, 20);
     entry_w.Put(IS_UNAPPLIED_UPDATE, true);  // Fake a conflict.
     entry_j.PutPredecessor(entry_w.Get(ID));
+
+    // The expected order is "x", "b", "c", "d", "e", "j", truncated
+    // appropriately.
+    expected_order.push_back(entry_x.Get(META_HANDLE));
+    expected_order.push_back(entry_b.Get(META_HANDLE));
+    expected_order.push_back(entry_c.Get(META_HANDLE));
+    expected_order.push_back(entry_d.Get(META_HANDLE));
+    expected_order.push_back(entry_e.Get(META_HANDLE));
+    expected_order.push_back(entry_j.Get(META_HANDLE));
   }
 
   // The arrangement is now: x (b (d) c (e)) w j
   // Entry "w" is in conflict, so it is not eligible for commit.
   vector<int64> unsynced_handle_view;
-  vector<syncable::Id> expected_order;
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     GetUnsyncedEntries(&rtrans, &unsynced_handle_view);
   }
-  // The expected order is "x", "b", "c", "d", "e", "j", truncated
-  // appropriately.
-  expected_order.push_back(ids_.MakeServer("x"));
-  expected_order.push_back(ids_.MakeLocal("b"));
-  expected_order.push_back(ids_.MakeLocal("c"));
-  expected_order.push_back(ids_.MakeLocal("d"));
-  expected_order.push_back(ids_.MakeLocal("e"));
-  expected_order.push_back(ids_.MakeLocal("j"));
   DoTruncationTest(unsynced_handle_view, expected_order);
 }
 
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   const ModelTypeSet throttled_types(BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
@@ skipping 4154 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