Convert //components/dom_distiller from scoped_ptr to std::unique_ptr

components/dom_distiller/core/dom_distiller_store_unittest.cc

 // Copyright 2013 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/dom_distiller/core/dom_distiller_store.h"
 
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "components/dom_distiller/core/article_entry.h"
 #include "components/dom_distiller/core/dom_distiller_test_util.h"
 #include "components/leveldb_proto/testing/fake_db.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 124 matching lines @@
   void CreateStore() {
     fake_db_ = new FakeDB<ArticleEntry>(&db_model_);
     store_.reset(test::util::CreateStoreWithFakeDB(fake_db_, store_model_));
   }
 
   void StartSyncing() {
     fake_sync_processor_ = new FakeSyncChangeProcessor(&sync_model_);
 
     store_->MergeDataAndStartSyncing(
         kDomDistillerModelType, SyncDataFromEntryMap(sync_model_),
-        make_scoped_ptr<SyncChangeProcessor>(fake_sync_processor_),
-        scoped_ptr<SyncErrorFactory>(new FakeSyncErrorFactory()));
+        base::WrapUnique<SyncChangeProcessor>(fake_sync_processor_),
+        std::unique_ptr<SyncErrorFactory>(new FakeSyncErrorFactory()));
   }
 
  protected:
   SyncData CreateSyncData(const ArticleEntry& entry) {
     EntitySpecifics specifics = SpecificsFromEntry(entry);
     return SyncData::CreateRemoteData(
         next_sync_id_++, specifics, Time::UnixEpoch(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create());
   }
 
   SyncDataList SyncDataFromEntryMap(const EntryMap& model) {
     SyncDataList data;
     for (EntryMap::const_iterator it = model.begin(); it != model.end(); ++it) {
       data.push_back(CreateSyncData(it->second));
     }
     return data;
   }
 
   base::MessageLoop message_loop_;
 
   EntryMap db_model_;
   EntryMap sync_model_;
   FakeDB<ArticleEntry>::EntryMap store_model_;
 
-  scoped_ptr<DomDistillerStore> store_;
+  std::unique_ptr<DomDistillerStore> store_;
 
   // Both owned by |store_|.
   FakeDB<ArticleEntry>* fake_db_;
   FakeSyncChangeProcessor* fake_sync_processor_;
 
   int64_t next_sync_id_;
 };
 
 AssertionResult AreEntriesEqual(const DomDistillerStore::EntryVector& entries,
                                 EntryMap expected_entries) {
@@ skipping 114 matching lines @@
   store_->RemoveEntry(updated_entry);
   EXPECT_FALSE(store_->UpdateEntry(updated_entry));
   EXPECT_FALSE(store_->UpdateEntry(GetSampleEntry(0)));
 }
 
 class MockAttachmentsCallbacks {
  public:
   MOCK_METHOD2(Get, void(bool, ArticleAttachmentsData*));
   MOCK_METHOD1(Update, void(bool));
 
-  void GetImpl(bool success, scoped_ptr<ArticleAttachmentsData> attachments) {
+  void GetImpl(bool success,
+               std::unique_ptr<ArticleAttachmentsData> attachments) {
     Get(success, attachments.get());
   }
 
   DomDistillerStore::UpdateAttachmentsCallback UpdateCallback() {
     return base::Bind(&MockAttachmentsCallbacks::Update,
                       base::Unretained(this));
   }
 
   DomDistillerStore::GetAttachmentsCallback GetCallback() {
     return base::Bind(&MockAttachmentsCallbacks::GetImpl,
@@ skipping 14 matching lines @@
   store_->GetAttachments(entry.entry_id(), callbacks.GetCallback());
   EXPECT_CALL(callbacks, Get(false, _));
   base::RunLoop().RunUntilIdle();
 
   ArticleAttachmentsData attachments, got_attachments;
   DistilledArticleProto article_proto;
   article_proto.set_title("A title");
   attachments.set_distilled_article(article_proto);
   store_->UpdateAttachments(
       entry.entry_id(),
-      make_scoped_ptr(new ArticleAttachmentsData(attachments)),
+      base::WrapUnique(new ArticleAttachmentsData(attachments)),
       callbacks.UpdateCallback());
   EXPECT_CALL(callbacks, Update(true));
   base::RunLoop().RunUntilIdle();
 
   store_->GetAttachments(entry.entry_id(), callbacks.GetCallback());
   EXPECT_CALL(callbacks, Get(true, _))
       .WillOnce(SaveArgPointee<1>(&got_attachments));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(attachments.ToString(),
@@ skipping 137 matching lines @@
   AddEntry(GetSampleEntry(3), &expected_model);
   AddEntry(GetSampleEntry(4), &expected_model);
 
   CreateStore();
 
   fake_db_->InitCallback(true);
   fake_db_->LoadCallback(true);
 
   FakeDB<ArticleEntry>* other_fake_db =
       new FakeDB<ArticleEntry>(&other_db_model);
-  scoped_ptr<DomDistillerStore> owned_other_store(new DomDistillerStore(
-      scoped_ptr<leveldb_proto::ProtoDatabase<ArticleEntry> >(other_fake_db),
+  std::unique_ptr<DomDistillerStore> owned_other_store(new DomDistillerStore(
+      std::unique_ptr<leveldb_proto::ProtoDatabase<ArticleEntry>>(
+          other_fake_db),
       std::vector<ArticleEntry>(),
       base::FilePath(FILE_PATH_LITERAL("/fake/other/path"))));
   DomDistillerStore* other_store = owned_other_store.get();
   other_fake_db->InitCallback(true);
   other_fake_db->LoadCallback(true);
 
   EXPECT_FALSE(AreEntriesEqual(store_->GetEntries(), expected_model));
   EXPECT_FALSE(AreEntriesEqual(other_store->GetEntries(), expected_model));
   ASSERT_TRUE(AreEntriesEqual(other_store->GetEntries(), other_db_model));
 
   FakeSyncErrorFactory* other_error_factory = new FakeSyncErrorFactory();
   store_->MergeDataAndStartSyncing(
       kDomDistillerModelType, SyncDataFromEntryMap(other_db_model),
       std::move(owned_other_store),
-      make_scoped_ptr<SyncErrorFactory>(other_error_factory));
+      base::WrapUnique<SyncErrorFactory>(other_error_factory));
 
   EXPECT_TRUE(AreEntriesEqual(store_->GetEntries(), expected_model));
   EXPECT_TRUE(AreEntriesEqual(other_store->GetEntries(), expected_model));
 }
 
 TEST_F(DomDistillerStoreTest, TestObserver) {
   CreateStore();
   MockDistillerObserver observer;
   store_->AddObserver(&observer);
   fake_db_->InitCallback(true);
@@ skipping 39 matching lines @@
   expected_updates.push_back(update);
   EXPECT_CALL(observer, ArticleEntriesUpdated(
                             test::util::HasExpectedUpdates(expected_updates)));
 
   FakeSyncErrorFactory* fake_error_factory = new FakeSyncErrorFactory();
   EntryMap fake_model;
   FakeSyncChangeProcessor* fake_sync_change_processor =
       new FakeSyncChangeProcessor(&fake_model);
   store_->MergeDataAndStartSyncing(
       kDomDistillerModelType, change_data,
-      make_scoped_ptr<SyncChangeProcessor>(fake_sync_change_processor),
-      make_scoped_ptr<SyncErrorFactory>(fake_error_factory));
+      base::WrapUnique<SyncChangeProcessor>(fake_sync_change_processor),
+      base::WrapUnique<SyncErrorFactory>(fake_error_factory));
 }
 
 }  // namespace dom_distiller