sync: Implement per-type commit interface

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 377 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) {
       SCOPED_TRACE(i);
       EXPECT_EQ(1u, expected_positions.count(i));
       EXPECT_EQ(expected_positions[i], mock_server_->committed_ids()[i]);
     }
   }
 
-  void DoTruncationTest(const vector<int64>& unsynced_handle_view,
-                        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;
-      GetCommitIds(&wtrans, types, limit, &output_set);
-      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_handle_order[i], output_set.GetCommitHandleAt(i))
-            << "At index " << i << " with batch size limited to " << limit;
-      }
-      ASSERT_EQ(truncated_size, output_set.Size());
-      for (size_t i = 0; i < truncated_size; ++i) {
-        SCOPED_TRACE(::testing::Message("Projection mismatch with i = ") << i);
-        int64 handle = output_set.GetCommitHandleAt(i);
-        ASSERT_EQ(expected_handle_order[i], handle);
-      }
-    }
-  }
-
   const StatusController& status() {
     return session_->status_controller();
   }
 
   Directory* directory() {
     return dir_maker_.directory();
   }
 
   const std::string local_cache_guid() {
     return directory()->cache_guid();
@@ skipping 96 matching lines @@
       syncable::ReadTransaction trans(FROM_HERE, directory());
       GetUnsyncedEntries(&trans, &handles);
     }
     ASSERT_EQ(0u, handles.size());
   }
   // TODO(sync): When we can dynamically connect and disconnect the mock
   // ServerConnectionManager test disconnected GetUnsyncedEntries here. It's a
   // regression for a very old bug.
 }
 
-TEST_F(SyncerTest, GetCommitIdsCommandTruncates) {
-  syncable::Id root = ids_.root();
-  // Create two server entries.
-  mock_server_->AddUpdateDirectory(ids_.MakeServer("x"), root, "X", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(ids_.MakeServer("w"), root, "W", 10, 10,
-                                   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.PutIsUnsynced(true);
-    entry_b.PutParentId(entry_x.GetId());
-    entry_d.PutParentId(entry_b.GetId());
-    entry_c.PutParentId(entry_x.GetId());
-    entry_c.PutPredecessor(entry_b.GetId());
-    entry_e.PutParentId(entry_c.GetId());
-    entry_w.PutPredecessor(entry_x.GetId());
-    entry_w.PutIsUnsynced(true);
-    entry_w.PutServerVersion(20);
-    entry_w.PutIsUnappliedUpdate(true);  // Fake a conflict.
-    entry_j.PutPredecessor(entry_w.GetId());
-
-    // The expected order is "x", "b", "c", "d", "e", "j", truncated
-    // appropriately.
-    expected_order.push_back(entry_x.GetMetahandle());
-    expected_order.push_back(entry_b.GetMetahandle());
-    expected_order.push_back(entry_c.GetMetahandle());
-    expected_order.push_back(entry_d.GetMetahandle());
-    expected_order.push_back(entry_e.GetMetahandle());
-    expected_order.push_back(entry_j.GetMetahandle());
-  }
-
-  // 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;
-  {
-    syncable::ReadTransaction rtrans(FROM_HERE, directory());
-    GetUnsyncedEntries(&rtrans, &unsynced_handle_view);
-  }
-  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");
   SyncShareNudge();
 
   {
@@ skipping 4137 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