Update Commit and GetUpdatesResponse messages to include attachment ids.

sync/engine/conflict_resolver.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/conflict_resolver.h"
 
 #include <list>
 #include <set>
 #include <string>
 
@@ skipping 12 matching lines @@
 
 namespace syncer {
 
 using sessions::StatusController;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::WriteTransaction;
 
+namespace {
+
+// Returns true iff the set of attachment ids contained in attachment_metadata
+// matches the set of ids contained in server_attachment_metadata.
+bool AttachmentMetadataMatches(const MutableEntry& entity) {
+  const sync_pb::AttachmentMetadata& local = entity.GetAttachmentMetadata();
+  const sync_pb::AttachmentMetadata& server =
+      entity.GetServerAttachmentMetadata();
+  if (local.record_size() != server.record_size()) {
+    return false;
+  }
+
+  // The order of records in local and server may be different so use a std::set
+  // to determine if they are equivalent.
+  std::set<std::string> local_ids;
+  for (int i = 0; i < local.record_size(); ++i) {
+    const sync_pb::AttachmentMetadataRecord& record = local.record(i);
+    DCHECK(record.is_on_server());
+    local_ids.insert(record.id().SerializeAsString());
+  }
+  for (int i = 0; i < server.record_size(); ++i) {
+    const sync_pb::AttachmentMetadataRecord& record = server.record(i);
+    DCHECK(record.is_on_server());
+    if (local_ids.find(record.id().SerializeAsString()) == local_ids.end()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace
+
 ConflictResolver::ConflictResolver() {
 }
 
 ConflictResolver::~ConflictResolver() {
 }
 
 void ConflictResolver::ProcessSimpleConflict(WriteTransaction* trans,
                                              const Id& id,
                                              const Cryptographer* cryptographer,
                                              StatusController* status,
@@ skipping 98 matching lines @@
         decrypted_base_server_specifics =
             base_server_specifics.SerializeAsString();
       } else {
         decrypted_base_server_specifics = cryptographer->DecryptToString(
             base_server_specifics.encrypted());
       }
       if (decrypted_server_specifics == decrypted_base_server_specifics)
           base_server_specifics_match = true;
     }
 
+    bool attachment_metadata_matches = AttachmentMetadataMatches(entry);
     if (!entry_deleted && name_matches && parent_matches && specifics_match &&
-        position_matches) {
+        position_matches && attachment_metadata_matches) {
       DVLOG(1) << "Resolving simple conflict, everything matches, ignoring "
                << "changes for: " << entry;
       conflict_util::IgnoreConflict(&entry);
       UMA_HISTOGRAM_ENUMERATION("Sync.ResolveSimpleConflict",
                                 CHANGES_MATCH,
                                 CONFLICT_RESOLUTION_SIZE);
     } else if (base_server_specifics_match) {
       DVLOG(1) << "Resolving simple conflict, ignoring server encryption "
                << " changes for: " << entry;
       status->increment_num_server_overwrites();
@@ skipping 72 matching lines @@
         GetModelTypeFromSpecifics(conflicting_node.GetSpecifics()))) {
       continue;
     }
 
     ProcessSimpleConflict(trans, *it, cryptographer, status, counters);
   }
   return;
 }
 
 }  // namespace syncer