sync: Implement per-type commit interface

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 12 matching lines @@
 #include "sync/syncable/syncable_util.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 syncable::ModelNeutralWriteTransaction;
 using syncable::ModelNeutralMutableEntry;
 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;
 using syncable::SYNCING;
 
-ProcessCommitResponseCommand::ProcessCommitResponseCommand(
-      const sessions::OrderedCommitSet& commit_set,
-      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() {}
-
-SyncerError ProcessCommitResponseCommand::ExecuteImpl(SyncSession* session) {
-  syncable::Directory* dir = session->context()->directory();
-  StatusController* status = session->mutable_status_controller();
-  const CommitResponse& cr = commit_response_.commit();
-  const sync_pb::CommitMessage& commit_message = commit_message_.commit();
-
-  int transient_error_commits = 0;
-  int conflicting_commits = 0;
-  int error_commits = 0;
-  int successes = 0;
-
-  set<syncable::Id> deleted_folders;
-
-  { // Scope for ModelNeutralWriteTransaction.
-    ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir);
-    for (size_t i = 0; i < commit_set_.Size(); i++) {
-      CommitResponse::ResponseType response_type = ProcessSingleCommitResponse(
-          &trans,
-          cr.entryresponse(i),
-          commit_message.entries(i),
-          commit_set_.GetCommitHandleAt(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:
-          // TODO(sync): worry about sync_rate_ rate calc?
-          ++successes;
-          if (commit_set_.GetModelTypeAt(i) == BOOKMARKS)
-            status->increment_num_successful_bookmark_commits();
-          status->increment_num_successful_commits();
-          break;
-        case CommitResponse::OVER_QUOTA:
-          // We handle over quota like a retry, which is same as transient.
-        case CommitResponse::RETRY:
-        case CommitResponse::TRANSIENT_ERROR:
-          ++transient_error_commits;
-          break;
-        default:
-          LOG(FATAL) << "Bad return from ProcessSingleCommitResponse";
-      }
-    }
-
-    MarkDeletedChildrenSynced(dir, &trans, &deleted_folders);
-  }
-
-  int commit_count = static_cast<int>(commit_set_.Size());
-  if (commit_count == successes) {
-    return SYNCER_OK;
-  } else if (error_commits > 0) {
-    return SERVER_RETURN_UNKNOWN_ERROR;
-  } else if (transient_error_commits > 0) {
-    return SERVER_RETURN_TRANSIENT_ERROR;
-  } else if (conflicting_commits > 0) {
-    // This means that the server already has an item with this version, but
-    // we haven't seen that update yet.
-    //
-    // A well-behaved client should respond to this by proceeding to the
-    // download updates phase, fetching the conflicting items, then attempting
-    // to resolve the conflict.  That's not what this client does.
-    //
-    // We don't currently have any code to support that exceptional control
-    // flow.  Instead, we abort the current sync cycle and start a new one.  The
-    // end result is the same.
-    return SERVER_RETURN_CONFLICT;
-  } else {
-    LOG(FATAL) << "Inconsistent counts when processing commit response";
-    return SYNCER_OK;
-  }
-}
-
 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::ModelNeutralWriteTransaction* trans,
@@ skipping 227 matching lines @@
   // been recursively deleted.
   // TODO(nick): Here, commit_message.deleted() would be more correct than
   // local_entry->GetIsDel().  For example, an item could be renamed, and then
   // deleted during the commit of the rename.  Unit test & fix.
   if (local_entry->GetIsDir() && local_entry->GetIsDel()) {
     deleted_folders->insert(local_entry->GetId());
   }
 }
 
 }  // namespace syncer