Make GenericChangeProcessor upload attachments on startup.

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 "components/sync_driver/sync_api_component_factory.h"
@@ skipping 94 matching lines @@
   DCHECK_NE(type_, syncer::UNSPECIFIED);
   if (attachment_store.get()) {
     attachment_service_ = sync_factory->CreateAttachmentService(
         attachment_store, *user_share, this);
     attachment_service_weak_ptr_factory_.reset(
         new base::WeakPtrFactory<syncer::AttachmentService>(
             attachment_service_.get()));
     attachment_service_proxy_.reset(new syncer::AttachmentServiceProxy(
         base::MessageLoopProxy::current(),
         attachment_service_weak_ptr_factory_->GetWeakPtr()));
+    UploadAllAttachmentsNotOnServer();
   } else {
     attachment_service_proxy_.reset(new syncer::AttachmentServiceProxy(
         base::MessageLoopProxy::current(),
         base::WeakPtr<syncer::AttachmentService>()));
   }
 }
 
 GenericChangeProcessor::~GenericChangeProcessor() {
   DCHECK(CalledOnValidThread());
 }
@@ skipping 276 matching lines @@
 
 }  // 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::AttachmentIdList new_attachments;
+  syncer::AttachmentIdSet 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_EQ(change.sync_data().GetDataType(), type_);
     std::string type_str = syncer::ModelTypeToString(type_);
     syncer::WriteNode sync_node(&trans);
@@ skipping 41 matching lines @@
       syncer::SyncError error(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "Datatype performs attachment operation without initializing "
           "attachment store",
           type_);
       error_handler()->OnSingleDataTypeUnrecoverableError(error);
       NOTREACHED();
       return error;
     }
-    UploadAttachments(new_attachments);
+    attachment_service_->UploadAttachments(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::WriteTransaction& trans,
     syncer::WriteNode* sync_node,
-    syncer::AttachmentIdList* new_attachments) {
+    syncer::AttachmentIdSet* 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.InitTypeRoot(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_);
@@ skipping 47 matching lines @@
       }
     }
   }
   sync_node->SetTitle(change.sync_data().GetTitle());
   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.
-  new_attachments->insert(
-      new_attachments->end(), attachment_ids.begin(), attachment_ids.end());
+  new_attachments->insert(attachment_ids.begin(), attachment_ids.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::WriteTransaction& trans,
     syncer::WriteNode* sync_node,
-    syncer::AttachmentIdList* new_attachments) {
+    syncer::AttachmentIdSet* 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(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) {
@@ skipping 65 matching lines @@
       }
     }
   }
 
   sync_node->SetTitle(change.sync_data().GetTitle());
   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.
-  new_attachments->insert(
-      new_attachments->end(), attachment_ids.begin(), attachment_ids.end());
+  new_attachments->insert(attachment_ids.begin(), attachment_ids.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();
 }
 
@@ skipping 26 matching lines @@
 }
 
 void GenericChangeProcessor::StartImpl() {
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
-void GenericChangeProcessor::UploadAttachments(
-    const syncer::AttachmentIdList& attachment_ids) {
+void GenericChangeProcessor::UploadAllAttachmentsNotOnServer() {
   DCHECK(CalledOnValidThread());
-  DCHECK(attachment_service_.get() != NULL);
-
-  syncer::AttachmentIdSet attachment_id_set;
-  attachment_id_set.insert(attachment_ids.begin(), attachment_ids.end());
-  attachment_service_->UploadAttachments(attachment_id_set);
+  DCHECK(attachment_service_.get());
+  syncer::AttachmentIdSet id_set;
+  {
+    syncer::ReadTransaction trans(FROM_HERE, share_handle());
+    trans.GetAttachmentIdsToUpload(type_, &id_set);
+  }
+  if (!id_set.empty()) {
+    attachment_service_->UploadAttachments(id_set);
+  }
 }
 
 }  // namespace sync_driver