[Sync] Introduce AttachmentStoreForSync class

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/run_loop.h"
@@ skipping 19 matching lines @@
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_driver {
 
 namespace {
 
 // A mock that keeps track of attachments passed to UploadAttachments.
 class MockAttachmentService : public syncer::AttachmentServiceImpl {
  public:
-  MockAttachmentService(scoped_ptr<syncer::AttachmentStore> attachment_store);
+  MockAttachmentService(
+      scoped_ptr<syncer::AttachmentStoreForSync> attachment_store);
   ~MockAttachmentService() override;
   void UploadAttachments(
       const syncer::AttachmentIdList& attachment_ids) override;
   std::vector<syncer::AttachmentIdList>* attachment_id_lists();
 
  private:
   std::vector<syncer::AttachmentIdList> attachment_id_lists_;
 };
 
 MockAttachmentService::MockAttachmentService(
-    scoped_ptr<syncer::AttachmentStore> attachment_store)
+    scoped_ptr<syncer::AttachmentStoreForSync> attachment_store)
     : AttachmentServiceImpl(attachment_store.Pass(),
                             scoped_ptr<syncer::AttachmentUploader>(
                                 new syncer::FakeAttachmentUploader),
                             scoped_ptr<syncer::AttachmentDownloader>(
                                 new syncer::FakeAttachmentDownloader),
                             NULL,
                             base::TimeDelta(),
                             base::TimeDelta()) {
 }
 
@@ skipping 18 matching lines @@
   MockSyncApiComponentFactory() {}
 
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) override {
     // Shouldn't be called for this test.
     NOTREACHED();
     return base::WeakPtr<syncer::SyncableService>();
   }
 
   scoped_ptr<syncer::AttachmentService> CreateAttachmentService(
-      scoped_ptr<syncer::AttachmentStore> attachment_store,
+      scoped_ptr<syncer::AttachmentStoreForSync> attachment_store,
       const syncer::UserShare& user_share,
       const std::string& store_birthday,
       syncer::ModelType model_type,
       syncer::AttachmentService::Delegate* delegate) override {
     scoped_ptr<MockAttachmentService> attachment_service(
         new MockAttachmentService(attachment_store.Pass()));
     // 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.
@@ skipping 55 matching lines @@
   }
 
   void ConstructGenericChangeProcessor(syncer::ModelType type) {
     MockSyncApiComponentFactory sync_factory;
     scoped_ptr<syncer::AttachmentStore> attachment_store =
         syncer::AttachmentStore::CreateInMemoryStore();
     change_processor_.reset(new GenericChangeProcessor(
         type, &data_type_error_handler_,
         syncable_service_ptr_factory_.GetWeakPtr(),
         merge_result_ptr_factory_->GetWeakPtr(), test_user_share_->user_share(),
-        &sync_factory, attachment_store.Pass()));
+        &sync_factory, attachment_store->CreateAttachmentStoreForSync()));
     mock_attachment_service_ = sync_factory.GetMockAttachmentService();
   }
 
   void BuildChildNodes(syncer::ModelType type, int n) {
     syncer::WriteTransaction trans(FROM_HERE, user_share());
     syncer::ReadNode root(&trans);
     ASSERT_EQ(syncer::BaseNode::INIT_OK, root.InitTypeRoot(type));
     for (int i = 0; i < n; ++i) {
       syncer::WriteNode node(&trans);
       node.InitUniqueByCreation(type, root, base::StringPrintf("node%05d", i));
@@ skipping 297 matching lines @@
   // AttachmentService to upload id1 only.
   ConstructGenericChangeProcessor(kType);
   ASSERT_EQ(1U, mock_attachment_service()->attachment_id_lists()->size());
   ASSERT_THAT(mock_attachment_service()->attachment_id_lists()->front(),
               testing::UnorderedElementsAre(id1));
 }
 
 }  // namespace
 
 }  // namespace sync_driver