[Sync] Introduce AttachmentStoreForSync class

sync/internal_api/attachments/attachment_service_impl.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 "sync/internal_api/public/attachments/attachment_service_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 92 matching lines @@
     // All requests completed. Let's notify consumer.
     GetOrDownloadResult result =
         unavailable_attachments_.empty() ? GET_SUCCESS : GET_UNSPECIFIED_ERROR;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback_, result, base::Passed(&retrieved_attachments_)));
   }
 }
 
 AttachmentServiceImpl::AttachmentServiceImpl(
-    scoped_ptr<AttachmentStore> attachment_store,
+    scoped_ptr<AttachmentStoreForSync> attachment_store,
     scoped_ptr<AttachmentUploader> attachment_uploader,
     scoped_ptr<AttachmentDownloader> attachment_downloader,
     Delegate* delegate,
     const base::TimeDelta& initial_backoff_delay,
     const base::TimeDelta& max_backoff_delay)
     : attachment_store_(attachment_store.Pass()),
       attachment_uploader_(attachment_uploader.Pass()),
       attachment_downloader_(attachment_downloader.Pass()),
       delegate_(delegate),
       weak_ptr_factory_(this) {
@@ skipping 20 matching lines @@
 
 // Static.
 scoped_ptr<syncer::AttachmentService> AttachmentServiceImpl::CreateForTest() {
   scoped_ptr<syncer::AttachmentStore> attachment_store =
       AttachmentStore::CreateInMemoryStore();
   scoped_ptr<AttachmentUploader> attachment_uploader(
       new FakeAttachmentUploader);
   scoped_ptr<AttachmentDownloader> attachment_downloader(
       new FakeAttachmentDownloader());
   scoped_ptr<syncer::AttachmentService> attachment_service(
-      new syncer::AttachmentServiceImpl(attachment_store.Pass(),
-                                        attachment_uploader.Pass(),
-                                        attachment_downloader.Pass(),
-                                        NULL,
-                                        base::TimeDelta(),
-                                        base::TimeDelta()));
+      new syncer::AttachmentServiceImpl(
+          attachment_store->CreateAttachmentStoreForSync(),
+          attachment_uploader.Pass(), attachment_downloader.Pass(), NULL,
+          base::TimeDelta(), base::TimeDelta()));
   return attachment_service.Pass();
 }
 
 void AttachmentServiceImpl::GetOrDownloadAttachments(
     const AttachmentIdList& attachment_ids,
     const GetOrDownloadCallback& callback) {
   DCHECK(CalledOnValidThread());
   scoped_refptr<GetOrDownloadState> state(
       new GetOrDownloadState(attachment_ids, callback));
   attachment_store_->Read(attachment_ids,
@@ skipping 46 matching lines @@
     case AttachmentStore::STORE_INITIALIZATION_FAILED:
       state->AddUnavailableAttachmentId(attachment.GetId());
       break;
   }
 }
 
 void AttachmentServiceImpl::UploadDone(
     const AttachmentUploader::UploadResult& result,
     const AttachmentId& attachment_id) {
   DCHECK(CalledOnValidThread());
+  AttachmentIdList ids;
+  ids.push_back(attachment_id);
   switch (result) {
     case AttachmentUploader::UPLOAD_SUCCESS:
+      attachment_store_->DropSyncReference(ids);
       upload_task_queue_->MarkAsSucceeded(attachment_id);
       if (delegate_) {
         delegate_->OnAttachmentUploaded(attachment_id);
       }
       break;
     case AttachmentUploader::UPLOAD_TRANSIENT_ERROR:
       upload_task_queue_->MarkAsFailed(attachment_id);
       upload_task_queue_->AddToQueue(attachment_id);
       break;
     case AttachmentUploader::UPLOAD_UNSPECIFIED_ERROR:
       // TODO(pavely): crbug/372622: Deal with UploadAttachment failures.
+      attachment_store_->DropSyncReference(ids);
       upload_task_queue_->MarkAsFailed(attachment_id);
       break;
   }
 }
 
 void AttachmentServiceImpl::DownloadDone(
     const scoped_refptr<GetOrDownloadState>& state,
     const AttachmentId& attachment_id,
     const AttachmentDownloader::DownloadResult& result,
     scoped_ptr<Attachment> attachment) {
@@ skipping 22 matching lines @@
                           base::Bind(&AttachmentServiceImpl::ReadDoneNowUpload,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void AttachmentServiceImpl::UploadAttachments(
     const AttachmentIdList& attachment_ids) {
   DCHECK(CalledOnValidThread());
   if (!attachment_uploader_.get()) {
     return;
   }
+  attachment_store_->SetSyncReference(attachment_ids);
+
   for (auto iter = attachment_ids.begin(); iter != attachment_ids.end();
        ++iter) {
     upload_task_queue_->AddToQueue(*iter);
   }
 }
 
 void AttachmentServiceImpl::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   if (type != net::NetworkChangeNotifier::CONNECTION_NONE) {
     upload_task_queue_->ResetBackoff();
   }
 }
 
 void AttachmentServiceImpl::ReadDoneNowUpload(
     const AttachmentStore::Result& result,
     scoped_ptr<AttachmentMap> attachments,
     scoped_ptr<AttachmentIdList> unavailable_attachment_ids) {
   DCHECK(CalledOnValidThread());
   if (!unavailable_attachment_ids->empty()) {
     // TODO(maniscalco): We failed to read some attachments. What should we do
     // now?
     AttachmentIdList::const_iterator iter = unavailable_attachment_ids->begin();
     AttachmentIdList::const_iterator end = unavailable_attachment_ids->end();
     for (; iter != end; ++iter) {
       upload_task_queue_->Cancel(*iter);
     }
+    attachment_store_->DropSyncReference(*unavailable_attachment_ids);
   }
 
   AttachmentMap::const_iterator iter = attachments->begin();
   AttachmentMap::const_iterator end = attachments->end();
   for (; iter != end; ++iter) {
     attachment_uploader_->UploadAttachment(
         iter->second,
         base::Bind(&AttachmentServiceImpl::UploadDone,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void AttachmentServiceImpl::SetTimerForTest(scoped_ptr<base::Timer> timer) {
   upload_task_queue_->SetTimerForTest(timer.Pass());
 }
 
 }  // namespace syncer