Keep track of which attachments are referenced by which sync entries.

components/sync_driver/generic_change_processor.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 "components/sync_driver/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "sync/api/sync_change.h"
@@ skipping 18 matching lines @@
                       syncer::WriteNode* write_node) {
   if (syncer::GetModelTypeFromSpecifics(entity_specifics) ==
           syncer::PASSWORDS) {
     write_node->SetPasswordSpecifics(
         entity_specifics.password().client_only_encrypted_data());
   } else {
     write_node->SetEntitySpecifics(entity_specifics);
   }
 }
 
+// Helper function to convert AttachmentId to AttachmentMetadataRecord.
+sync_pb::AttachmentMetadataRecord AttachmentIdToRecord(
+    const syncer::AttachmentId& attachment_id) {
+  sync_pb::AttachmentMetadataRecord record;
+  *record.mutable_id() = attachment_id.GetProto();
+  return record;
+}
+
+// Replace |write_nodes|'s attachment ids with |attachment_ids|.
+void SetAttachmentMetadata(const syncer::AttachmentIdList& attachment_ids,
+                           syncer::WriteNode* write_node) {
+  DCHECK(write_node);
+  sync_pb::AttachmentMetadata attachment_metadata;
+  std::transform(
+      attachment_ids.begin(),
+      attachment_ids.end(),
+      RepeatedFieldBackInserter(attachment_metadata.mutable_record()),
+      AttachmentIdToRecord);
+  write_node->SetAttachmentMetadata(attachment_metadata);
+}
+
 syncer::SyncData BuildRemoteSyncData(
     int64 sync_id,
     const syncer::BaseNode& read_node,
     const syncer::AttachmentServiceProxy& attachment_service_proxy) {
   const syncer::AttachmentIdList& attachment_ids = read_node.GetAttachmentIds();
   // Use the specifics of non-password datatypes directly (encryption has
   // already been handled).
   if (read_node.GetModelType() != syncer::PASSWORDS) {
     return syncer::SyncData::CreateRemoteData(sync_id,
                                               read_node.GetEntitySpecifics(),
@@ skipping 263 matching lines @@
       // Should have listed all the possible error cases above.
       error.Reset(from_here, error_prefix + "unknown error", type);
       error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         error.message());
       LOG(ERROR) << "Delete: Unknown error.";
       return error;
     }
   }
 }
 
-syncer::SyncError AttemptDelete(
-    const syncer::SyncChange& change,
-    syncer::ModelType type,
-    const std::string& type_str,
-    syncer::WriteNode* node,
-    DataTypeErrorHandler* error_handler) {
+syncer::SyncError AttemptDelete(const syncer::SyncChange& change,
+                                syncer::ModelType type,
+                                const std::string& type_str,
+                                syncer::WriteNode* node,
+                                DataTypeErrorHandler* error_handler) {
   DCHECK_EQ(change.change_type(), syncer::SyncChange::ACTION_DELETE);
   if (change.sync_data().IsLocal()) {
     const std::string& tag = syncer::SyncDataLocal(change.sync_data()).GetTag();
     if (tag.empty()) {
       syncer::SyncError error(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "Failed to delete " + type_str + " node. Local data, empty tag. " +
               change.location().ToString(),
           type);
@@ skipping 23 matching lines @@
           type, error_handler);
     }
   }
   if (IsActOnceDataType(type))
     node->Drop();
   else
     node->Tombstone();
   return syncer::SyncError();
 }
 
+// A callback invoked on completion of AttachmentService::StoreAttachment.
+void IgnoreStoreResult(const syncer::AttachmentService::StoreResult&) {
+  // TODO(maniscalco): Here is where we're going to update the in-directory
+  // entry to indicate that the attachments have been successfully stored on
+  // disk.  Why do we care?  Because we might crash after persisting the
+  // directory to disk, but before we have persisted its attachments, leaving us
+  // with danging attachment ids.  Having a flag that indicates we've stored the
+  // entry will allow us to detect and filter entries with dangling attachment
+  // ids (bug 368353).
+}
+
+void StoreAttachments(syncer::AttachmentService* attachment_service,
+                      const syncer::AttachmentList& attachments) {
+  DCHECK(attachment_service);
+  syncer::AttachmentService::StoreCallback ignore_store_result =
+      base::Bind(&IgnoreStoreResult);
+  attachment_service->StoreAttachments(attachments, ignore_store_result);
+}
+
 }  // namespace
 
 syncer::SyncError GenericChangeProcessor::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& list_of_changes) {
   DCHECK(CalledOnValidThread());
+
+  // Keep track of brand new attachments so we can persist them on this device
+  // and upload them to the server.
+  syncer::AttachmentList new_attachments;
+
   syncer::WriteTransaction trans(from_here, share_handle());
 
   for (syncer::SyncChangeList::const_iterator iter = list_of_changes.begin();
        iter != list_of_changes.end();
        ++iter) {
     const syncer::SyncChange& change = *iter;
     DCHECK_NE(change.sync_data().GetDataType(), syncer::UNSPECIFIED);
     syncer::ModelType type = change.sync_data().GetDataType();
     std::string type_str = syncer::ModelTypeToString(type);
     syncer::WriteNode sync_node(&trans);
     if (change.change_type() == syncer::SyncChange::ACTION_DELETE) {
       syncer::SyncError error =
           AttemptDelete(change, type, type_str, &sync_node, error_handler());
       if (error.IsSet()) {
         NOTREACHED();
         return error;
       }
-      attachment_service_->OnSyncDataDelete(change.sync_data());
       if (merge_result_.get()) {
         merge_result_->set_num_items_deleted(
             merge_result_->num_items_deleted() + 1);
       }
     } else if (change.change_type() == syncer::SyncChange::ACTION_ADD) {
-      syncer::SyncError error =
-          HandleActionAdd(change, type_str, type, trans, &sync_node);
+      syncer::SyncError error = HandleActionAdd(
+          change, type_str, type, trans, &sync_node, &new_attachments);
       if (error.IsSet()) {
         return error;
       }
     } else if (change.change_type() == syncer::SyncChange::ACTION_UPDATE) {
-      syncer::SyncError error =
-          HandleActionUpdate(change, type_str, type, trans, &sync_node);
+      syncer::SyncError error = HandleActionUpdate(
+          change, type_str, type, trans, &sync_node, &new_attachments);
       if (error.IsSet()) {
         return error;
       }
     } else {
       syncer::SyncError error(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "Received unset SyncChange in the change processor, " +
               change.location().ToString(),
           type);
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           error.message());
       NOTREACHED();
       LOG(ERROR) << "Unset sync change.";
       return error;
     }
   }
+
+  if (!new_attachments.empty()) {
+    StoreAttachments(attachment_service_.get(), new_attachments);
+  }
+
   return syncer::SyncError();
 }
 
 // WARNING: this code is sensitive to compiler optimizations. Be careful
 // modifying any code around an OnSingleDatatypeUnrecoverableError call, else
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError GenericChangeProcessor::HandleActionAdd(
     const syncer::SyncChange& change,
     const std::string& type_str,
     const syncer::ModelType& type,
     const syncer::WriteTransaction& trans,
-    syncer::WriteNode* sync_node) {
+    syncer::WriteNode* sync_node,
+    syncer::AttachmentList* new_attachments) {
   // TODO(sync): Handle other types of creation (custom parents, folders,
   // etc.).
   syncer::ReadNode root_node(&trans);
+  const syncer::SyncDataLocal sync_data_local(change.sync_data());
   if (root_node.InitByTagLookup(syncer::ModelTypeToRootTag(
-          change.sync_data().GetDataType())) != syncer::BaseNode::INIT_OK) {
+          sync_data_local.GetDataType())) != syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
                             "Failed to look up root node for type " + type_str,
                             type);
     error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         error.message());
     NOTREACHED();
     LOG(ERROR) << "Create: no root node.";
     return error;
   }
   syncer::WriteNode::InitUniqueByCreationResult result =
       sync_node->InitUniqueByCreation(
-          change.sync_data().GetDataType(),
-          root_node,
-          syncer::SyncDataLocal(change.sync_data()).GetTag());
+          sync_data_local.GetDataType(), root_node, sync_data_local.GetTag());
   if (result != syncer::WriteNode::INIT_SUCCESS) {
     std::string error_prefix = "Failed to create " + type_str + " node: " +
                                change.location().ToString() + ", ";
     switch (result) {
       case syncer::WriteNode::INIT_FAILED_EMPTY_TAG: {
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "empty tag", type);
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         LOG(ERROR) << "Create: Empty tag.";
@@ skipping 28 matching lines @@
         syncer::SyncError error;
         error.Reset(FROM_HERE, error_prefix + "unknown error", type);
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         LOG(ERROR) << "Create: Unknown error.";
         return error;
       }
     }
   }
   sync_node->SetTitle(change.sync_data().GetTitle());
-  SetNodeSpecifics(change.sync_data().GetSpecifics(), sync_node);
-  attachment_service_->OnSyncDataAdd(change.sync_data());
+  SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node);
+
+  syncer::AttachmentIdList attachment_ids = sync_data_local.GetAttachmentIds();
+  SetAttachmentMetadata(attachment_ids, sync_node);
+
+  // Return any newly added attachments.
+  const syncer::AttachmentList& local_attachments_for_upload =
+      sync_data_local.GetLocalAttachmentsForUpload();
+  new_attachments->insert(new_attachments->end(),
+                          local_attachments_for_upload.begin(),
+                          local_attachments_for_upload.end());
+
   if (merge_result_.get()) {
     merge_result_->set_num_items_added(merge_result_->num_items_added() + 1);
   }
   return syncer::SyncError();
 }
 // WARNING: this code is sensitive to compiler optimizations. Be careful
 // modifying any code around an OnSingleDatatypeUnrecoverableError call, else
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError GenericChangeProcessor::HandleActionUpdate(
     const syncer::SyncChange& change,
     const std::string& type_str,
     const syncer::ModelType& type,
     const syncer::WriteTransaction& trans,
-    syncer::WriteNode* sync_node) {
+    syncer::WriteNode* sync_node,
+    syncer::AttachmentList* new_attachments) {
   // TODO(zea): consider having this logic for all possible changes?
+
+  const syncer::SyncDataLocal sync_data_local(change.sync_data());
   syncer::BaseNode::InitByLookupResult result =
-      sync_node->InitByClientTagLookup(
-          change.sync_data().GetDataType(),
-          syncer::SyncDataLocal(change.sync_data()).GetTag());
+      sync_node->InitByClientTagLookup(sync_data_local.GetDataType(),
+                                       sync_data_local.GetTag());
   if (result != syncer::BaseNode::INIT_OK) {
     std::string error_prefix = "Failed to load " + type_str + " node. " +
                                change.location().ToString() + ", ";
     if (result == syncer::BaseNode::INIT_FAILED_PRECONDITION) {
       syncer::SyncError error;
       error.Reset(FROM_HERE, error_prefix + "empty tag", type);
       error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                           error.message());
       LOG(ERROR) << "Update: Empty tag.";
       return error;
@@ skipping 61 matching lines @@
                     type);
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         LOG(ERROR) << "Update: encr case 4.";
         return error;
       }
     }
   }
 
   sync_node->SetTitle(change.sync_data().GetTitle());
-  SetNodeSpecifics(change.sync_data().GetSpecifics(), sync_node);
-  attachment_service_->OnSyncDataUpdate(sync_node->GetAttachmentIds(),
-                                        change.sync_data());
+  SetNodeSpecifics(sync_data_local.GetSpecifics(), sync_node);
+  SetAttachmentMetadata(sync_data_local.GetAttachmentIds(), sync_node);
+
+  // Return any newly added attachments.
+  const syncer::AttachmentList& local_attachments_for_upload =
+      sync_data_local.GetLocalAttachmentsForUpload();
+  new_attachments->insert(new_attachments->end(),
+                          local_attachments_for_upload.begin(),
+                          local_attachments_for_upload.end());
+
   if (merge_result_.get()) {
     merge_result_->set_num_items_modified(merge_result_->num_items_modified() +
                                           1);
   }
   // TODO(sync): Support updating other parts of the sync node (title,
   // successor, parent, etc.).
   return syncer::SyncError();
 }
 
 bool GenericChangeProcessor::SyncModelHasUserCreatedNodes(
@@ skipping 33 matching lines @@
 void GenericChangeProcessor::StartImpl() {
   DCHECK(CalledOnValidThread());
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync