Remove syncproto.h

sync/engine/process_commit_response_command.cc

 // Copyright (c) 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>
 
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_util.h"
-#include "sync/engine/syncproto.h"
 #include "sync/sessions/sync_session.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/read_transaction.h"
+#include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/time.h"
 
 using std::set;
 using std::string;
 using std::vector;
+using sync_pb::CommitResponse;
 
 namespace syncer {
 
 using sessions::OrderedCommitSet;
 using sessions::StatusController;
 using sessions::SyncSession;
 using sessions::ConflictProgress;
 using syncable::WriteTransaction;
 using syncable::MutableEntry;
 using syncable::Entry;
 using syncable::BASE_VERSION;
 using syncable::GET_BY_ID;
 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_POSITION_IN_PARENT;
 using syncable::SERVER_VERSION;
 using syncable::SYNCER;
 using syncable::SYNCING;
 
 ProcessCommitResponseCommand::ProcessCommitResponseCommand(
       const sessions::OrderedCommitSet& commit_set,
-      const ClientToServerMessage& commit_message,
-      const ClientToServerResponse& commit_response)
+      const sync_pb::ClientToServerMessage& commit_message,
+      const sync_pb::ClientToServerResponse& commit_response)
   : commit_set_(commit_set),
     commit_message_(commit_message),
     commit_response_(commit_response) {
 }
 
 ProcessCommitResponseCommand::~ProcessCommitResponseCommand() {}
 
 std::set<ModelSafeGroup> ProcessCommitResponseCommand::GetGroupsToChange(
     const sessions::SyncSession& session) const {
   std::set<ModelSafeGroup> groups_with_commits;
@@ skipping 115 matching lines @@
     //
     // TODO: Remove this option when the CONFLICT return value is fully
     // deprecated.
     return SERVER_RETURN_TRANSIENT_ERROR;
   } else {
     LOG(FATAL) << "Inconsistent counts when processing commit response";
     return SYNCER_OK;
   }
 }
 
-void LogServerError(const CommitResponse_EntryResponse& res) {
+void LogServerError(const sync_pb::CommitResponse_EntryResponse& res) {
   if (res.has_error_message())
     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& pb_server_entry,
     const sync_pb::SyncEntity& commit_request_entry,
     const syncable::Id& pre_commit_id,
     set<syncable::Id>* deleted_folders) {
 
-  const CommitResponse_EntryResponse& server_entry =
-      *static_cast<const CommitResponse_EntryResponse*>(&pb_server_entry);
+  const sync_pb::CommitResponse_EntryResponse& server_entry =
+      *static_cast<const sync_pb::CommitResponse_EntryResponse*>(

[akalin, 2012/07/11 01:42:22]

static cast not needed anymore?

[rlarocque, 2012/07/11 19:22:16]

Done.

+          &pb_server_entry);
   MutableEntry local_entry(trans, GET_BY_ID, pre_commit_id);
   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?";
@@ skipping 23 matching lines @@
   }
   if (!server_entry.has_id_string()) {
     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.
-  if (pre_commit_id != server_entry.id()) {
-    Entry e(trans, GET_BY_ID, server_entry.id());
+  syncable::Id server_entry_id = SyncableIdFromProto(server_entry.id_string());
+  if (pre_commit_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";
       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);
   return response;
 }
 
 const string& ProcessCommitResponseCommand::GetResultingPostCommitName(
     const sync_pb::SyncEntity& committed_entry,
-    const CommitResponse_EntryResponse& entry_response) {
+    const sync_pb::CommitResponse_EntryResponse& entry_response) {
   const string& response_name =
       SyncerProtoUtil::NameFromCommitEntryResponse(entry_response);
   if (!response_name.empty())
     return response_name;
   return SyncerProtoUtil::NameFromSyncEntity(committed_entry);
 }
 
 bool ProcessCommitResponseCommand::UpdateVersionAfterCommit(
     const sync_pb::SyncEntity& committed_entry,
-    const CommitResponse_EntryResponse& entry_response,
+    const sync_pb::CommitResponse_EntryResponse& entry_response,
     const syncable::Id& pre_commit_id,
     syncable::MutableEntry* local_entry) {
   int64 old_version = local_entry->Get(BASE_VERSION);
   int64 new_version = entry_response.version();
   bool bad_commit_version = false;
   if (committed_entry.deleted() &&
       !local_entry->Get(syncable::UNIQUE_CLIENT_TAG).empty()) {
     // If the item was deleted, and it's undeletable (uses the client tag),
     // change the version back to zero.  We must set the version to zero so
     // that the server knows to re-create the item if it gets committed
     // later for undeletion.
     new_version = 0;
   } else if (!pre_commit_id.ServerKnows()) {
     bad_commit_version = 0 == new_version;
   } else {
     bad_commit_version = old_version > new_version;
   }
   if (bad_commit_version) {
     LOG(ERROR) << "Bad version in commit return for " << *local_entry
-               << " new_id:" << entry_response.id() << " new_version:"
-               << entry_response.version();
+               << " new_id:" << SyncableIdFromProto(entry_response.id_string())
+               << " new_version:" << entry_response.version();
     return false;
   }
 
   // Update the base version and server version.  The base version must change
   // here, even if syncing_was_set is false; that's because local changes were
   // on top of the successfully committed version.
   local_entry->Put(BASE_VERSION, new_version);
   DVLOG(1) << "Commit is changing base version of " << local_entry->Get(ID)
            << " to: " << new_version;
   local_entry->Put(SERVER_VERSION, new_version);
   return true;
 }
 
 bool ProcessCommitResponseCommand::ChangeIdAfterCommit(
-    const CommitResponse_EntryResponse& entry_response,
+    const sync_pb::CommitResponse_EntryResponse& entry_response,
     const syncable::Id& pre_commit_id,
     syncable::MutableEntry* local_entry) {
   syncable::WriteTransaction* trans = local_entry->write_transaction();
-  if (entry_response.id() != pre_commit_id) {
+  syncable::Id entry_response_id =
+      SyncableIdFromProto(entry_response.id_string());
+  if (entry_response_id != pre_commit_id) {
     if (pre_commit_id.ServerKnows()) {
       // The server can sometimes generate a new ID on commit; for example,
       // when committing an undeletion.
       DVLOG(1) << " ID changed while committing an old entry. "
-               << pre_commit_id << " became " << entry_response.id() << ".";
+               << pre_commit_id << " became " << entry_response_id << ".";
     }
-    MutableEntry same_id(trans, GET_BY_ID, entry_response.id());
+    MutableEntry same_id(trans, GET_BY_ID, entry_response_id);
     // We should trap this before this function.
     if (same_id.good()) {
-      LOG(ERROR) << "ID clash with id " << entry_response.id()
+      LOG(ERROR) << "ID clash with id " << entry_response_id
                  << " during commit " << same_id;
       return false;
     }
-    ChangeEntryIDAndUpdateChildren(trans, local_entry, entry_response.id());
-    DVLOG(1) << "Changing ID to " << entry_response.id();
+    ChangeEntryIDAndUpdateChildren(trans, local_entry, entry_response_id);
+    DVLOG(1) << "Changing ID to " << entry_response_id;
   }
   return true;
 }
 
 void ProcessCommitResponseCommand::UpdateServerFieldsAfterCommit(
     const sync_pb::SyncEntity& committed_entry,
-    const CommitResponse_EntryResponse& entry_response,
+    const sync_pb::CommitResponse_EntryResponse& entry_response,
     syncable::MutableEntry* local_entry) {
 
   // We just committed an entry successfully, and now we want to make our view
   // of the server state consistent with the server state. We must be careful;
   // |entry_response| and |committed_entry| have some identically named
   // fields.  We only want to consider fields from |committed_entry| when there
   // is not an overriding field in the |entry_response|.  We do not want to
   // update the server data from the local data in the entry -- it's possible
   // that the local data changed during the commit, and even if not, the server
   // has the last word on the values of several properties.
@@ skipping 30 matching lines @@
   if (local_entry->Get(IS_UNAPPLIED_UPDATE)) {
     // This shouldn't happen; an unapplied update shouldn't be committed, and
     // if it were, the commit should have failed.  But if it does happen: we've
     // just overwritten the update info, so clear the flag.
     local_entry->Put(IS_UNAPPLIED_UPDATE, false);
   }
 }
 
 void ProcessCommitResponseCommand::OverrideClientFieldsAfterCommit(
     const sync_pb::SyncEntity& committed_entry,
-    const CommitResponse_EntryResponse& entry_response,
+    const sync_pb::CommitResponse_EntryResponse& entry_response,
     syncable::MutableEntry* local_entry) {
   if (committed_entry.deleted()) {
     // If an entry's been deleted, nothing else matters.
     DCHECK(local_entry->Get(IS_DEL));
     return;
   }
 
   // Update the name.
   const string& server_name =
       GetResultingPostCommitName(committed_entry, entry_response);
@@ skipping 19 matching lines @@
         local_entry->Get(PARENT_ID));
     if (!local_entry->PutPredecessor(new_prev)) {
       // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
       NOTREACHED();
     }
   }
 }
 
 void ProcessCommitResponseCommand::ProcessSuccessfulCommitResponse(
     const sync_pb::SyncEntity& committed_entry,
-    const CommitResponse_EntryResponse& entry_response,
+    const sync_pb::CommitResponse_EntryResponse& entry_response,
     const syncable::Id& pre_commit_id, syncable::MutableEntry* local_entry,
     bool syncing_was_set, set<syncable::Id>* deleted_folders) {
   DCHECK(local_entry->Get(IS_UNSYNCED));
 
   // Update SERVER_VERSION and BASE_VERSION.
   if (!UpdateVersionAfterCommit(committed_entry, entry_response, pre_commit_id,
                                 local_entry)) {
     LOG(ERROR) << "Bad version in commit return for " << *local_entry
-               << " new_id:" << entry_response.id() << " new_version:"
-               << entry_response.version();
+               << " new_id:" << SyncableIdFromProto(entry_response.id_string())
+               << " new_version:" << entry_response.version();
     return;
   }
 
   // If the server gave us a new ID, apply it.
   if (!ChangeIdAfterCommit(entry_response, pre_commit_id, local_entry)) {
     return;
   }
 
   // Update our stored copy of the server state.
   UpdateServerFieldsAfterCommit(committed_entry, entry_response, local_entry);
@@ skipping 13 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