Update sync API to support attachments.

chrome/browser/sync/glue/generic_change_processor.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 "chrome/browser/sync/glue/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 21 matching lines @@
           syncer::PASSWORDS) {
     write_node->SetPasswordSpecifics(
         entity_specifics.password().client_only_encrypted_data());
   } else {
     write_node->SetEntitySpecifics(entity_specifics);
   }
 }
 
 syncer::SyncData BuildRemoteSyncData(
     int64 sync_id,
-    const syncer::BaseNode& read_node) {
+    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(),
-                                              read_node.GetModificationTime());
+                                              read_node.GetModificationTime(),
+                                              attachment_ids,
+                                              attachment_service_proxy);
   }
 
   // Passwords must be accessed differently, to account for their encryption,
   // and stored into a temporary EntitySpecifics.
   sync_pb::EntitySpecifics password_holder;
   password_holder.mutable_password()->mutable_client_only_encrypted_data()->
       CopyFrom(read_node.GetPasswordSpecifics());
   return syncer::SyncData::CreateRemoteData(sync_id,
                                             password_holder,
-                                            read_node.GetModificationTime());
+                                            read_node.GetModificationTime(),
+                                            attachment_ids,
+                                            attachment_service_proxy);
 }
 
 }  // namespace
 
 GenericChangeProcessor::GenericChangeProcessor(
     DataTypeErrorHandler* error_handler,
     const base::WeakPtr<syncer::SyncableService>& local_service,
     const base::WeakPtr<syncer::SyncMergeResult>& merge_result,
-    syncer::UserShare* user_share)
+    syncer::UserShare* user_share,
+    scoped_ptr<syncer::AttachmentService> attachment_service)
     : ChangeProcessor(error_handler),
       local_service_(local_service),
       merge_result_(merge_result),
-      share_handle_(user_share) {
+      share_handle_(user_share),
+      attachment_service_(attachment_service.Pass()),
+      attachment_service_weak_ptr_factory_(attachment_service_.get()),
+      attachment_service_proxy_(syncer::AttachmentServiceProxy(
+          base::MessageLoopProxy::current(),
+          attachment_service_weak_ptr_factory_.GetWeakPtr())) {
   DCHECK(CalledOnValidThread());
+  DCHECK(attachment_service_);
 }
 
 GenericChangeProcessor::~GenericChangeProcessor() {
   DCHECK(CalledOnValidThread());
 }
 
 void GenericChangeProcessor::ApplyChangesFromSyncModel(
     const syncer::BaseTransaction* trans,
     int64 model_version,
     const syncer::ImmutableChangeRecordList& changes) {
   DCHECK(CalledOnValidThread());
   DCHECK(syncer_changes_.empty());
   for (syncer::ChangeRecordList::const_iterator it =
            changes.Get().begin(); it != changes.Get().end(); ++it) {
     if (it->action == syncer::ChangeRecord::ACTION_DELETE) {
       scoped_ptr<sync_pb::EntitySpecifics> specifics;
       if (it->specifics.has_password()) {
         DCHECK(it->extra.get());
         specifics.reset(new sync_pb::EntitySpecifics(it->specifics));
         specifics->mutable_password()->mutable_client_only_encrypted_data()->
             CopyFrom(it->extra->unencrypted());
       }
-      syncer_changes_.push_back(syncer::SyncChange(
-          FROM_HERE,
-          syncer::SyncChange::ACTION_DELETE,
-          syncer::SyncData::CreateRemoteData(
-              it->id, specifics ? *specifics : it->specifics, base::Time())));
+      const syncer::AttachmentIdList empty_list_of_attachment_ids;
+      syncer_changes_.push_back(
+          syncer::SyncChange(FROM_HERE,
+                             syncer::SyncChange::ACTION_DELETE,
+                             syncer::SyncData::CreateRemoteData(
+                                 it->id,
+                                 specifics ? *specifics : it->specifics,
+                                 base::Time(),
+                                 empty_list_of_attachment_ids,
+                                 attachment_service_proxy_)));
     } else {
       syncer::SyncChange::SyncChangeType action =
           (it->action == syncer::ChangeRecord::ACTION_ADD) ?
           syncer::SyncChange::ACTION_ADD : syncer::SyncChange::ACTION_UPDATE;
       // Need to load specifics from node.
       syncer::ReadNode read_node(trans);
       if (read_node.InitByIdLookup(it->id) != syncer::BaseNode::INIT_OK) {
         error_handler()->OnSingleDatatypeUnrecoverableError(
             FROM_HERE,
             "Failed to look up data for received change with id " +
                 base::Int64ToString(it->id));
         return;
       }
-      syncer_changes_.push_back(
-          syncer::SyncChange(
-              FROM_HERE,
-              action,
-              BuildRemoteSyncData(it->id, read_node)));
+      syncer_changes_.push_back(syncer::SyncChange(
+          FROM_HERE,
+          action,
+          BuildRemoteSyncData(it->id, read_node, attachment_service_proxy_)));
     }
   }
 }
 
 void GenericChangeProcessor::CommitChangesFromSyncModel() {
   DCHECK(CalledOnValidThread());
   if (syncer_changes_.empty())
     return;
   if (!local_service_.get()) {
     syncer::ModelType type = syncer_changes_[0].sync_data().GetDataType();
@@ skipping 51 matching lines @@
     syncer::ReadNode sync_child_node(&trans);
     if (sync_child_node.InitByIdLookup(*it) !=
             syncer::BaseNode::INIT_OK) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to fetch child node for type " +
                                   type_name + ".",
                               type);
       return error;
     }
-    current_sync_data->push_back(BuildRemoteSyncData(sync_child_node.GetId(),
-                                                     sync_child_node));
+    current_sync_data->push_back(BuildRemoteSyncData(
+        sync_child_node.GetId(), sync_child_node, attachment_service_proxy_));
   }
   return syncer::SyncError();
 }
 
 int GenericChangeProcessor::GetSyncCountForType(syncer::ModelType type) {
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   syncer::ReadNode root(&trans);
   if (root.InitByTagLookup(syncer::ModelTypeToRootTag(type)) !=
       syncer::BaseNode::INIT_OK)
     return 0;
@@ skipping 130 matching lines @@
     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);
       if (error.IsSet()) {
         return error;
       }
@@ skipping 91 matching lines @@
         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(base::UTF8ToWide(change.sync_data().GetTitle()));
   SetNodeSpecifics(change.sync_data().GetSpecifics(), sync_node);
+  attachment_service_->OnSyncDataAdd(change.sync_data());
   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(
@@ skipping 81 matching lines @@
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         LOG(ERROR) << "Update: encr case 4.";
         return error;
       }
     }
   }
 
   sync_node->SetTitle(base::UTF8ToWide(change.sync_data().GetTitle()));
   SetNodeSpecifics(change.sync_data().GetSpecifics(), sync_node);
+  attachment_service_->OnSyncDataUpdate(sync_node->GetAttachmentIds(),
+                                        change.sync_data());
   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(Profile* profile) {
   DCHECK(CalledOnValidThread());
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync