sync: Remove IDs from OrderedCommitSet

sync/engine/get_commit_ids_command.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.
 
 #include "sync/engine/get_commit_ids_command.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 56 matching lines @@
                        requested_types_,
                        encrypted_types,
                        passphrase_missing,
                        all_unsynced_handles,
                        &ready_unsynced_set);
 
   BuildCommitIds(trans_,
                  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;
 }
 
 namespace {
 
 bool IsEntryInConflict(const syncable::Entry& entry) {
   if (entry.Get(syncable::IS_UNSYNCED) &&
       entry.Get(syncable::SERVER_VERSION) > 0 &&
       (entry.Get(syncable::SERVER_VERSION) >
        entry.Get(syncable::BASE_VERSION))) {
@@ skipping 125 matching lines @@
   return true;
 }
 
 // Adds the given item to the list if it is unsynced and ready for commit.
 void GetCommitIdsCommand::TryAddItem(const std::set<int64>& ready_unsynced_set,
                                      const syncable::Entry& item,
                                      OrderedCommitSet* result) const {
   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());
   }
 }
 
 // Adds the given item, and all its unsynced predecessors.  The traversal will
 // be cut short if any item along the traversal is not IS_UNSYNCED, or if we
 // detect that this area of the tree has already been traversed.  Items that are
 // not 'ready' for commit (see IsEntryReadyForCommit()) will not be added to the
 // list, though they will not stop the traversal.
 void GetCommitIdsCommand::AddItemThenPredecessors(
     syncable::BaseTransaction* trans,
@@ skipping 119 matching lines @@
         // then we'll miss it in the roll up. We have to add it in manually.
         // TODO(chron): Unit test for move / delete cases:
         // Case 1: Locally moved, then parent deleted
         // Case 2: Server moved, then locally issue recursive delete.
         if (entry.Get(syncable::ID).ServerKnows() &&
             entry.Get(syncable::PARENT_ID) !=
                 entry.Get(syncable::SERVER_PARENT_ID)) {
           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
         // deleted. The server will unroll the delete and delete the
         // child as well.
         continue;
       }
 
       legal_delete_parents.insert(entry.Get(syncable::PARENT_ID));
     }
@@ skipping 15 matching lines @@
   for (std::set<int64>::const_iterator iter = ready_unsynced_set.begin();
        !IsCommitBatchFull() && iter != ready_unsynced_set.end(); ++iter) {
     int64 metahandle = *iter;
     if (commit_set_->HaveCommitItem(metahandle))
       continue;
     syncable::Entry entry(trans, syncable::GET_BY_HANDLE,
                           metahandle);
     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());
       }
     }
   }
 }
 
 void GetCommitIdsCommand::BuildCommitIds(
     syncable::BaseTransaction* trans,
     const ModelSafeRoutingInfo& routes,
     const std::set<int64>& ready_unsynced_set) {
   // Commits follow these rules:
   // 1. Moves or creates are preceded by needed folder creates, from
   //    root to leaf.  For folders whose contents are ordered, moves
   //    and creates appear in order.
   // 2. Moves/Creates before deletes.
   // 3. Deletes, collapsed.
   // We commit deleted moves under deleted items as moves when collapsing
   // delete trees.
 
   // Add moves and creates, and prepend their uncommitted parents.
   AddCreatesAndMoves(trans, routes, ready_unsynced_set);
 
   // Add all deletes.
   AddDeletes(trans, ready_unsynced_set);
 }
 
 }  // namespace syncer