Move AttachmentStore ownership to datatype

sync/internal_api/attachments/attachment_service_impl_unittest.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 "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 65 matching lines @@
     write_attachments.pop_back();
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, result));
   }
 
   std::vector<AttachmentIdList> read_ids;
   std::vector<ReadCallback> read_callbacks;
   std::vector<AttachmentList> write_attachments;
   std::vector<WriteCallback> write_callbacks;
 
+ private:
+  virtual ~MockAttachmentStore() {}
+
   DISALLOW_COPY_AND_ASSIGN(MockAttachmentStore);
 };
 
 class MockAttachmentDownloader
     : public AttachmentDownloader,
       public base::SupportsWeakPtr<MockAttachmentDownloader> {
  public:
   MockAttachmentDownloader() {}
 
   virtual void DownloadAttachment(const AttachmentId& id,
@@ skipping 70 matching lines @@
   // AttachmentService::Delegate implementation.
   virtual void OnAttachmentUploaded(
       const AttachmentId& attachment_id) OVERRIDE {
     on_attachment_uploaded_list_.push_back(attachment_id);
   }
 
   void InitializeAttachmentService(
       scoped_ptr<MockAttachmentUploader> uploader,
       scoped_ptr<MockAttachmentDownloader> downloader,
       AttachmentService::Delegate* delegate) {
-    scoped_ptr<MockAttachmentStore> attachment_store(new MockAttachmentStore());
+    scoped_refptr<MockAttachmentStore> attachment_store(
+        new MockAttachmentStore());
     attachment_store_ = attachment_store->AsWeakPtr();
 
     if (uploader.get()) {
       attachment_uploader_ = uploader->AsWeakPtr();
     }
     if (downloader.get()) {
       attachment_downloader_ = downloader->AsWeakPtr();
     }
     attachment_service_.reset(
-        new AttachmentServiceImpl(attachment_store.PassAs<AttachmentStore>(),
+        new AttachmentServiceImpl(attachment_store,
                                   uploader.PassAs<AttachmentUploader>(),
                                   downloader.PassAs<AttachmentDownloader>(),
                                   delegate));
   }
 
   AttachmentService* attachment_service() { return attachment_service_.get(); }
 
   AttachmentService::GetOrDownloadCallback download_callback() {
     return base::Bind(&AttachmentServiceImplTest::DownloadDone,
                       base::Unretained(this));
@@ skipping 246 matching lines @@
   EXPECT_EQ(1U, store()->write_attachments.size());
 
   store()->RespondToWrite(AttachmentStore::SUCCESS);
   RunLoop();
   ASSERT_EQ(1U, store_results().size());
   EXPECT_EQ(AttachmentService::STORE_SUCCESS, store_results()[0]);
   EXPECT_TRUE(on_attachment_uploaded_list().empty());
 }
 
 }  // namespace syncer