sync: Remove IDs from OrderedCommitSet

sync/engine/process_commit_response_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/process_commit_response_command.h"
 
 #include <cstddef>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 20 matching lines @@
 namespace syncer {
 
 using sessions::OrderedCommitSet;
 using sessions::StatusController;
 using sessions::SyncSession;
 using syncable::WriteTransaction;
 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;
 using syncable::IS_UNAPPLIED_UPDATE;
 using syncable::IS_UNSYNCED;
 using syncable::PARENT_ID;
 using syncable::SERVER_IS_DEL;
 using syncable::SERVER_PARENT_ID;
 using syncable::SERVER_VERSION;
 using syncable::SYNCER;
@@ skipping 42 matching lines @@
   OrderedCommitSet::Projection proj = status->commit_id_projection(
       commit_set_);
 
   if (!proj.empty()) { // Scope for WriteTransaction.
     WriteTransaction trans(FROM_HERE, SYNCER, dir);
     for (size_t i = 0; i < proj.size(); i++) {
       CommitResponse::ResponseType response_type = ProcessSingleCommitResponse(
           &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:
           ++error_commits;
           break;
         case CommitResponse::CONFLICT:
           ++conflicting_commits;
           status->increment_num_server_conflicts();
           break;
         case CommitResponse::SUCCESS:
@@ skipping 47 matching lines @@
     LOG(WARNING) << "  " << res.error_message();
   else
     LOG(WARNING) << "  No detailed error message returned from server";
 }
 
 CommitResponse::ResponseType
 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);
 
   CommitResponse::ResponseType response = (CommitResponse::ResponseType)
       server_entry.response_type();
   if (!CommitResponse::ResponseType_IsValid(response)) {
     LOG(ERROR) << "Commit response has unknown response type! Possibly out "
                "of date client?";
     return CommitResponse::INVALID_MESSAGE;
@@ skipping 24 matching lines @@
     LOG(ERROR) << "Commit response has no id";
     return CommitResponse::INVALID_MESSAGE;
   }
 
   // Implied by the IsValid call above, but here for clarity.
   DCHECK_EQ(CommitResponse::SUCCESS, response) << response;
   // Check to see if we've been given the ID of an existing entry. If so treat
   // 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;
     }
   }
 
   if (server_entry.version() == 0) {
     LOG(WARNING) << "Server returned a zero version on a commit response.";
   }
 
   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;
 }
 
 const string& ProcessCommitResponseCommand::GetResultingPostCommitName(
     const sync_pb::SyncEntity& committed_entry,
     const sync_pb::CommitResponse_EntryResponse& entry_response) {
   const string& response_name =
       SyncerProtoUtil::NameFromCommitEntryResponse(entry_response);
   if (!response_name.empty())
     return response_name;
@@ skipping 181 matching lines @@
   // been recursively deleted.
   // TODO(nick): Here, commit_message.deleted() would be more correct than
   // local_entry->Get(IS_DEL).  For example, an item could be renamed, and then
   // deleted during the commit of the rename.  Unit test & fix.
   if (local_entry->Get(IS_DIR) && local_entry->Get(IS_DEL)) {
     deleted_folders->insert(local_entry->Get(ID));
   }
 }
 
 }  // namespace syncer