Revert of [Sync] Refactor AttachmentStore classes. Introduce concept of referrer.

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(
+      const scoped_refptr<syncer::AttachmentStore>& attachment_store);
   ~MockAttachmentService() override;
   void UploadAttachments(
       const syncer::AttachmentIdSet& attachment_ids) override;
   std::vector<syncer::AttachmentIdSet>* attachment_id_sets();
 
  private:
   std::vector<syncer::AttachmentIdSet> attachment_id_sets_;
 };
 
 MockAttachmentService::MockAttachmentService(
-    scoped_ptr<syncer::AttachmentStore> attachment_store)
-    : AttachmentServiceImpl(attachment_store.Pass(),
+    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,
                             base::TimeDelta(),
                             base::TimeDelta()) {
 }
 
 MockAttachmentService::~MockAttachmentService() {
 }
 
 void MockAttachmentService::UploadAttachments(
     const syncer::AttachmentIdSet& attachment_ids) {
   attachment_id_sets_.push_back(attachment_ids);
   AttachmentServiceImpl::UploadAttachments(attachment_ids);
 }
 
 std::vector<syncer::AttachmentIdSet>*
 MockAttachmentService::attachment_id_sets() {
   return &attachment_id_sets_;
 }
 
 // MockSyncApiComponentFactory needed to initialize GenericChangeProcessor and
 // pass MockAttachmentService to it.
 class MockSyncApiComponentFactory : public SyncApiComponentFactory {
  public:
-  MockSyncApiComponentFactory() {}
+  MockSyncApiComponentFactory(
+      scoped_ptr<syncer::AttachmentService> attachment_service)
+      : attachment_service_(attachment_service.Pass()) {}
 
   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,
+      const scoped_refptr<syncer::AttachmentStore>& 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.
-    mock_attachment_service_ = attachment_service.get();
-    return attachment_service.Pass();
-  }
-
-  MockAttachmentService* GetMockAttachmentService() {
-    return mock_attachment_service_;
+    EXPECT_TRUE(attachment_service_ != NULL);
+    return attachment_service_.Pass();
   }
 
  private:
-  MockAttachmentService* mock_attachment_service_;
+  scoped_ptr<syncer::AttachmentService> attachment_service_;
 };
 
 class SyncGenericChangeProcessorTest : public testing::Test {
  public:
   // Most test cases will use this type.  For those that need a
   // GenericChangeProcessor for a different type, use |InitializeForType|.
   static const syncer::ModelType kType = syncer::PREFERENCES;
 
   SyncGenericChangeProcessorTest()
       : syncable_service_ptr_factory_(&fake_syncable_service_),
@@ skipping 28 matching lines @@
     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();
     ConstructGenericChangeProcessor(type);
   }
 
   void ConstructGenericChangeProcessor(syncer::ModelType type) {
-    MockSyncApiComponentFactory sync_factory;
-    scoped_ptr<syncer::AttachmentStore> attachment_store =
+    scoped_refptr<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()));
-    mock_attachment_service_ = sync_factory.GetMockAttachmentService();
+    scoped_ptr<MockAttachmentService> mock_attachment_service(
+        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.Pass()));
+    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_.get(),
+                                   attachment_store));
   }
 
   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 23 matching lines @@
   scoped_ptr<base::WeakPtrFactory<syncer::SyncMergeResult> >
       merge_result_ptr_factory_;
 
   syncer::FakeSyncableService fake_syncable_service_;
   base::WeakPtrFactory<syncer::FakeSyncableService>
       syncable_service_ptr_factory_;
 
   DataTypeErrorHandlerMock data_type_error_handler_;
   scoped_ptr<syncer::TestUserShare> test_user_share_;
   MockAttachmentService* mock_attachment_service_;
+  scoped_ptr<SyncApiComponentFactory> sync_factory_;
 
   scoped_ptr<GenericChangeProcessor> change_processor_;
 };
 
 // Similar to above, but focused on the method that implements sync/api
 // interfaces and is hence exposed to datatypes directly.
 TEST_F(SyncGenericChangeProcessorTest, StressGetAllSyncData) {
   const int kNumChildNodes = 1000;
   const int kRepeatCount = 1;
 
@@ skipping 253 matching lines @@
   // AttachmentService to upload id1 only.
   ConstructGenericChangeProcessor(kType);
   ASSERT_EQ(1U, mock_attachment_service()->attachment_id_sets()->size());
   ASSERT_THAT(mock_attachment_service()->attachment_id_sets()->front(),
               testing::UnorderedElementsAre(id1));
 }
 
 }  // namespace
 
 }  // namespace sync_driver