Convert //sync from scoped_ptr to std::unique_ptr

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 <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.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"
@@ skipping 56 matching lines @@
 
   // 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();
     read_callbacks.pop_back();
     read_ids.pop_back();
 
-    scoped_ptr<AttachmentMap> attachments(new AttachmentMap());
-    scoped_ptr<AttachmentIdList> unavailable_attachments(
+    std::unique_ptr<AttachmentMap> attachments(new AttachmentMap());
+    std::unique_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()) {
         Attachment attachment = Attachment::CreateFromParts(*iter, data);
         attachments->insert(std::make_pair(*iter, attachment));
       } else {
         unavailable_attachments->push_back(*iter);
       }
     }
@@ skipping 39 matching lines @@
   void DownloadAttachment(const AttachmentId& id,
                           const DownloadCallback& callback) override {
     ASSERT_TRUE(download_requests.find(id) == download_requests.end());
     download_requests.insert(std::make_pair(id, callback));
   }
 
   // Multiple requests to download will be active at the same time.
   // RespondToDownload should respond to only one of them.
   void RespondToDownload(const AttachmentId& id, const DownloadResult& result) {
     ASSERT_TRUE(download_requests.find(id) != download_requests.end());
-    scoped_ptr<Attachment> attachment;
+    std::unique_ptr<Attachment> attachment;
     if (result == DOWNLOAD_SUCCESS) {
       scoped_refptr<base::RefCountedString> data = new base::RefCountedString();
       attachment.reset(new Attachment(Attachment::CreateFromParts(id, data)));
     }
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(download_requests[id], result, base::Passed(&attachment)));
 
     download_requests.erase(id);
   }
@@ skipping 33 matching lines @@
 
 }  // namespace
 
 class AttachmentServiceImplTest : public testing::Test,
                                   public AttachmentService::Delegate {
  protected:
   AttachmentServiceImplTest() {}
 
   void SetUp() override {
     network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
-    InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
-                                make_scoped_ptr(new MockAttachmentDownloader()),
-                                this);
+    InitializeAttachmentService(
+        base::WrapUnique(new MockAttachmentUploader()),
+        base::WrapUnique(new MockAttachmentDownloader()), this);
   }
 
   void TearDown() override {
     attachment_service_.reset();
     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,
+      std::unique_ptr<MockAttachmentUploader> uploader,
+      std::unique_ptr<MockAttachmentDownloader> downloader,
       AttachmentService::Delegate* delegate) {
     // Initialize mock attachment store
     scoped_refptr<base::SingleThreadTaskRunner> runner =
         base::ThreadTaskRunnerHandle::Get();
-    scoped_ptr<MockAttachmentStoreBackend> attachment_store_backend(
+    std::unique_ptr<MockAttachmentStoreBackend> attachment_store_backend(
         new MockAttachmentStoreBackend(runner));
     attachment_store_backend_ = attachment_store_backend->AsWeakPtr();
-    scoped_ptr<AttachmentStore> attachment_store =
+    std::unique_ptr<AttachmentStore> attachment_store =
         AttachmentStore::CreateMockStoreForTest(
             std::move(attachment_store_backend));
 
     if (uploader.get()) {
       attachment_uploader_ = uploader->AsWeakPtr();
     }
     if (downloader.get()) {
       attachment_downloader_ = downloader->AsWeakPtr();
     }
     attachment_service_.reset(new AttachmentServiceImpl(
         attachment_store->CreateAttachmentStoreForSync(), std::move(uploader),
         std::move(downloader), delegate, base::TimeDelta::FromMinutes(1),
         base::TimeDelta::FromMinutes(8)));
 
-    scoped_ptr<base::MockTimer> timer_to_pass(
+    std::unique_ptr<base::MockTimer> timer_to_pass(
         new base::MockTimer(false, false));
     mock_timer_ = timer_to_pass.get();
     attachment_service_->SetTimerForTest(std::move(timer_to_pass));
   }
 
   AttachmentService* attachment_service() { return attachment_service_.get(); }
 
   base::MockTimer* mock_timer() { return mock_timer_; }
 
   AttachmentService::GetOrDownloadCallback download_callback() {
     return base::Bind(&AttachmentServiceImplTest::DownloadDone,
                       base::Unretained(this));
   }
 
   void DownloadDone(const AttachmentService::GetOrDownloadResult& result,
-                    scoped_ptr<AttachmentMap> attachments) {
+                    std::unique_ptr<AttachmentMap> attachments) {
     download_results_.push_back(result);
     last_download_attachments_ = std::move(attachments);
   }
 
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void RunLoopAndFireTimer() {
@@ skipping 36 matching lines @@
   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_;
+  std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   base::WeakPtr<MockAttachmentStoreBackend> attachment_store_backend_;
   base::WeakPtr<MockAttachmentDownloader> attachment_downloader_;
   base::WeakPtr<MockAttachmentUploader> attachment_uploader_;
-  scoped_ptr<AttachmentServiceImpl> attachment_service_;
+  std::unique_ptr<AttachmentServiceImpl> attachment_service_;
   base::MockTimer* mock_timer_;  // not owned
 
   std::vector<AttachmentService::GetOrDownloadResult> download_results_;
-  scoped_ptr<AttachmentMap> last_download_attachments_;
+  std::unique_ptr<AttachmentMap> last_download_attachments_;
   std::vector<AttachmentId> on_attachment_uploaded_list_;
 };
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_EmptyAttachmentList) {
   AttachmentIdList attachment_ids;
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
   RunLoop();
   store()->RespondToRead(AttachmentIdSet());
 
@@ skipping 82 matching lines @@
               last_download_attachments().end());
   EXPECT_TRUE(last_download_attachments().find(attachment_ids[2]) ==
               last_download_attachments().end());
   EXPECT_TRUE(last_download_attachments().find(attachment_ids[3]) ==
               last_download_attachments().end());
 }
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_NoDownloader) {
   // No downloader.
   InitializeAttachmentService(
-      make_scoped_ptr<MockAttachmentUploader>(new MockAttachmentUploader()),
-      make_scoped_ptr<MockAttachmentDownloader>(NULL),
-      this);
+      base::WrapUnique<MockAttachmentUploader>(new MockAttachmentUploader()),
+      base::WrapUnique<MockAttachmentDownloader>(NULL), this);
 
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create(0, 0));
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
   RunLoop();
   EXPECT_FALSE(store()->read_ids.empty());
 
   AttachmentIdSet local_attachments;
   store()->RespondToRead(local_attachments);
@@ skipping 31 matching lines @@
   // 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()),
+  InitializeAttachmentService(base::WrapUnique(new MockAttachmentUploader()),
+                              base::WrapUnique(new MockAttachmentDownloader()),
                               NULL);  // No delegate.
 
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(AttachmentId::Create(0, 0));
   attachment_service()->UploadAttachments(attachment_ids);
   RunLoopAndFireTimer();
   ASSERT_EQ(1U, store()->read_ids.size());
   ASSERT_EQ(0U, uploader()->upload_requests.size());
   store()->RespondToRead(AttachmentIdSetFromList(attachment_ids));
   RunLoop();
@@ skipping 48 matching lines @@
   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()),
+  InitializeAttachmentService(base::WrapUnique<MockAttachmentUploader>(NULL),
+                              base::WrapUnique(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());
 }
@@ skipping 64 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