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

sync/internal_api/processor_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/internal_api/public/processor_entity_tracker.h"
 
 #include <stdint.h>
 
 #include "base/base64.h"
 #include "base/sha1.h"
 #include "base/time/time.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/time.h"
 
 namespace syncer_v2 {
 
 namespace {
 
 void HashSpecifics(const sync_pb::EntitySpecifics& specifics,
                    std::string* hash) {
+  DCHECK_GT(specifics.ByteSize(), 0);
   base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()), hash);
 }
 
 }  // namespace
 
 std::unique_ptr<ProcessorEntityTracker> ProcessorEntityTracker::CreateNew(
     const std::string& client_tag,
     const std::string& client_tag_hash,
     const std::string& id,
     base::Time creation_time) {
@@ skipping 41 matching lines @@
 void ProcessorEntityTracker::CacheCommitData(const EntityDataPtr& data_ptr) {
   DCHECK(RequiresCommitData());
   commit_data_ = data_ptr;
   DCHECK(HasCommitData());
 }
 
 bool ProcessorEntityTracker::HasCommitData() const {
   return !commit_data_->client_tag_hash.empty();
 }
 
-bool ProcessorEntityTracker::MatchesSpecificsHash(
-    const sync_pb::EntitySpecifics& specifics) const {
-  DCHECK_GT(specifics.ByteSize(), 0);
-  std::string hash;
-  HashSpecifics(specifics, &hash);
-  return hash == metadata_.specifics_hash();
+bool ProcessorEntityTracker::MatchesData(const EntityData& data) const {
+  return metadata_.is_deleted() ? data.is_deleted() :
+         MatchesSpecificsHash(data.specifics);
 }
 
-bool ProcessorEntityTracker::MatchesData(const EntityData& data) const {
-  return (data.is_deleted() && metadata_.is_deleted()) ||
-         MatchesSpecificsHash(data.specifics);
+bool ProcessorEntityTracker::MatchesBaseData(const EntityData& data) const {
+  DCHECK(IsUnsynced());
+  if (data.is_deleted() || metadata_.base_specifics_hash().empty()) {
+    return false;
+  }
+  std::string hash;
+  HashSpecifics(data.specifics, &hash);
+  return hash == metadata_.base_specifics_hash();
 }
 
 bool ProcessorEntityTracker::IsUnsynced() const {
   return metadata_.sequence_number() > metadata_.acked_sequence_number();
 }
 
 bool ProcessorEntityTracker::RequiresCommitRequest() const {
   return metadata_.sequence_number() > commit_requested_sequence_number_;
 }
 
@@ skipping 38 matching lines @@
 }
 
 void ProcessorEntityTracker::MakeLocalChange(std::unique_ptr<EntityData> data) {
   DCHECK(!metadata_.client_tag_hash().empty());
   DCHECK_EQ(metadata_.client_tag_hash(), data->client_tag_hash);
 
   if (data->modification_time.is_null()) {
     data->modification_time = base::Time::Now();
   }
 
+  IncrementSequenceNumber();
+  UpdateSpecificsHash(data->specifics);
   metadata_.set_modification_time(
       syncer::TimeToProtoTime(data->modification_time));
   metadata_.set_is_deleted(false);
-  IncrementSequenceNumber();
-  UpdateSpecificsHash(data->specifics);
 
   data->id = metadata_.server_id();
   data->creation_time = syncer::ProtoTimeToTime(metadata_.creation_time());
   commit_data_.reset();
   CacheCommitData(data.get());
 }
 
 void ProcessorEntityTracker::Delete() {
   IncrementSequenceNumber();
   metadata_.set_is_deleted(true);
@@ skipping 13 matching lines @@
     // done lazily here to simplify loading a pending deletion on startup.
     EntityData data;
     data.client_tag_hash = metadata_.client_tag_hash();
     data.id = metadata_.server_id();
     data.creation_time = syncer::ProtoTimeToTime(metadata_.creation_time());
     request->entity = data.PassToPtr();
   }
 
   request->sequence_number = metadata_.sequence_number();
   request->base_version = metadata_.server_version();
+  request->specifics_hash = metadata_.specifics_hash();
   commit_requested_sequence_number_ = metadata_.sequence_number();
 }
 
 void ProcessorEntityTracker::ReceiveCommitResponse(
-    const std::string& id,
-    int64_t sequence_number,
-    int64_t response_version) {
-  DCHECK(sequence_number > metadata_.acked_sequence_number());
+    const CommitResponseData& data) {
+  DCHECK_EQ(metadata_.client_tag_hash(), data.client_tag_hash);
+  DCHECK_GT(data.sequence_number, metadata_.acked_sequence_number());
+  DCHECK_GT(data.response_version, metadata_.server_version());
 
   // The server can assign us a new ID in a commit response.
-  metadata_.set_server_id(id);
-  metadata_.set_acked_sequence_number(sequence_number);
-  metadata_.set_server_version(response_version);
+  metadata_.set_server_id(data.id);
+  metadata_.set_acked_sequence_number(data.sequence_number);
+  metadata_.set_server_version(data.response_version);
   if (!IsUnsynced()) {
     // Clear pending commit data if there hasn't been another commit request
     // since the one that is currently getting acked.
     commit_data_.reset();
+    metadata_.clear_base_specifics_hash();
+  } else {
+    metadata_.set_base_specifics_hash(data.specifics_hash);
   }
 }
 
 void ProcessorEntityTracker::ClearTransientSyncState() {
   // If we have any unacknowledged commit requests outstanding, they've been
   // dropped and we should forget about them.
   commit_requested_sequence_number_ = metadata_.acked_sequence_number();
 }
 
 void ProcessorEntityTracker::IncrementSequenceNumber() {
   DCHECK(metadata_.has_sequence_number());
+  if (!IsUnsynced()) {
+    // Update the base specifics hash if this entity wasn't already out of sync.
+    metadata_.set_base_specifics_hash(metadata_.specifics_hash());
+  }
   metadata_.set_sequence_number(metadata_.sequence_number() + 1);
 }
 
-// Update hash string for EntitySpecifics.
+bool ProcessorEntityTracker::MatchesSpecificsHash(
+    const sync_pb::EntitySpecifics& specifics) const {
+  DCHECK(!metadata_.is_deleted());
+  std::string hash;
+  HashSpecifics(specifics, &hash);
+  return hash == metadata_.specifics_hash();
+}
+
 void ProcessorEntityTracker::UpdateSpecificsHash(
     const sync_pb::EntitySpecifics& specifics) {
   if (specifics.ByteSize() > 0) {
     HashSpecifics(specifics, metadata_.mutable_specifics_hash());
   } else {
     metadata_.clear_specifics_hash();
   }
 }
 
 }  // namespace syncer_v2