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

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"
+#include "base/thread_task_runner_handle.h"
 #include "base/timer/mock_timer.h"
+#include "sync/api/attachments/attachment_store_backend.h"
 #include "sync/internal_api/public/attachments/attachment_util.h"
 #include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
 #include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
-class MockAttachmentStore : public AttachmentStore,
-                            public base::SupportsWeakPtr<MockAttachmentStore> {
+class MockAttachmentStoreBackend
+    : public AttachmentStoreBackend,
+      public base::SupportsWeakPtr<MockAttachmentStoreBackend> {
  public:
-  MockAttachmentStore() {}
+  MockAttachmentStoreBackend(
+      const scoped_refptr<base::SequencedTaskRunner>& callback_task_runner)
+      : AttachmentStoreBackend(callback_task_runner) {}
 
-  void Init(const InitCallback& callback) override {
-  }
+  ~MockAttachmentStoreBackend() override {}
+
+  void Init(const AttachmentStore::InitCallback& callback) override {}
 
   void Read(const AttachmentIdList& ids,
-            const ReadCallback& callback) override {
+            const AttachmentStore::ReadCallback& callback) override {
     read_ids.push_back(ids);
     read_callbacks.push_back(callback);
   }
 
-  void Write(const AttachmentList& attachments,
-             const WriteCallback& callback) override {
+  void Write(AttachmentStore::AttachmentReferrer referrer,
+             const AttachmentList& attachments,
+             const AttachmentStore::WriteCallback& callback) override {
     write_attachments.push_back(attachments);
     write_callbacks.push_back(callback);
   }
 
-  void Drop(const AttachmentIdList& ids,
-            const DropCallback& callback) override {
+  void Drop(AttachmentStore::AttachmentReferrer referrer,
+            const AttachmentIdList& ids,
+            const AttachmentStore::DropCallback& callback) override {
     NOTREACHED();
   }
 
-  void ReadMetadata(const AttachmentIdList& ids,
-                    const ReadMetadataCallback& callback) override {
+  void ReadMetadata(
+      const AttachmentIdList& ids,
+      const AttachmentStore::ReadMetadataCallback& callback) override {
     NOTREACHED();
   }
 
-  void ReadAllMetadata(const ReadMetadataCallback& callback) override {
+  void ReadAllMetadata(
+      AttachmentStore::AttachmentReferrer referrer,
+      const AttachmentStore::ReadMetadataCallback& callback) override {
     NOTREACHED();
   }
 
   // Respond to Read request. Attachments found in local_attachments should be
   // returned, everything else should be reported unavailable.
   void RespondToRead(const AttachmentIdSet& local_attachments) {
     scoped_refptr<base::RefCountedString> data = new base::RefCountedString();
-    ReadCallback callback = read_callbacks.back();
+    AttachmentStore::ReadCallback callback = read_callbacks.back();
     AttachmentIdList ids = read_ids.back();
     read_callbacks.pop_back();
     read_ids.pop_back();
 
     scoped_ptr<AttachmentMap> attachments(new AttachmentMap());
     scoped_ptr<AttachmentIdList> unavailable_attachments(
         new AttachmentIdList());
     for (AttachmentIdList::const_iterator iter = ids.begin(); iter != ids.end();
          ++iter) {
       if (local_attachments.find(*iter) != local_attachments.end()) {
         uint32_t crc32c = ComputeCrc32c(data);
         Attachment attachment =
             Attachment::CreateFromParts(*iter, data, crc32c);
         attachments->insert(std::make_pair(*iter, attachment));
       } else {
         unavailable_attachments->push_back(*iter);
       }
     }
-    Result result =
-        unavailable_attachments->empty() ? SUCCESS : UNSPECIFIED_ERROR;
+    AttachmentStore::Result result = unavailable_attachments->empty()
+                                         ? AttachmentStore::SUCCESS
+                                         : AttachmentStore::UNSPECIFIED_ERROR;
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    result,
                    base::Passed(&attachments),
                    base::Passed(&unavailable_attachments)));
   }
 
   // Respond to Write request with |result|.
-  void RespondToWrite(const Result& result) {
-    WriteCallback callback = write_callbacks.back();
+  void RespondToWrite(const AttachmentStore::Result& result) {
+    AttachmentStore::WriteCallback callback = write_callbacks.back();
     AttachmentList attachments = write_attachments.back();
     write_callbacks.pop_back();
     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<AttachmentStore::ReadCallback> read_callbacks;
   std::vector<AttachmentList> write_attachments;
-  std::vector<WriteCallback> write_callbacks;
+  std::vector<AttachmentStore::WriteCallback> write_callbacks;
 
  private:
-  ~MockAttachmentStore() override {}
-
-  DISALLOW_COPY_AND_ASSIGN(MockAttachmentStore);
+  DISALLOW_COPY_AND_ASSIGN(MockAttachmentStoreBackend);
 };
 
 class MockAttachmentDownloader
     : public AttachmentDownloader,
       public base::SupportsWeakPtr<MockAttachmentDownloader> {
  public:
   MockAttachmentDownloader() {}
 
   void DownloadAttachment(const AttachmentId& id,
                           const DownloadCallback& callback) override {
@@ skipping 59 matching lines @@
 
   void SetUp() override {
     network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
     InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
                                 make_scoped_ptr(new MockAttachmentDownloader()),
                                 this);
   }
 
   void TearDown() override {
     attachment_service_.reset();
-    ASSERT_FALSE(attachment_store_);
+    RunLoop();
+    ASSERT_FALSE(attachment_store_backend_);
     ASSERT_FALSE(attachment_uploader_);
     ASSERT_FALSE(attachment_downloader_);
   }
 
   // AttachmentService::Delegate implementation.
   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_refptr<MockAttachmentStore> attachment_store(
-        new MockAttachmentStore());
-    attachment_store_ = attachment_store->AsWeakPtr();
+    // Initialize mock attachment store
+    scoped_refptr<base::SingleThreadTaskRunner> runner =
+        base::ThreadTaskRunnerHandle::Get();
+    scoped_ptr<MockAttachmentStoreBackend> attachment_store_backend(
+        new MockAttachmentStoreBackend(runner));
+    attachment_store_backend_ = attachment_store_backend->AsWeakPtr();
+    scoped_ptr<AttachmentStore> attachment_store =
+        AttachmentStore::CreateMockStoreForTest(
+            attachment_store_backend.Pass());
 
     if (uploader.get()) {
       attachment_uploader_ = uploader->AsWeakPtr();
     }
     if (downloader.get()) {
       attachment_downloader_ = downloader->AsWeakPtr();
     }
-    attachment_service_.reset(
-        new AttachmentServiceImpl(attachment_store,
-                                  uploader.Pass(),
-                                  downloader.Pass(),
-                                  delegate,
-                                  base::TimeDelta::FromMinutes(1),
-                                  base::TimeDelta::FromMinutes(8)));
+    attachment_service_.reset(new AttachmentServiceImpl(
+        attachment_store.Pass(), uploader.Pass(), downloader.Pass(), delegate,
+        base::TimeDelta::FromMinutes(1), base::TimeDelta::FromMinutes(8)));
 
     scoped_ptr<base::MockTimer> timer_to_pass(
         new base::MockTimer(false, false));
     mock_timer_ = timer_to_pass.get();
     attachment_service_->SetTimerForTest(timer_to_pass.Pass());
   }
 
   AttachmentService* attachment_service() { return attachment_service_.get(); }
 
   base::MockTimer* mock_timer() { return mock_timer_; }
@@ skipping 11 matching lines @@
 
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void RunLoopAndFireTimer() {
     RunLoop();
     if (mock_timer()->IsRunning()) {
       mock_timer()->Fire();
+      RunLoop();
     }
-    RunLoop();
   }
 
   const std::vector<AttachmentService::GetOrDownloadResult>&
   download_results() const {
     return download_results_;
   }
 
   const AttachmentMap& last_download_attachments() const {
     return *last_download_attachments_.get();
   }
 
   net::NetworkChangeNotifier* network_change_notifier() {
     return network_change_notifier_.get();
   }
 
-  MockAttachmentStore* store() { return attachment_store_.get(); }
+  MockAttachmentStoreBackend* store() {
+    return attachment_store_backend_.get();
+  }
 
   MockAttachmentDownloader* downloader() {
     return attachment_downloader_.get();
   }
 
   MockAttachmentUploader* uploader() {
     return attachment_uploader_.get();
   }
 
   const std::vector<AttachmentId>& on_attachment_uploaded_list() const {
     return on_attachment_uploaded_list_;
   }
 
  private:
   base::MessageLoop message_loop_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
-  base::WeakPtr<MockAttachmentStore> attachment_store_;
+  base::WeakPtr<MockAttachmentStoreBackend> attachment_store_backend_;
   base::WeakPtr<MockAttachmentDownloader> attachment_downloader_;
   base::WeakPtr<MockAttachmentUploader> attachment_uploader_;
   scoped_ptr<AttachmentServiceImpl> attachment_service_;
   base::MockTimer* mock_timer_;  // not owned
 
   std::vector<AttachmentService::GetOrDownloadResult> download_results_;
   scoped_ptr<AttachmentMap> last_download_attachments_;
   std::vector<AttachmentId> on_attachment_uploaded_list_;
 };
 
-TEST_F(AttachmentServiceImplTest, GetStore) {
-  EXPECT_EQ(store(), attachment_service()->GetStore());
-}
-
 TEST_F(AttachmentServiceImplTest, GetOrDownload_EmptyAttachmentList) {
   AttachmentIdList attachment_ids;
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
+  RunLoop();
   store()->RespondToRead(AttachmentIdSet());
 
   RunLoop();
   EXPECT_EQ(1U, download_results().size());
   EXPECT_EQ(0U, last_download_attachments().size());
 }
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_Local) {
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create());
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
   AttachmentIdSet local_attachments;
   local_attachments.insert(attachment_ids[0]);
+  RunLoop();
   store()->RespondToRead(local_attachments);
 
   RunLoop();
   EXPECT_EQ(1U, download_results().size());
   EXPECT_EQ(1U, last_download_attachments().size());
   EXPECT_TRUE(last_download_attachments().find(attachment_ids[0]) !=
               last_download_attachments().end());
 }
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_LocalRemoteUnavailable) {
   // Create attachment list with 4 ids.
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create());
   attachment_ids.push_back(AttachmentId::Create());
   attachment_ids.push_back(AttachmentId::Create());
   attachment_ids.push_back(AttachmentId::Create());
   // Call attachment service.
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
+  RunLoop();
   // Ensure AttachmentStore is called.
   EXPECT_FALSE(store()->read_ids.empty());
 
   // Make AttachmentStore return only attachment 0.
   AttachmentIdSet local_attachments;
   local_attachments.insert(attachment_ids[0]);
   store()->RespondToRead(local_attachments);
   RunLoop();
   // Ensure Downloader called with right attachment ids
   EXPECT_EQ(3U, downloader()->download_requests.size());
@@ skipping 45 matching lines @@
   // No downloader.
   InitializeAttachmentService(
       make_scoped_ptr<MockAttachmentUploader>(new MockAttachmentUploader()),
       make_scoped_ptr<MockAttachmentDownloader>(NULL),
       this);
 
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create());
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
+  RunLoop();
   EXPECT_FALSE(store()->read_ids.empty());
 
   AttachmentIdSet local_attachments;
   store()->RespondToRead(local_attachments);
   RunLoop();
   ASSERT_EQ(1U, download_results().size());
   EXPECT_EQ(AttachmentService::GET_UNSPECIFIED_ERROR, download_results()[0]);
   EXPECT_TRUE(last_download_attachments().empty());
 }
 
@@ skipping 175 matching lines @@
   net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   RunLoop();
 
   // No longer in backoff.
   ASSERT_TRUE(mock_timer()->IsRunning());
   ASSERT_EQ(base::TimeDelta(), mock_timer()->GetCurrentDelay());
 }
 
 }  // namespace syncer