0

sync: Remove IDs from OrderedCommitSet

Remove the IDs from OrderedCommitSet in order to add a new member,
AddCommitItems().

Removing the IDs from this class would have been a good idea on its own.
There hasn't been any need to track both IDs and metahandles for quite
some time, and storing redundant information always carries the risk
that the two copies will disagree with each other. It is particularly
risky in this case because the entries' IDs will be changed when a
commit response is successful.

The AddCommitItems() function would have needed to have an inconvenient
signature if it had to pass in both the handles and IDs of all the
entries being added to the set.  It's much easier to implement now that
we only need to pass in the entries' metahandles.

The new member function is not used in this commit.  It will be used in
a future commit that allows us to run GetCommitIdsCommand on a single
model type at a time.

BUG=278484

Review URL: https://chromiumcodereview.appspot.com/23694004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@221154 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
rlarocque@chromium.org
2013-09-04 04:50:58 +00:00
parent 1ba18129d4
commit 093722c9ef
10 changed files with 103 additions and 111 deletions

@ -119,10 +119,10 @@ SyncerError BuildCommitCommand::ExecuteImpl(SyncSession* session) {
AddClientConfigParamsToMessage(session, commit_message);
for (size_t i = 0; i < batch_commit_set_.Size(); i++) {
Id id = batch_commit_set_.GetCommitIdAt(i);
int64 handle = batch_commit_set_.GetCommitHandleAt(i);
sync_pb::SyncEntity* sync_entry = commit_message->add_entries();
Entry meta_entry(trans_, syncable::GET_BY_ID, id);
Entry meta_entry(trans_, syncable::GET_BY_HANDLE, handle);
CHECK(meta_entry.good());
DCHECK_NE(0UL,

@ -26,10 +26,10 @@ namespace {
void SetAllSyncingBitsToValue(WriteTransaction* trans,
const sessions::OrderedCommitSet& commit_set,
bool value_to_set) {
const std::vector<syncable::Id>& commit_ids = commit_set.GetAllCommitIds();
for (std::vector<syncable::Id>::const_iterator it = commit_ids.begin();
it != commit_ids.end(); ++it) {
syncable::MutableEntry entry(trans, syncable::GET_BY_ID, *it);
const std::vector<int64>& commit_handles = commit_set.GetAllCommitHandles();
for (std::vector<int64>::const_iterator it = commit_handles.begin();
it != commit_handles.end(); ++it) {
syncable::MutableEntry entry(trans, syncable::GET_BY_HANDLE, *it);
if (entry.good()) {
entry.Put(syncable::SYNCING, value_to_set);
}

@ -74,12 +74,6 @@ SyncerError GetCommitIdsCommand::ExecuteImpl(SyncSession* session) {
session->context()->routing_info(),
ready_unsynced_set);
const vector<syncable::Id>& verified_commit_ids =
commit_set_->GetAllCommitIds();
for (size_t i = 0; i < verified_commit_ids.size(); i++)
DVLOG(1) << "Debug commit batch result:" << verified_commit_ids[i];
return SYNCER_OK;
}
@ -225,8 +219,7 @@ void GetCommitIdsCommand::TryAddItem(const std::set<int64>& ready_unsynced_set,
DCHECK(item.Get(syncable::IS_UNSYNCED));
int64 item_handle = item.Get(syncable::META_HANDLE);
if (ready_unsynced_set.count(item_handle) != 0) {
result->AddCommitItem(item_handle, item.Get(syncable::ID),
item.GetModelType());
result->AddCommitItem(item_handle, item.GetModelType());
}
}
@ -366,9 +359,7 @@ void GetCommitIdsCommand::AddDeletes(
DVLOG(1) << "Inserting moved and deleted entry, will be missed by "
<< "delete roll." << entry.Get(syncable::ID);
commit_set_->AddCommitItem(metahandle,
entry.Get(syncable::ID),
entry.GetModelType());
commit_set_->AddCommitItem(metahandle, entry.GetModelType());
}
// Skip this entry since it's a child of a parent that will be
@ -404,8 +395,7 @@ void GetCommitIdsCommand::AddDeletes(
if (entry.Get(syncable::IS_DEL)) {
syncable::Id parent_id = entry.Get(syncable::PARENT_ID);
if (legal_delete_parents.count(parent_id)) {
commit_set_->AddCommitItem(metahandle, entry.Get(syncable::ID),
entry.GetModelType());
commit_set_->AddCommitItem(metahandle, entry.GetModelType());
}
}
}

@ -38,6 +38,7 @@ using syncable::MutableEntry;
using syncable::Entry;
using syncable::BASE_VERSION;
using syncable::GET_BY_ID;
using syncable::GET_BY_HANDLE;
using syncable::ID;
using syncable::IS_DEL;
using syncable::IS_DIR;
@ -100,7 +101,7 @@ SyncerError ProcessCommitResponseCommand::ModelChangingExecuteImpl(
&trans,
cr.entryresponse(proj[i]),
commit_message.entries(proj[i]),
commit_set_.GetCommitIdAt(proj[i]),
commit_set_.GetCommitHandleAt(proj[i]),
&deleted_folders);
switch (response_type) {
case CommitResponse::INVALID_MESSAGE:
@ -168,10 +169,9 @@ ProcessCommitResponseCommand::ProcessSingleCommitResponse(
syncable::WriteTransaction* trans,
const sync_pb::CommitResponse_EntryResponse& server_entry,
const sync_pb::SyncEntity& commit_request_entry,
const syncable::Id& pre_commit_id,
const int64 metahandle,
set<syncable::Id>* deleted_folders) {
MutableEntry local_entry(trans, GET_BY_ID, pre_commit_id);
MutableEntry local_entry(trans, GET_BY_HANDLE, metahandle);
CHECK(local_entry.good());
bool syncing_was_set = local_entry.Get(SYNCING);
local_entry.Put(SYNCING, false);
@ -216,11 +216,13 @@ ProcessCommitResponseCommand::ProcessSingleCommitResponse(
// it as an error response and retry later.
const syncable::Id& server_entry_id =
SyncableIdFromProto(server_entry.id_string());
if (pre_commit_id != server_entry_id) {
if (local_entry.Get(ID) != server_entry_id) {
Entry e(trans, GET_BY_ID, server_entry_id);
if (e.good()) {
LOG(ERROR) << "Got duplicate id when commiting id: " << pre_commit_id <<
". Treating as an error return";
LOG(ERROR)
<< "Got duplicate id when commiting id: "
<< local_entry.Get(ID)
<< ". Treating as an error return";
return CommitResponse::INVALID_MESSAGE;
}
}
@ -230,7 +232,7 @@ ProcessCommitResponseCommand::ProcessSingleCommitResponse(
}
ProcessSuccessfulCommitResponse(commit_request_entry, server_entry,
pre_commit_id, &local_entry, syncing_was_set, deleted_folders);
local_entry.Get(ID), &local_entry, syncing_was_set, deleted_folders);
return response;
}

@ -70,7 +70,7 @@ class SYNC_EXPORT_PRIVATE ProcessCommitResponseCommand
syncable::WriteTransaction* trans,
const sync_pb::CommitResponse_EntryResponse& pb_commit_response,
const sync_pb::SyncEntity& pb_committed_entry,
const syncable::Id& pre_commit_id,
int64 metahandle,
std::set<syncable::Id>* deleted_folders);
void ProcessSuccessfulCommitResponse(

@ -98,7 +98,7 @@ class ProcessCommitResponseCommandTest : public SyncerCommandTest {
// ProcessCommitResponseCommand consumes commit_ids from the session
// state, so we need to update that. O(n^2) because it's a test.
commit_set->AddCommitItem(metahandle, item_id, model_type);
commit_set->AddCommitItem(metahandle, model_type);
WriteTransaction trans(FROM_HERE, UNITTEST, directory());
MutableEntry entry(&trans, syncable::GET_BY_ID, item_id);

@ -393,8 +393,8 @@ class SyncerTest : public testing::Test,
}
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;
@ -407,10 +407,10 @@ class SyncerTest : public testing::Test,
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;
@ -418,10 +418,10 @@ class SyncerTest : public testing::Test,
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);
}
}
}
@ -600,6 +600,7 @@ TEST_F(SyncerTest, GetCommitIdsCommandTruncates) {
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"));
@ -620,24 +621,24 @@ TEST_F(SyncerTest, GetCommitIdsCommandTruncates) {
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);
}

@ -18,19 +18,26 @@ OrderedCommitSet::OrderedCommitSet(const ModelSafeRoutingInfo& routes)
OrderedCommitSet::~OrderedCommitSet() {}
void OrderedCommitSet::AddCommitItem(const int64 metahandle,
const syncable::Id& commit_id,
ModelType type) {
if (!HaveCommitItem(metahandle)) {
inserted_metahandles_.insert(metahandle);
metahandle_order_.push_back(metahandle);
commit_ids_.push_back(commit_id);
projections_[GetGroupForModelType(type, routes_)].push_back(
commit_ids_.size() - 1);
inserted_metahandles_.size() - 1);
types_.push_back(type);
types_in_list_.Put(type);
}
}
void OrderedCommitSet::AddCommitItems(
const std::vector<int64> metahandles,
ModelType type) {
for (std::vector<int64>::const_iterator it = metahandles.begin();
it != metahandles.end(); ++it) {
AddCommitItem(*it, type);
}
}
const OrderedCommitSet::Projection& OrderedCommitSet::GetCommitIdProjection(
ModelSafeGroup group) const {
Projections::const_iterator i = projections_.find(group);
@ -41,14 +48,14 @@ const OrderedCommitSet::Projection& OrderedCommitSet::GetCommitIdProjection(
void OrderedCommitSet::Append(const OrderedCommitSet& other) {
for (size_t i = 0; i < other.Size(); ++i) {
CommitItem item = other.GetCommitItemAt(i);
AddCommitItem(item.meta, item.id, item.group);
AddCommitItem(item.meta, item.group);
}
}
void OrderedCommitSet::AppendReverse(const OrderedCommitSet& other) {
for (int i = other.Size() - 1; i >= 0; i--) {
CommitItem item = other.GetCommitItemAt(i);
AddCommitItem(item.meta, item.id, item.group);
AddCommitItem(item.meta, item.group);
}
}
@ -72,7 +79,6 @@ void OrderedCommitSet::Truncate(size_t max_size) {
if (element != p.end())
p.erase(element, p.end());
}
commit_ids_.resize(max_size);
metahandle_order_.resize(max_size);
types_.resize(max_size);
}
@ -80,7 +86,6 @@ void OrderedCommitSet::Truncate(size_t max_size) {
void OrderedCommitSet::Clear() {
inserted_metahandles_.clear();
commit_ids_.clear();
metahandle_order_.clear();
for (Projections::iterator it = projections_.begin();
it != projections_.end(); ++it) {
@ -94,7 +99,6 @@ OrderedCommitSet::CommitItem OrderedCommitSet::GetCommitItemAt(
const size_t position) const {
DCHECK(position < Size());
CommitItem return_item = {metahandle_order_[position],
commit_ids_[position],
types_[position]};
return return_item;
}
@ -116,7 +120,6 @@ bool OrderedCommitSet::HasBookmarkCommitId() const {
void OrderedCommitSet::operator=(const OrderedCommitSet& other) {
inserted_metahandles_ = other.inserted_metahandles_;
commit_ids_ = other.commit_ids_;
metahandle_order_ = other.metahandle_order_;
projections_ = other.projections_;
types_ = other.types_;

@ -12,7 +12,6 @@
#include "sync/base/sync_export.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
#include "sync/syncable/syncable_id.h"
namespace syncer {
namespace sessions {
@ -37,22 +36,22 @@ class SYNC_EXPORT_PRIVATE OrderedCommitSet {
return inserted_metahandles_.count(metahandle) > 0;
}
void AddCommitItem(const int64 metahandle, const syncable::Id& commit_id,
ModelType type);
void AddCommitItem(const int64 metahandle, ModelType type);
void AddCommitItems(const std::vector<int64> metahandles, ModelType type);
const std::vector<syncable::Id>& GetAllCommitIds() const {
return commit_ids_;
const std::vector<int64>& GetAllCommitHandles() const {
return metahandle_order_;
}
// Return the Id at index |position| in this OrderedCommitSet. Note that
// Return the handle at index |position| in this OrderedCommitSet. Note that
// the index uniquely identifies the same logical item in each of:
// 1) this OrderedCommitSet
// 2) the CommitRequest sent to the server
// 3) the list of EntryResponse objects in the CommitResponse.
// These together allow re-association of the pre-commit Id with the
// actual committed entry.
const syncable::Id& GetCommitIdAt(const size_t position) const {
return commit_ids_[position];
int64 GetCommitHandleAt(const size_t position) const {
return metahandle_order_[position];
}
// Same as above, but for ModelType of the item.
@ -68,7 +67,7 @@ class SYNC_EXPORT_PRIVATE OrderedCommitSet {
ModelSafeGroup group) const;
size_t Size() const {
return commit_ids_.size();
return metahandle_order_.size();
}
bool Empty() const {
@ -99,7 +98,6 @@ class SYNC_EXPORT_PRIVATE OrderedCommitSet {
// Helper container for return value of GetCommitItemAt.
struct CommitItem {
int64 meta;
syncable::Id id;
ModelType group;
};
@ -108,16 +106,13 @@ class SYNC_EXPORT_PRIVATE OrderedCommitSet {
// These lists are different views of the same items; e.g they are
// isomorphic.
std::set<int64> inserted_metahandles_;
std::vector<syncable::Id> commit_ids_;
std::vector<int64> metahandle_order_;
Projections projections_;
// We need this because of operations like AppendReverse that take ids from
// one OrderedCommitSet and insert into another -- we need to know the
// group for each ID so that the insertion can update the appropriate
// projection. We could store it in commit_ids_, but sometimes we want
// to just return the vector of Ids, so this is more straightforward
// and shouldn't take up too much extra space since commit lists are small.
// projection.
std::vector<ModelType> types_;
// The set of types which are included in this particular list.

@ -26,90 +26,91 @@ class OrderedCommitSetTest : public testing::Test {
};
TEST_F(OrderedCommitSetTest, Projections) {
vector<syncable::Id> expected;
for (int i = 0; i < 8; i++)
expected.push_back(ids_.NewLocalId());
vector<int64> expected;
for (int64 i = 0; i < 8; i++)
expected.push_back(i);
OrderedCommitSet commit_set1(routes_), commit_set2(routes_);
commit_set1.AddCommitItem(0, expected[0], BOOKMARKS);
commit_set1.AddCommitItem(1, expected[1], BOOKMARKS);
commit_set1.AddCommitItem(2, expected[2], PREFERENCES);
commit_set1.AddCommitItem(expected[0], BOOKMARKS);
commit_set1.AddCommitItem(expected[1], BOOKMARKS);
commit_set1.AddCommitItem(expected[2], PREFERENCES);
// Duplicates should be dropped.
commit_set1.AddCommitItem(2, expected[2], PREFERENCES);
commit_set1.AddCommitItem(3, expected[3], SESSIONS);
commit_set1.AddCommitItem(4, expected[4], SESSIONS);
commit_set2.AddCommitItem(7, expected[7], AUTOFILL);
commit_set2.AddCommitItem(6, expected[6], AUTOFILL);
commit_set2.AddCommitItem(5, expected[5], AUTOFILL);
commit_set1.AddCommitItem(expected[2], PREFERENCES);
commit_set1.AddCommitItem(expected[3], SESSIONS);
commit_set1.AddCommitItem(expected[4], SESSIONS);
commit_set2.AddCommitItem(expected[7], AUTOFILL);
commit_set2.AddCommitItem(expected[6], AUTOFILL);
commit_set2.AddCommitItem(expected[5], AUTOFILL);
// Add something in set1 to set2, which should get dropped by AppendReverse.
commit_set2.AddCommitItem(0, expected[0], BOOKMARKS);
commit_set2.AddCommitItem(expected[0], BOOKMARKS);
commit_set1.AppendReverse(commit_set2);
EXPECT_EQ(8U, commit_set1.Size());
// First, we should verify the projections are correct. Second, we want to
// do the same verification after truncating by 1. Next, try truncating
// the set to a size of 4, so that the DB projection is wiped out and
// PASSIVE has one element removed. Finally, truncate to 1 so only UI is
// remaining.
int j = 0;
do {
SCOPED_TRACE(::testing::Message("Iteration j = ") << j);
vector<syncable::Id> all_ids = commit_set1.GetAllCommitIds();
EXPECT_EQ(expected.size(), all_ids.size());
for (size_t i = 0; i < expected.size(); i++) {
SCOPED_TRACE(::testing::Message("CommitSet mismatch at iteration i = ")
<< i);
std::vector<size_t> sizes;
sizes.push_back(8);
sizes.push_back(7);
sizes.push_back(4);
sizes.push_back(1);
for (std::vector<size_t>::iterator it = sizes.begin();
it != sizes.end(); ++it) {
commit_set1.Truncate(*it);
size_t expected_size = *it;
SCOPED_TRACE(::testing::Message("Iteration size = ") << *it);
std::vector<int64> all_ids = commit_set1.GetAllCommitHandles();
EXPECT_EQ(expected_size, all_ids.size());
for (size_t i = 0; i < expected_size; i++) {
EXPECT_TRUE(expected[i] == all_ids[i]);
EXPECT_TRUE(expected[i] == commit_set1.GetCommitIdAt(i));
EXPECT_TRUE(expected[i] == commit_set1.GetCommitHandleAt(i));
}
OrderedCommitSet::Projection p1, p2, p3;
p1 = commit_set1.GetCommitIdProjection(GROUP_UI);
p2 = commit_set1.GetCommitIdProjection(GROUP_PASSIVE);
p3 = commit_set1.GetCommitIdProjection(GROUP_DB);
EXPECT_TRUE(p1.size() + p2.size() + p3.size() == expected.size()) << "Sum"
EXPECT_TRUE(p1.size() + p2.size() + p3.size() == expected_size) << "Sum"
<< "of sizes of projections should equal full expected size!";
for (size_t i = 0; i < p1.size(); i++) {
SCOPED_TRACE(::testing::Message("UI projection mismatch at i = ") << i);
EXPECT_TRUE(expected[p1[i]] == commit_set1.GetCommitIdAt(p1[i]))
EXPECT_TRUE(expected[p1[i]] == commit_set1.GetCommitHandleAt(p1[i]))
<< "expected[p1[i]] = " << expected[p1[i]]
<< ", commit_set1[p1[i]] = " << commit_set1.GetCommitIdAt(p1[i]);
<< ", commit_set1[p1[i]] = " << commit_set1.GetCommitHandleAt(p1[i]);
}
for (size_t i = 0; i < p2.size(); i++) {
SCOPED_TRACE(::testing::Message("PASSIVE projection mismatch at i = ")
<< i);
EXPECT_TRUE(expected[p2[i]] == commit_set1.GetCommitIdAt(p2[i]))
EXPECT_TRUE(expected[p2[i]] == commit_set1.GetCommitHandleAt(p2[i]))
<< "expected[p2[i]] = " << expected[p2[i]]
<< ", commit_set1[p2[i]] = " << commit_set1.GetCommitIdAt(p2[i]);
<< ", commit_set1[p2[i]] = " << commit_set1.GetCommitHandleAt(p2[i]);
}
for (size_t i = 0; i < p3.size(); i++) {
SCOPED_TRACE(::testing::Message("DB projection mismatch at i = ") << i);
EXPECT_TRUE(expected[p3[i]] == commit_set1.GetCommitIdAt(p3[i]))
EXPECT_TRUE(expected[p3[i]] == commit_set1.GetCommitHandleAt(p3[i]))
<< "expected[p3[i]] = " << expected[p3[i]]
<< ", commit_set1[p3[i]] = " << commit_set1.GetCommitIdAt(p3[i]);
<< ", commit_set1[p3[i]] = " << commit_set1.GetCommitHandleAt(p3[i]);
}
int cut_to_size = 7 - 3 * j++;
if (cut_to_size < 0)
break;
expected.resize(cut_to_size);
commit_set1.Truncate(cut_to_size);
} while (true);
}
}
TEST_F(OrderedCommitSetTest, HasBookmarkCommitId) {
OrderedCommitSet commit_set(routes_);
commit_set.AddCommitItem(0, ids_.NewLocalId(), AUTOFILL);
commit_set.AddCommitItem(1, ids_.NewLocalId(), SESSIONS);
commit_set.AddCommitItem(0, AUTOFILL);
commit_set.AddCommitItem(1, SESSIONS);
EXPECT_FALSE(commit_set.HasBookmarkCommitId());
commit_set.AddCommitItem(2, ids_.NewLocalId(), PREFERENCES);
commit_set.AddCommitItem(3, ids_.NewLocalId(), PREFERENCES);
commit_set.AddCommitItem(2, PREFERENCES);
commit_set.AddCommitItem(3, PREFERENCES);
EXPECT_FALSE(commit_set.HasBookmarkCommitId());
commit_set.AddCommitItem(4, ids_.NewLocalId(), BOOKMARKS);
commit_set.AddCommitItem(4, BOOKMARKS);
EXPECT_TRUE(commit_set.HasBookmarkCommitId());
commit_set.Truncate(4);
@ -121,7 +122,7 @@ TEST_F(OrderedCommitSetTest, AddAndRemoveEntries) {
ASSERT_TRUE(commit_set.Empty());
commit_set.AddCommitItem(0, ids_.NewLocalId(), AUTOFILL);
commit_set.AddCommitItem(0, AUTOFILL);
ASSERT_EQ(static_cast<size_t>(1), commit_set.Size());
commit_set.Clear();