[Sync] USS: Ignore encryption changes during conflict resolution 2/2

sync/engine/worker_entity_tracker.cc

 // Copyright 2014 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/worker_entity_tracker.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "sync/internal_api/public/base/model_type.h"
@@ skipping 14 matching lines @@
   DCHECK(!client_tag_hash_.empty());
 }
 
 WorkerEntityTracker::~WorkerEntityTracker() {}
 
 bool WorkerEntityTracker::HasPendingCommit() const {
   return !!pending_commit_;
 }
 
 void WorkerEntityTracker::PopulateCommitProto(
-    sync_pb::SyncEntity* commit_entity,
-    int64_t* sequence_number) const {
+    sync_pb::SyncEntity* commit_entity) const {
   DCHECK(HasPendingCommit());
   DCHECK(!client_tag_hash_.empty());
 
   if (!id_.empty()) {
     commit_entity->set_id_string(id_);
   }
 
   const EntityData& entity = pending_commit_->entity.value();
   DCHECK_EQ(client_tag_hash_, entity.client_tag_hash);
 
   commit_entity->set_client_defined_unique_tag(client_tag_hash_);
   commit_entity->set_version(base_version_);
   commit_entity->set_deleted(entity.is_deleted());
 
   // TODO(stanisc): This doesn't support bookmarks yet.
   DCHECK(entity.parent_id.empty());
   commit_entity->set_folder(false);
 
   commit_entity->set_name(entity.non_unique_name);
   if (!entity.is_deleted()) {
     commit_entity->set_ctime(syncer::TimeToProtoTime(entity.creation_time));
     commit_entity->set_mtime(syncer::TimeToProtoTime(entity.modification_time));
     commit_entity->mutable_specifics()->CopyFrom(entity.specifics);
   }
-
-  *sequence_number = sequence_number_;
 }
 
 void WorkerEntityTracker::RequestCommit(const CommitRequestData& data) {
   DCHECK_GE(data.base_version, base_version_)
       << "Base version should never decrease";
 
   DCHECK_GE(data.sequence_number, sequence_number_)
       << "Sequence number should never decrease";
 
   // Update our book-keeping counters.
   base_version_ = data.base_version;
   sequence_number_ = data.sequence_number;
+  pending_commit_specifics_hash_ = data.specifics_hash;
 
   // Don't commit deletions of server-unknown items.
   if (data.entity->is_deleted() && !IsServerKnown()) {
     ClearPendingCommit();
     return;
   }
 
   // We intentionally don't update the id_ here.  Good ID values come from the
   // server and always pass through the sync thread first.  There's no way the
   // model thread could have a better ID value than we do.
@@ skipping 13 matching lines @@
   // Note that this check must be after pending_commit_ is set.
   if (IsInConflict()) {
     ClearPendingCommit();
     return;
   }
 
   // Otherwise, keep the data associated with this pending commit
   // so it can be committed at the next possible opportunity.
 }
 
-void WorkerEntityTracker::ReceiveCommitResponse(const std::string& response_id,
-                                                int64_t response_version,
-                                                int64_t sequence_number) {
-  // Commit responses, especially after the first commit, can update our ID.
-  id_ = response_id;
-
-  DCHECK_GT(response_version, highest_commit_response_version_)
+void WorkerEntityTracker::ReceiveCommitResponse(CommitResponseData* ack) {
+  DCHECK_GT(ack->response_version, highest_commit_response_version_)
       << "Had expected higher response version."
       << " id: " << id_;
 
-  // Commits are synchronous, so there's no reason why the sequence numbers
-  // wouldn't match.
-  DCHECK_EQ(sequence_number_, sequence_number)
-      << "Unexpected sequence number mismatch."
-      << " id: " << id_;
+  // Commit responses, especially after the first commit, can update our ID.
+  id_ = ack->id;
+  highest_commit_response_version_ = ack->response_version;
 
-  highest_commit_response_version_ = response_version;
+  // Fill in some cached info for the response data. Since commits happen
+  // synchronously on the sync thread, our item's state is guaranteed to be
+  // the same at the end of the commit as it was at the start.
+  ack->sequence_number = sequence_number_;
+  ack->specifics_hash = pending_commit_specifics_hash_;
 
   // Because an in-progress commit blocks the sync thread, we can assume that
   // the item we just committed successfully is exactly the one we have now.
   // Nothing changed it while the commit was happening.  Since we're now in
   // sync with the server, we can clear the pending commit.
   ClearPendingCommit();
 }
 
 void WorkerEntityTracker::ReceiveUpdate(int64_t version) {
   if (version <= highest_gu_response_version_)
@@ skipping 57 matching lines @@
     }
   }
 }
 
 bool WorkerEntityTracker::IsServerKnown() const {
   return base_version_ != kUncommittedVersion;
 }
 
 void WorkerEntityTracker::ClearPendingCommit() {
   pending_commit_.reset();
+  pending_commit_specifics_hash_.clear();
 }
 
 }  // namespace syncer_v2