Move AttachmentStore ownership to datatype

components/sync_driver/generic_change_processor_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 "components/sync_driver/generic_change_processor.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 18 matching lines @@
 
 namespace sync_driver {
 
 namespace {
 
 const char kTestData[] = "some data";
 
 // A mock that keeps track of attachments passed to StoreAttachments.
 class MockAttachmentService : public syncer::AttachmentServiceImpl {
  public:
-  MockAttachmentService();
+  MockAttachmentService(
+      const scoped_refptr<syncer::AttachmentStore>& attachment_store);
   virtual ~MockAttachmentService();
   virtual void StoreAttachments(const syncer::AttachmentList& attachments,
                                 const StoreCallback& callback) OVERRIDE;
   std::vector<syncer::AttachmentList>* attachment_lists();
 
  private:
   std::vector<syncer::AttachmentList> attachment_lists_;
 };
 
-MockAttachmentService::MockAttachmentService()
-    : AttachmentServiceImpl(
-          scoped_ptr<syncer::AttachmentStore>(new syncer::FakeAttachmentStore(
-              base::MessageLoopProxy::current())),
-          scoped_ptr<syncer::AttachmentUploader>(
-              new syncer::FakeAttachmentUploader),
-          scoped_ptr<syncer::AttachmentDownloader>(
-              new syncer::FakeAttachmentDownloader),
-          NULL) {
+MockAttachmentService::MockAttachmentService(
+    const scoped_refptr<syncer::AttachmentStore>& attachment_store)
+    : AttachmentServiceImpl(attachment_store,
+                            scoped_ptr<syncer::AttachmentUploader>(
+                                new syncer::FakeAttachmentUploader),
+                            scoped_ptr<syncer::AttachmentDownloader>(
+                                new syncer::FakeAttachmentDownloader),
+                            NULL) {
 }
 
 MockAttachmentService::~MockAttachmentService() {
 }
 
 void MockAttachmentService::StoreAttachments(
     const syncer::AttachmentList& attachments,
     const StoreCallback& callback) {
   attachment_lists_.push_back(attachments);
   AttachmentServiceImpl::StoreAttachments(attachments, callback);
@@ skipping 12 matching lines @@
       : attachment_service_(attachment_service.Pass()) {}
 
   virtual base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) OVERRIDE {
     // Shouldn't be called for this test.
     NOTREACHED();
     return base::WeakPtr<syncer::SyncableService>();
   }
 
   virtual scoped_ptr<syncer::AttachmentService> CreateAttachmentService(
+      const scoped_refptr<syncer::AttachmentStore>& attachment_store,
       const syncer::UserShare& user_share,
       syncer::AttachmentService::Delegate* delegate) OVERRIDE {
     EXPECT_TRUE(attachment_service_ != NULL);
     return attachment_service_.Pass();
   }
 
  private:
   scoped_ptr<syncer::AttachmentService> attachment_service_;
 };
 
@@ skipping 10 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     test_user_share_.SetUp();
     syncer::ModelTypeSet types = syncer::ProtocolTypes();
     for (syncer::ModelTypeSet::Iterator iter = types.First(); iter.Good();
          iter.Inc()) {
       syncer::TestUserShare::CreateRoot(iter.Get(),
                                         test_user_share_.user_share());
     }
     test_user_share_.encryption_handler()->Init();
+    scoped_refptr<syncer::AttachmentStore> attachment_store(
+        new syncer::FakeAttachmentStore(base::MessageLoopProxy::current()));
+
     scoped_ptr<MockAttachmentService> mock_attachment_service(
-        new MockAttachmentService);
+        new MockAttachmentService(attachment_store));
     // GenericChangeProcessor takes ownership of the AttachmentService, but we
     // need to have a pointer to it so we can see that it was used properly.
     // Take a pointer and trust that GenericChangeProcessor does not prematurely
     // destroy it.
     mock_attachment_service_ = mock_attachment_service.get();
     sync_factory_.reset(new MockSyncApiComponentFactory(
         mock_attachment_service.PassAs<syncer::AttachmentService>()));
     change_processor_.reset(
         new GenericChangeProcessor(&data_type_error_handler_,
                                    syncable_service_ptr_factory_.GetWeakPtr(),
                                    merge_result_ptr_factory_.GetWeakPtr(),
                                    test_user_share_.user_share(),
-                                   sync_factory_.get()));
+                                   sync_factory_.get(),
+                                   attachment_store));
   }
 
   virtual void TearDown() OVERRIDE {
     mock_attachment_service_ = NULL;
     test_user_share_.TearDown();
   }
 
   void BuildChildNodes(int n) {
     syncer::WriteTransaction trans(FROM_HERE, user_share());
     syncer::ReadNode root(&trans);
@@ skipping 268 matching lines @@
   syncer::ReadNode node(&read_transaction);
   ASSERT_EQ(node.InitByClientTagLookup(syncer::PREFERENCES, tag),
             syncer::BaseNode::INIT_OK);
   syncer::AttachmentIdList attachment_ids = node.GetAttachmentIds();
   EXPECT_EQ(1U, attachment_ids.size());
 }
 
 }  // namespace
 
 }  // namespace sync_driver