Move AttachmentStore ownership to datatype

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 79 matching lines @@
   return attachment.GetId();
 }
 
 }  // namespace
 
 GenericChangeProcessor::GenericChangeProcessor(
     DataTypeErrorHandler* error_handler,
     const base::WeakPtr<syncer::SyncableService>& local_service,
     const base::WeakPtr<syncer::SyncMergeResult>& merge_result,
     syncer::UserShare* user_share,
-    SyncApiComponentFactory* sync_factory)
+    SyncApiComponentFactory* sync_factory,
+    const scoped_refptr<syncer::AttachmentStore>& attachment_store)
     : ChangeProcessor(error_handler),
       local_service_(local_service),
       merge_result_(merge_result),
       share_handle_(user_share),
-      attachment_service_(
-          sync_factory->CreateAttachmentService(*user_share, this)),
-      attachment_service_weak_ptr_factory_(attachment_service_.get()),
-      attachment_service_proxy_(
-          base::MessageLoopProxy::current(),
-          attachment_service_weak_ptr_factory_.GetWeakPtr()),
       weak_ptr_factory_(this) {
   DCHECK(CalledOnValidThread());
-  DCHECK(attachment_service_);
+  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()));
+  } else {
+    attachment_service_proxy_.reset(new syncer::AttachmentServiceProxy(
+        base::MessageLoopProxy::current(),
+        base::WeakPtr<syncer::AttachmentService>()));
+  }
 }
 
 GenericChangeProcessor::~GenericChangeProcessor() {
   DCHECK(CalledOnValidThread());
 }
 
 void GenericChangeProcessor::ApplyChangesFromSyncModel(
     const syncer::BaseTransaction* trans,
     int64 model_version,
     const syncer::ImmutableChangeRecordList& changes) {
@@ skipping 11 matching lines @@
       }
       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_)));
+                                 *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) {
         syncer::SyncError error(
             FROM_HERE,
             syncer::SyncError::DATATYPE_ERROR,
             "Failed to look up data for received change with id " +
                 base::Int64ToString(it->id),
             syncer::GetModelTypeFromSpecifics(it->specifics));
         error_handler()->OnSingleDataTypeUnrecoverableError(error);
         return;
       }
       syncer_changes_.push_back(syncer::SyncChange(
           FROM_HERE,
           action,
-          BuildRemoteSyncData(it->id, read_node, attachment_service_proxy_)));
+          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 76 matching lines @@
     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, attachment_service_proxy_));
+        sync_child_node.GetId(), sync_child_node, *attachment_service_proxy_));
   }
   return syncer::SyncError();
 }
 
 bool GenericChangeProcessor::GetDataTypeContext(syncer::ModelType type,
                                                 std::string* context) const {
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   sync_pb::DataTypeContext context_proto;
   trans.GetDataTypeContext(type, &context_proto);
   if (!context_proto.has_context())
@@ skipping 126 matching lines @@
     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());
 
+  syncer::ModelType type = syncer::UNSPECIFIED;
+
   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();
+    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;
       }
       if (merge_result_.get()) {
@@ skipping 20 matching lines @@
               change.location().ToString(),
           type);
       error_handler()->OnSingleDataTypeUnrecoverableError(error);
       NOTREACHED();
       LOG(ERROR) << "Unset sync change.";
       return error;
     }
   }
 
   if (!new_attachments.empty()) {
+    // If datatype uses attachments it should have supplied attachment store
+    // which would initialize attachment_service_. Fail if it isn't so.
+    if (!attachment_service_.get()) {
+      DCHECK_NE(type, syncer::UNSPECIFIED);
+      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;
+    }
     StoreAndUploadAttachments(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.
@@ skipping 229 matching lines @@
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 void GenericChangeProcessor::StoreAndUploadAttachments(
     const syncer::AttachmentList& attachments) {
   DCHECK(CalledOnValidThread());
+  DCHECK(attachment_service_.get() != NULL);
   attachment_service_->GetStore()->Write(
       attachments,
       base::Bind(&GenericChangeProcessor::WriteAttachmentsDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  attachments));
 }
 
 void GenericChangeProcessor::WriteAttachmentsDone(
     const syncer::AttachmentList& attachments,
     const syncer::AttachmentStore::Result& result) {
   DCHECK(CalledOnValidThread());
+  DCHECK(attachment_service_.get() != NULL);
   if (result != syncer::AttachmentStore::SUCCESS) {
     // TODO(maniscalco): Deal with case where an error occurred (bug 361251).
     return;
   }
 
   // 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).
 
   // Begin uploading the attachments now that they are safe on disk.
   syncer::AttachmentIdSet attachment_ids;
   std::transform(attachments.begin(),
                  attachments.end(),
                  std::inserter(attachment_ids, attachment_ids.end()),
                  AttachmentToAttachmentId);
   attachment_service_->UploadAttachments(attachment_ids);
 }
 
 }  // namespace sync_driver