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

components/dom_distiller/core/dom_distiller_service_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_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 42 matching lines @@
   MOCK_METHOD1(DistillationCompleted, void(bool));
 };
 
 DomDistillerService::ArticleAvailableCallback ArticleCallback(
     MockArticleAvailableCallback* callback) {
   return base::Bind(&MockArticleAvailableCallback::DistillationCompleted,
                     base::Unretained(callback));
 }
 
 void RunDistillerCallback(FakeDistiller* distiller,
-                          scoped_ptr<DistilledArticleProto> proto) {
+                          std::unique_ptr<DistilledArticleProto> proto) {
   distiller->RunDistillerCallback(std::move(proto));
   base::RunLoop().RunUntilIdle();
 }
 
-scoped_ptr<DistilledArticleProto> CreateArticleWithURL(const std::string& url) {
-  scoped_ptr<DistilledArticleProto> proto(new DistilledArticleProto);
+std::unique_ptr<DistilledArticleProto> CreateArticleWithURL(
+    const std::string& url) {
+  std::unique_ptr<DistilledArticleProto> proto(new DistilledArticleProto);
   DistilledPageProto* page = proto->add_pages();
   page->set_url(url);
   return proto;
 }
 
-scoped_ptr<DistilledArticleProto> CreateDefaultArticle() {
+std::unique_ptr<DistilledArticleProto> CreateDefaultArticle() {
   return CreateArticleWithURL("http://www.example.com/default_article_page1");
 }
 
 }  // namespace
 
 class DomDistillerServiceTest : public testing::Test {
  public:
   void SetUp() override {
     main_loop_.reset(new base::MessageLoop());
     FakeDB<ArticleEntry>* fake_db = new FakeDB<ArticleEntry>(&db_model_);
     FakeDB<ArticleEntry>::EntryMap store_model;
     store_ =
         test::util::CreateStoreWithFakeDB(fake_db, store_model);
     distiller_factory_ = new MockDistillerFactory();
     distiller_page_factory_ = new MockDistillerPageFactory();
     service_.reset(new DomDistillerService(
-        scoped_ptr<DomDistillerStoreInterface>(store_),
-        scoped_ptr<DistillerFactory>(distiller_factory_),
-        scoped_ptr<DistillerPageFactory>(distiller_page_factory_),
-        scoped_ptr<DistilledPagePrefs>()));
+        std::unique_ptr<DomDistillerStoreInterface>(store_),
+        std::unique_ptr<DistillerFactory>(distiller_factory_),
+        std::unique_ptr<DistillerPageFactory>(distiller_page_factory_),
+        std::unique_ptr<DistilledPagePrefs>()));
     fake_db->InitCallback(true);
     fake_db->LoadCallback(true);
   }
 
   void TearDown() override {
     base::RunLoop().RunUntilIdle();
     store_ = NULL;
     distiller_factory_ = NULL;
     service_.reset();
   }
 
  protected:
   // store is owned by service_.
   DomDistillerStoreInterface* store_;
   MockDistillerFactory* distiller_factory_;
   MockDistillerPageFactory* distiller_page_factory_;
-  scoped_ptr<DomDistillerService> service_;
-  scoped_ptr<base::MessageLoop> main_loop_;
+  std::unique_ptr<DomDistillerService> service_;
+  std::unique_ptr<base::MessageLoop> main_loop_;
   FakeDB<ArticleEntry>::EntryMap db_model_;
 };
 
 TEST_F(DomDistillerServiceTest, TestViewEntry) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   GURL url("http://www.example.com/p1");
   std::string entry_id("id0");
   ArticleEntry entry;
   entry.set_entry_id(entry_id);
   entry.add_pages()->set_url(url.spec());
 
   store_->AddEntry(entry);
 
   FakeViewRequestDelegate viewer_delegate;
-  scoped_ptr<ViewerHandle> handle = service_->ViewEntry(
+  std::unique_ptr<ViewerHandle> handle = service_->ViewEntry(
       &viewer_delegate, service_->CreateDefaultDistillerPage(gfx::Size()),
       entry_id);
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
 
-  scoped_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
+  std::unique_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
   EXPECT_CALL(viewer_delegate, OnArticleReady(proto.get()));
 
   RunDistillerCallback(distiller, std::move(proto));
 }
 
 TEST_F(DomDistillerServiceTest, TestViewUrl) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   FakeViewRequestDelegate viewer_delegate;
   GURL url("http://www.example.com/p1");
-  scoped_ptr<ViewerHandle> handle = service_->ViewUrl(
+  std::unique_ptr<ViewerHandle> handle = service_->ViewUrl(
       &viewer_delegate, service_->CreateDefaultDistillerPage(gfx::Size()), url);
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
-  scoped_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
+  std::unique_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
   EXPECT_CALL(viewer_delegate, OnArticleReady(proto.get()));
 
   RunDistillerCallback(distiller, std::move(proto));
 }
 
 TEST_F(DomDistillerServiceTest, TestMultipleViewUrl) {
   FakeDistiller* distiller = new FakeDistiller(false);
   FakeDistiller* distiller2 = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller))
       .WillOnce(Return(distiller2));
 
   FakeViewRequestDelegate viewer_delegate;
   FakeViewRequestDelegate viewer_delegate2;
 
   GURL url("http://www.example.com/p1");
   GURL url2("http://www.example.com/a/p1");
 
-  scoped_ptr<ViewerHandle> handle = service_->ViewUrl(
+  std::unique_ptr<ViewerHandle> handle = service_->ViewUrl(
       &viewer_delegate, service_->CreateDefaultDistillerPage(gfx::Size()), url);
-  scoped_ptr<ViewerHandle> handle2 = service_->ViewUrl(
+  std::unique_ptr<ViewerHandle> handle2 = service_->ViewUrl(
       &viewer_delegate2, service_->CreateDefaultDistillerPage(gfx::Size()),
       url2);
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
-  scoped_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
+  std::unique_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
   EXPECT_CALL(viewer_delegate, OnArticleReady(proto.get()));
 
   RunDistillerCallback(distiller, std::move(proto));
 
   ASSERT_FALSE(distiller2->GetArticleCallback().is_null());
   EXPECT_EQ(url2, distiller2->GetUrl());
 
-  scoped_ptr<DistilledArticleProto> proto2 = CreateDefaultArticle();
+  std::unique_ptr<DistilledArticleProto> proto2 = CreateDefaultArticle();
   EXPECT_CALL(viewer_delegate2, OnArticleReady(proto2.get()));
 
   RunDistillerCallback(distiller2, std::move(proto2));
 }
 
 TEST_F(DomDistillerServiceTest, TestViewUrlCancelled) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   bool distiller_destroyed = false;
   EXPECT_CALL(*distiller, Die())
       .WillOnce(testing::Assign(&distiller_destroyed, true));
 
   FakeViewRequestDelegate viewer_delegate;
   GURL url("http://www.example.com/p1");
-  scoped_ptr<ViewerHandle> handle = service_->ViewUrl(
+  std::unique_ptr<ViewerHandle> handle = service_->ViewUrl(
       &viewer_delegate, service_->CreateDefaultDistillerPage(gfx::Size()), url);
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
   EXPECT_CALL(viewer_delegate, OnArticleReady(_)).Times(0);
 
   EXPECT_FALSE(distiller_destroyed);
 
   handle.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(distiller_destroyed);
 }
 
 TEST_F(DomDistillerServiceTest, TestViewUrlDoesNotAddEntry) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   FakeViewRequestDelegate viewer_delegate;
   GURL url("http://www.example.com/p1");
-  scoped_ptr<ViewerHandle> handle = service_->ViewUrl(
+  std::unique_ptr<ViewerHandle> handle = service_->ViewUrl(
       &viewer_delegate, service_->CreateDefaultDistillerPage(gfx::Size()), url);
 
-  scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
+  std::unique_ptr<DistilledArticleProto> proto =
+      CreateArticleWithURL(url.spec());
   EXPECT_CALL(viewer_delegate, OnArticleReady(proto.get()));
 
   RunDistillerCallback(distiller, std::move(proto));
   base::RunLoop().RunUntilIdle();
   // The entry should not be added to the store.
   EXPECT_EQ(0u, store_->GetEntries().size());
 }
 
 TEST_F(DomDistillerServiceTest, TestAddAndRemoveEntry) {
   FakeDistiller* distiller = new FakeDistiller(false);
   EXPECT_CALL(*distiller_factory_, CreateDistillerImpl())
       .WillOnce(Return(distiller));
 
   GURL url("http://www.example.com/p1");
 
   MockArticleAvailableCallback article_cb;
   EXPECT_CALL(article_cb, DistillationCompleted(true));
 
   std::string entry_id = service_->AddToList(
       url, service_->CreateDefaultDistillerPage(gfx::Size()),
       ArticleCallback(&article_cb));
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
-  scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
+  std::unique_ptr<DistilledArticleProto> proto =
+      CreateArticleWithURL(url.spec());
   RunDistillerCallback(distiller, std::move(proto));
 
   ArticleEntry entry;
   EXPECT_TRUE(store_->GetEntryByUrl(url, &entry));
   EXPECT_EQ(entry.entry_id(), entry_id);
   EXPECT_EQ(1u, store_->GetEntries().size());
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, store_->GetEntries().size());
 }
@@ skipping 40 matching lines @@
   DomDistillerObserver::ArticleUpdate update;
   update.entry_id = entry_id;
   update.update_type = DomDistillerObserver::ArticleUpdate::ADD;
   expected_updates.push_back(update);
 
   for (int i = 0; i < kObserverCount; ++i) {
     EXPECT_CALL(observers[i], ArticleEntriesUpdated(
                                   util::HasExpectedUpdates(expected_updates)));
   }
 
-  scoped_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
+  std::unique_ptr<DistilledArticleProto> proto = CreateDefaultArticle();
   RunDistillerCallback(distiller, std::move(proto));
 
   // Remove should notify all observers that article is removed.
   update.update_type = DomDistillerObserver::ArticleUpdate::REMOVE;
   expected_updates.clear();
   expected_updates.push_back(update);
   for (int i = 0; i < kObserverCount; ++i) {
     EXPECT_CALL(observers[i], ArticleEntriesUpdated(
                                   util::HasExpectedUpdates(expected_updates)));
   }
@@ skipping 17 matching lines @@
   EXPECT_CALL(article_cb[0], DistillationCompleted(true));
 
   for (int i = 1; i < kClientsCount; ++i) {
     EXPECT_EQ(entry_id,
               service_->AddToList(
                   url, service_->CreateDefaultDistillerPage(gfx::Size()),
                   ArticleCallback(&article_cb[i])));
     EXPECT_CALL(article_cb[i], DistillationCompleted(true));
   }
 
-  scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
+  std::unique_ptr<DistilledArticleProto> proto =
+      CreateArticleWithURL(url.spec());
   RunDistillerCallback(distiller, std::move(proto));
 
   // Add the same url again, all callbacks should be called with true.
   for (int i = 0; i < kClientsCount; ++i) {
     EXPECT_CALL(article_cb[i], DistillationCompleted(true));
     EXPECT_EQ(entry_id,
               service_->AddToList(
                   url, service_->CreateDefaultDistillerPage(gfx::Size()),
                   ArticleCallback(&article_cb[i])));
   }
@@ skipping 46 matching lines @@
 
   std::string entry_id = service_->AddToList(
       pages_url[0], service_->CreateDefaultDistillerPage(gfx::Size()),
       ArticleCallback(&article_cb));
 
   ArticleEntry entry;
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(pages_url[0], distiller->GetUrl());
 
   // Create the article with pages to pass to the distiller.
-  scoped_ptr<DistilledArticleProto> proto =
+  std::unique_ptr<DistilledArticleProto> proto =
       CreateArticleWithURL(pages_url[0].spec());
   for (int page_num = 1; page_num < kPageCount; ++page_num) {
     DistilledPageProto* distilled_page = proto->add_pages();
     distilled_page->set_url(pages_url[page_num].spec());
   }
 
   RunDistillerCallback(distiller, std::move(proto));
   EXPECT_TRUE(store_->GetEntryByUrl(pages_url[0], &entry));
 
   EXPECT_EQ(kPageCount, entry.pages_size());
@@ skipping 25 matching lines @@
   MockArticleAvailableCallback article_cb;
   EXPECT_CALL(article_cb, DistillationCompleted(true));
 
   std::string entry_id = service_->AddToList(
       url, service_->CreateDefaultDistillerPage(gfx::Size()),
       ArticleCallback(&article_cb));
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
-  scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
+  std::unique_ptr<DistilledArticleProto> proto =
+      CreateArticleWithURL(url.spec());
   RunDistillerCallback(distiller, std::move(proto));
 
   // Check that HasEntry returns true for the article just added.
   EXPECT_TRUE(service_->HasEntry(entry_id));
 
   // Remove article and check that there is no longer an entry for the given
   // entry id.
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, store_->GetEntries().size());
@@ skipping 10 matching lines @@
   MockArticleAvailableCallback article_cb;
   EXPECT_CALL(article_cb, DistillationCompleted(true));
 
   std::string entry_id = service_->AddToList(
       url, service_->CreateDefaultDistillerPage(gfx::Size()),
       ArticleCallback(&article_cb));
 
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(url, distiller->GetUrl());
 
-  scoped_ptr<DistilledArticleProto> proto = CreateArticleWithURL(url.spec());
+  std::unique_ptr<DistilledArticleProto> proto =
+      CreateArticleWithURL(url.spec());
   RunDistillerCallback(distiller, std::move(proto));
 
   // Check if retrieved URL is same as given URL.
   GURL retrieved_url(service_->GetUrlForEntry(entry_id));
   EXPECT_EQ(url, retrieved_url);
 
   // Remove article and check that there is no longer an entry for the given
   // entry id.
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
@@ skipping 19 matching lines @@
 
   std::string entry_id = service_->AddToList(
       pages_url[0], service_->CreateDefaultDistillerPage(gfx::Size()),
       ArticleCallback(&article_cb));
 
   ArticleEntry entry;
   ASSERT_FALSE(distiller->GetArticleCallback().is_null());
   EXPECT_EQ(pages_url[0], distiller->GetUrl());
 
   // Create the article with pages to pass to the distiller.
-  scoped_ptr<DistilledArticleProto> proto =
+  std::unique_ptr<DistilledArticleProto> proto =
       CreateArticleWithURL(pages_url[0].spec());
   for (int page_num = 1; page_num < kPageCount; ++page_num) {
     DistilledPageProto* distilled_page = proto->add_pages();
     distilled_page->set_url(pages_url[page_num].spec());
   }
 
   RunDistillerCallback(distiller, std::move(proto));
   EXPECT_TRUE(store_->GetEntryByUrl(pages_url[0], &entry));
 
   // Check if retrieved URL is same as given URL for the first page.
   GURL retrieved_url(service_->GetUrlForEntry(entry_id));
   EXPECT_EQ(pages_url[0], retrieved_url);
 
   // Remove the article and check that no URL can be retrieved for the entry.
   service_->RemoveEntry(entry_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, store_->GetEntries().size());
   EXPECT_EQ("", service_->GetUrlForEntry(entry_id));
 }
 
 }  // namespace test
 }  // namespace dom_distiller