[Sync] Introduce AttachmentStoreForSync class

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 21 matching lines @@
   ~MockAttachmentStoreBackend() override {}
 
   void Init(const AttachmentStore::InitCallback& callback) override {}
 
   void Read(const AttachmentIdList& ids,
             const AttachmentStore::ReadCallback& callback) override {
     read_ids.push_back(ids);
     read_callbacks.push_back(callback);
   }
 
-  void Write(AttachmentStore::AttachmentReferrer referrer,
+  void Write(AttachmentStore::Component component,
              const AttachmentList& attachments,
              const AttachmentStore::WriteCallback& callback) override {
     write_attachments.push_back(attachments);
     write_callbacks.push_back(callback);
   }
 
-  void Drop(AttachmentStore::AttachmentReferrer referrer,
-            const AttachmentIdList& ids,
-            const AttachmentStore::DropCallback& callback) override {
-    NOTREACHED();
+  void SetReference(AttachmentStore::Component component,
+                    const AttachmentIdList& ids) override {
+    set_reference_ids.push_back(ids);
+  }
+
+  void DropReference(AttachmentStore::Component component,
+                     const AttachmentIdList& ids,
+                     const AttachmentStore::DropCallback& callback) override {
+    ASSERT_EQ(AttachmentStore::SYNC, component);
+    drop_ids.push_back(ids);
   }
 
   void ReadMetadata(
       const AttachmentIdList& ids,
       const AttachmentStore::ReadMetadataCallback& callback) override {
     NOTREACHED();
   }
 
   void ReadAllMetadata(
-      AttachmentStore::AttachmentReferrer referrer,
+      AttachmentStore::Component component,
       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();
     AttachmentStore::ReadCallback callback = read_callbacks.back();
     AttachmentIdList ids = read_ids.back();
@@ skipping 20 matching lines @@
         FROM_HERE,
         base::Bind(callback,
                    result,
                    base::Passed(&attachments),
                    base::Passed(&unavailable_attachments)));
   }
 
   // Respond to Write request with |result|.
   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<AttachmentStore::ReadCallback> read_callbacks;
   std::vector<AttachmentList> write_attachments;
   std::vector<AttachmentStore::WriteCallback> write_callbacks;
+  std::vector<AttachmentIdList> set_reference_ids;
+  std::vector<AttachmentIdList> drop_ids;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAttachmentStoreBackend);
 };
 
 class MockAttachmentDownloader
     : public AttachmentDownloader,
       public base::SupportsWeakPtr<MockAttachmentDownloader> {
  public:
   MockAttachmentDownloader() {}
@@ skipping 92 matching lines @@
         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.Pass(), uploader.Pass(), downloader.Pass(), delegate,
-        base::TimeDelta::FromMinutes(1), base::TimeDelta::FromMinutes(8)));
+        attachment_store->CreateAttachmentStoreForSync(), 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 189 matching lines @@
   EXPECT_TRUE(last_download_attachments().empty());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_Success) {
   AttachmentIdList attachment_ids;
   const unsigned num_attachments = 3;
   for (unsigned i = 0; i < num_attachments; ++i) {
     attachment_ids.push_back(AttachmentId::Create(0, 0));
   }
   attachment_service()->UploadAttachments(attachment_ids);
-
+  RunLoop();
+  EXPECT_FALSE(store()->set_reference_ids.empty());
   for (unsigned i = 0; i < num_attachments; ++i) {
     RunLoopAndFireTimer();
     // See that the service has issued a read for at least one of the
     // attachments.
     ASSERT_GE(store()->read_ids.size(), 1U);
     store()->RespondToRead(AttachmentIdSetFromList(attachment_ids));
     RunLoop();
     ASSERT_GE(uploader()->upload_requests.size(), 1U);
     uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                                 AttachmentUploader::UPLOAD_SUCCESS);
   }
   RunLoop();
   ASSERT_EQ(0U, store()->read_ids.size());
   ASSERT_EQ(0U, uploader()->upload_requests.size());
 
   // See that all the attachments were uploaded.
   ASSERT_EQ(attachment_ids.size(), on_attachment_uploaded_list().size());
   for (auto iter = attachment_ids.begin(); iter != attachment_ids.end();
        ++iter) {
     EXPECT_THAT(on_attachment_uploaded_list(), testing::Contains(*iter));
   }
+  EXPECT_EQ(num_attachments, store()->drop_ids.size());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_Success_NoDelegate) {
   InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
                               make_scoped_ptr(new MockAttachmentDownloader()),
                               NULL);  // No delegate.
 
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create(0, 0));
   attachment_service()->UploadAttachments(attachment_ids);
@@ skipping 26 matching lines @@
   uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                               AttachmentUploader::UPLOAD_SUCCESS);
   RunLoopAndFireTimer();
   ASSERT_EQ(1U, on_attachment_uploaded_list().size());
   ASSERT_GE(store()->read_ids.size(), 1U);
   // Not found!
   store()->RespondToRead(AttachmentIdSet());
   RunLoop();
   // No upload requests since the read failed.
   ASSERT_EQ(0U, uploader()->upload_requests.size());
+  EXPECT_EQ(attachment_ids.size(), store()->drop_ids.size());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_AllMissingFromStore) {
   AttachmentIdList attachment_ids;
   const unsigned num_attachments = 2;
   for (unsigned i = 0; i < num_attachments; ++i) {
     attachment_ids.push_back(AttachmentId::Create(0, 0));
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
   for (unsigned i = 0; i < num_attachments; ++i) {
     RunLoopAndFireTimer();
     ASSERT_GE(store()->read_ids.size(), 1U);
     // None found!
     store()->RespondToRead(AttachmentIdSet());
   }
   RunLoop();
 
   // Nothing uploaded.
   EXPECT_EQ(0U, uploader()->upload_requests.size());
   // See that the delegate was never called.
   ASSERT_EQ(0U, on_attachment_uploaded_list().size());
+  EXPECT_EQ(num_attachments, store()->drop_ids.size());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_NoUploader) {
   InitializeAttachmentService(make_scoped_ptr<MockAttachmentUploader>(NULL),
                               make_scoped_ptr(new MockAttachmentDownloader()),
                               this);
 
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create(0, 0));
   attachment_service()->UploadAttachments(attachment_ids);
   RunLoop();
   EXPECT_EQ(0U, store()->read_ids.size());
   ASSERT_EQ(0U, on_attachment_uploaded_list().size());
+  EXPECT_EQ(0U, store()->drop_ids.size());
 }
 
 // Upload three attachments.  For one of them, server responds with error.
 TEST_F(AttachmentServiceImplTest, UploadAttachments_OneUploadFails) {
   AttachmentIdList attachment_ids;
   const unsigned num_attachments = 3;
   for (unsigned i = 0; i < num_attachments; ++i) {
     attachment_ids.push_back(AttachmentId::Create(0, 0));
   }
   attachment_service()->UploadAttachments(attachment_ids);
@@ skipping 10 matching lines @@
     if (i == 2U) {
       result = AttachmentUploader::UPLOAD_UNSPECIFIED_ERROR;
     } else {
       result = AttachmentUploader::UPLOAD_SUCCESS;
     }
     uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                                 result);
     RunLoop();
   }
   ASSERT_EQ(2U, on_attachment_uploaded_list().size());
+  EXPECT_EQ(num_attachments, store()->drop_ids.size());
 }
 
 // Attempt an upload, respond with transient error to trigger backoff, issue
 // network disconnect/connect events and see that backoff is cleared.
 TEST_F(AttachmentServiceImplTest,
        UploadAttachments_ResetBackoffAfterNetworkChange) {
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create(0, 0));
   attachment_service()->UploadAttachments(attachment_ids);
 
@@ skipping 24 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