Pass AttachmentIdList instead of AttachmentList to SyncData

sync/api/sync_data.cc

 // Copyright (c) 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/api/sync_data.h"
 
 #include <ostream>
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base_node.h"
 #include "sync/protocol/proto_value_conversions.h"
 #include "sync/protocol/sync.pb.h"
 
-using syncer::Attachment;
-using syncer::AttachmentIdList;
-using syncer::AttachmentList;
-
 namespace {
 
-sync_pb::AttachmentIdProto AttachmentToProto(
-    const syncer::Attachment& attachment) {
-  return attachment.GetId().GetProto();
-}
-
 sync_pb::AttachmentIdProto IdToProto(
     const syncer::AttachmentId& attachment_id) {
   return attachment_id.GetProto();
 }
 
 syncer::AttachmentId ProtoToId(const sync_pb::AttachmentIdProto& proto) {
   return syncer::AttachmentId::CreateFromProto(proto);
 }
 
-// Return true iff |attachments| contains one or more elements with the same
-// AttachmentId.
-bool ContainsDuplicateAttachments(const syncer::AttachmentList& attachments) {
-  std::set<syncer::AttachmentId> id_set;
-  AttachmentList::const_iterator iter = attachments.begin();
-  AttachmentList::const_iterator end = attachments.end();
-  for (; iter != end; ++iter) {
-    if (id_set.find(iter->GetId()) != id_set.end()) {
-      return true;
-    }
-    id_set.insert(iter->GetId());
-  }
-  return false;
+// Return true iff |attachment_ids| contains duplicates.
+bool ContainsDuplicateAttachments(
+    const syncer::AttachmentIdList& attachment_ids) {
+  syncer::AttachmentIdSet id_set;
+  id_set.insert(attachment_ids.begin(), attachment_ids.end());
+  return id_set.size() != attachment_ids.size();
 }
 
 }  // namespace
 
 namespace syncer {
 
 void SyncData::ImmutableSyncEntityTraits::InitializeWrapper(Wrapper* wrapper) {
   *wrapper = new sync_pb::SyncEntity();
 }
 
@@ skipping 13 matching lines @@
 
 void SyncData::ImmutableSyncEntityTraits::Swap(sync_pb::SyncEntity* t1,
                                                sync_pb::SyncEntity* t2) {
   t1->Swap(t2);
 }
 
 SyncData::SyncData() : id_(kInvalidId), is_valid_(false) {}
 
 SyncData::SyncData(int64 id,
                    sync_pb::SyncEntity* entity,
-                   AttachmentList* attachments,
                    const base::Time& remote_modification_time,
                    const syncer::AttachmentServiceProxy& attachment_service)
     : id_(id),
       remote_modification_time_(remote_modification_time),
       immutable_entity_(entity),
-      attachments_(attachments),
       attachment_service_(attachment_service),
       is_valid_(true) {}
 
 SyncData::~SyncData() {}
 
 // Static.
 SyncData SyncData::CreateLocalDelete(const std::string& sync_tag,
                                      ModelType datatype) {
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(datatype, &specifics);
   return CreateLocalData(sync_tag, std::string(), specifics);
 }
 
 // Static.
 SyncData SyncData::CreateLocalData(const std::string& sync_tag,
                                    const std::string& non_unique_title,
                                    const sync_pb::EntitySpecifics& specifics) {
-  syncer::AttachmentList attachments;
+  syncer::AttachmentIdList attachment_ids;
   return CreateLocalDataWithAttachments(
-      sync_tag, non_unique_title, specifics, attachments);
+      sync_tag, non_unique_title, specifics, attachment_ids);
 }
 
 // Static.
 SyncData SyncData::CreateLocalDataWithAttachments(
     const std::string& sync_tag,
     const std::string& non_unique_title,
     const sync_pb::EntitySpecifics& specifics,
-    const AttachmentList& attachments) {
-  DCHECK(!ContainsDuplicateAttachments(attachments));
+    const AttachmentIdList& attachment_ids) {
+  DCHECK(!ContainsDuplicateAttachments(attachment_ids));
   sync_pb::SyncEntity entity;
   entity.set_client_defined_unique_tag(sync_tag);
   entity.set_non_unique_name(non_unique_title);
   entity.mutable_specifics()->CopyFrom(specifics);
-  std::transform(attachments.begin(),
-                 attachments.end(),
+  std::transform(attachment_ids.begin(),
+                 attachment_ids.end(),
                  RepeatedFieldBackInserter(entity.mutable_attachment_id()),
-                 AttachmentToProto);
-  AttachmentList copy_of_attachments(attachments);
+                 IdToProto);
   return SyncData(kInvalidId,
                   &entity,
-                  &copy_of_attachments,
                   base::Time(),
                   AttachmentServiceProxy());
 }
 
 // Static.
 SyncData SyncData::CreateRemoteData(
     int64 id,
     const sync_pb::EntitySpecifics& specifics,
     const base::Time& modification_time,
     const AttachmentIdList& attachment_ids,
     const AttachmentServiceProxy& attachment_service) {
   DCHECK_NE(id, kInvalidId);
   sync_pb::SyncEntity entity;
   entity.mutable_specifics()->CopyFrom(specifics);
   std::transform(attachment_ids.begin(),
                  attachment_ids.end(),
                  RepeatedFieldBackInserter(entity.mutable_attachment_id()),
                  IdToProto);
-  AttachmentList attachments;
-  return SyncData(
-      id, &entity, &attachments, modification_time, attachment_service);
+  return SyncData(id, &entity, modification_time, attachment_service);
 }
 
 bool SyncData::IsValid() const { return is_valid_; }
 
 const sync_pb::EntitySpecifics& SyncData::GetSpecifics() const {
   return immutable_entity_.Get().specifics();
 }
 
 ModelType SyncData::GetDataType() const {
   return GetModelTypeFromSpecifics(GetSpecifics());
@@ skipping 44 matching lines @@
                  ProtoToId);
   return result;
 }
 
 SyncDataLocal::SyncDataLocal(const SyncData& sync_data) : SyncData(sync_data) {
   DCHECK(sync_data.IsLocal());
 }
 
 SyncDataLocal::~SyncDataLocal() {}
 
-const AttachmentList& SyncDataLocal::GetLocalAttachmentsForUpload() const {
-  return attachments_.Get();
-}
-
 const std::string& SyncDataLocal::GetTag() const {
   return immutable_entity_.Get().client_defined_unique_tag();
 }
 
 SyncDataRemote::SyncDataRemote(const SyncData& sync_data)
     : SyncData(sync_data) {
   DCHECK(!sync_data.IsLocal());
 }
 
 SyncDataRemote::~SyncDataRemote() {}
@@ skipping 12 matching lines @@
   attachment_service_.GetOrDownloadAttachments(attachment_ids, callback);
 }
 
 void SyncDataRemote::DropAttachments(
     const AttachmentIdList& attachment_ids,
     const AttachmentService::DropCallback& callback) {
   attachment_service_.DropAttachments(attachment_ids, callback);
 }
 
 }  // namespace syncer