[Sync] USS: Filter out redundant changes in SMTP.

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) {
+  base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()), hash);
+}
+
+}  // namespace
+
 scoped_ptr<ProcessorEntityTracker> ProcessorEntityTracker::CreateNew(
     const std::string& client_tag,
     const std::string& client_tag_hash,
     const std::string& id,
     base::Time creation_time) {
   // Initialize metadata
   sync_pb::EntityMetadata metadata;
   metadata.set_client_tag_hash(client_tag_hash);
   if (!id.empty())
     metadata.set_server_id(id);
@@ skipping 31 matching lines @@
     data->client_tag_hash = metadata_.client_tag_hash();
   }
   commit_data_ = data->PassToPtr();
   DCHECK(HasCommitData());
 }
 
 bool ProcessorEntityTracker::HasCommitData() const {
   return !commit_data_->client_tag_hash.empty();
 }
 
+bool ProcessorEntityTracker::MatchesSpecificsHash(
+    const sync_pb::EntitySpecifics& specifics) const {
+  DCHECK(specifics.ByteSize() > 0);
+  std::string hash;
+  HashSpecifics(specifics, &hash);
+  return hash == metadata_.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_;
 }
 
 bool ProcessorEntityTracker::RequiresCommitData() const {
   return RequiresCommitRequest() && !HasCommitData() && !metadata_.is_deleted();
@@ skipping 10 matching lines @@
 bool ProcessorEntityTracker::UpdateIsInConflict(int64_t update_version) const {
   return IsUnsynced() && !UpdateIsReflection(update_version);
 }
 
 void ProcessorEntityTracker::ApplyUpdateFromServer(
     const UpdateResponseData& response_data) {
   DCHECK(metadata_.has_client_tag_hash());
   DCHECK(!metadata_.client_tag_hash().empty());
   DCHECK(metadata_.has_sequence_number());
 
-  // TODO(stanisc): crbug/561829: Filter out update if specifics hash hasn't
-  // changed.
-
   // TODO(stanisc): crbug/521867: Understand and verify the conflict resolution
   // logic here.
   // There was a conflict and the server just won it.
   // This implicitly acks all outstanding commits because a received update
   // will clobber any pending commits on the sync thread.
   metadata_.set_acked_sequence_number(metadata_.sequence_number());
   commit_requested_sequence_number_ = metadata_.sequence_number();
 
   metadata_.set_is_deleted(response_data.entity->is_deleted());
   metadata_.set_server_version(response_data.response_version);
@@ skipping 84 matching lines @@
 
 void ProcessorEntityTracker::IncrementSequenceNumber() {
   DCHECK(metadata_.has_sequence_number());
   metadata_.set_sequence_number(metadata_.sequence_number() + 1);
 }
 
 // Update hash string for EntitySpecifics.
 void ProcessorEntityTracker::UpdateSpecificsHash(
     const sync_pb::EntitySpecifics& specifics) {
   if (specifics.ByteSize() > 0) {
-    std::string hash_input;
-    specifics.AppendToString(&hash_input);
-    base::Base64Encode(base::SHA1HashString(hash_input),
-                       metadata_.mutable_specifics_hash());
+    HashSpecifics(specifics, metadata_.mutable_specifics_hash());
   } else {
     metadata_.clear_specifics_hash();
   }
 }
 
 }  // namespace syncer_v2