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

components/dom_distiller/core/dom_distiller_service.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/guid.h"
 #include "base/location.h"
@@ skipping 24 matching lines @@
     const DomDistillerService::ArticleAvailableCallback& article_cb,
     const ArticleEntry& entry,
     const DistilledArticleProto* article_proto,
     bool distillation_succeeded) {
   article_cb.Run(distillation_succeeded);
 }
 
 }  // namespace
 
 DomDistillerService::DomDistillerService(
-    scoped_ptr<DomDistillerStoreInterface> store,
-    scoped_ptr<DistillerFactory> distiller_factory,
-    scoped_ptr<DistillerPageFactory> distiller_page_factory,
-    scoped_ptr<DistilledPagePrefs> distilled_page_prefs)
+    std::unique_ptr<DomDistillerStoreInterface> store,
+    std::unique_ptr<DistillerFactory> distiller_factory,
+    std::unique_ptr<DistillerPageFactory> distiller_page_factory,
+    std::unique_ptr<DistilledPagePrefs> distilled_page_prefs)
     : store_(std::move(store)),
       content_store_(new InMemoryContentStore(kDefaultMaxNumCachedEntries)),
       distiller_factory_(std::move(distiller_factory)),
       distiller_page_factory_(std::move(distiller_page_factory)),
       distilled_page_prefs_(std::move(distilled_page_prefs)) {}
 
 DomDistillerService::~DomDistillerService() {
 }
 
 syncer::SyncableService* DomDistillerService::GetSyncableService() const {
   return store_->GetSyncableService();
 }
 
-scoped_ptr<DistillerPage> DomDistillerService::CreateDefaultDistillerPage(
+std::unique_ptr<DistillerPage> DomDistillerService::CreateDefaultDistillerPage(
     const gfx::Size& render_view_size) {
   return distiller_page_factory_->CreateDistillerPage(render_view_size);
 }
 
-scoped_ptr<DistillerPage>
+std::unique_ptr<DistillerPage>
 DomDistillerService::CreateDefaultDistillerPageWithHandle(
-    scoped_ptr<SourcePageHandle> handle) {
+    std::unique_ptr<SourcePageHandle> handle) {
   return distiller_page_factory_->CreateDistillerPageWithHandle(
       std::move(handle));
 }
 
 const std::string DomDistillerService::AddToList(
     const GURL& url,
-    scoped_ptr<DistillerPage> distiller_page,
+    std::unique_ptr<DistillerPage> distiller_page,
     const ArticleAvailableCallback& article_cb) {
   ArticleEntry entry;
   const bool is_already_added = store_->GetEntryByUrl(url, &entry);
 
   TaskTracker* task_tracker = nullptr;
   if (is_already_added) {
     task_tracker = GetTaskTrackerForEntry(entry);
     if (task_tracker == NULL) {
       // Entry is in the store but there is no task tracker. This could
       // happen when distillation has already completed. For now just return
@@ skipping 34 matching lines @@
   if (store_->GetEntryById(entry_id, &entry)) {
     return entry.pages().Get(0).url();
   }
   return "";
 }
 
 std::vector<ArticleEntry> DomDistillerService::GetEntries() const {
   return store_->GetEntries();
 }
 
-scoped_ptr<ArticleEntry> DomDistillerService::RemoveEntry(
+std::unique_ptr<ArticleEntry> DomDistillerService::RemoveEntry(
     const std::string& entry_id) {
-  scoped_ptr<ArticleEntry> entry(new ArticleEntry);
+  std::unique_ptr<ArticleEntry> entry(new ArticleEntry);
   entry->set_entry_id(entry_id);
   TaskTracker* task_tracker = GetTaskTrackerForEntry(*entry);
   if (task_tracker != NULL) {
     task_tracker->CancelSaveCallbacks();
   }
 
   if (!store_->GetEntryById(entry_id, entry.get())) {
-    return scoped_ptr<ArticleEntry>();
+    return std::unique_ptr<ArticleEntry>();
   }
 
   if (store_->RemoveEntry(*entry)) {
     return entry;
   }
-  return scoped_ptr<ArticleEntry>();
+  return std::unique_ptr<ArticleEntry>();
 }
 
-scoped_ptr<ViewerHandle> DomDistillerService::ViewEntry(
+std::unique_ptr<ViewerHandle> DomDistillerService::ViewEntry(
     ViewRequestDelegate* delegate,
-    scoped_ptr<DistillerPage> distiller_page,
+    std::unique_ptr<DistillerPage> distiller_page,
     const std::string& entry_id) {
   ArticleEntry entry;
   if (!store_->GetEntryById(entry_id, &entry)) {
-    return scoped_ptr<ViewerHandle>();
+    return std::unique_ptr<ViewerHandle>();
   }
 
   TaskTracker* task_tracker = nullptr;
   bool was_created = GetOrCreateTaskTrackerForEntry(entry, &task_tracker);
-  scoped_ptr<ViewerHandle> viewer_handle = task_tracker->AddViewer(delegate);
+  std::unique_ptr<ViewerHandle> viewer_handle =
+      task_tracker->AddViewer(delegate);
   if (was_created) {
     task_tracker->StartDistiller(distiller_factory_.get(),
                                  std::move(distiller_page));
     task_tracker->StartBlobFetcher();
   }
 
   return viewer_handle;
 }
 
-scoped_ptr<ViewerHandle> DomDistillerService::ViewUrl(
+std::unique_ptr<ViewerHandle> DomDistillerService::ViewUrl(
     ViewRequestDelegate* delegate,
-    scoped_ptr<DistillerPage> distiller_page,
+    std::unique_ptr<DistillerPage> distiller_page,
     const GURL& url) {
   if (!url.is_valid()) {
-    return scoped_ptr<ViewerHandle>();
+    return std::unique_ptr<ViewerHandle>();
   }
 
   TaskTracker* task_tracker = nullptr;
   bool was_created = GetOrCreateTaskTrackerForUrl(url, &task_tracker);
-  scoped_ptr<ViewerHandle> viewer_handle = task_tracker->AddViewer(delegate);
+  std::unique_ptr<ViewerHandle> viewer_handle =
+      task_tracker->AddViewer(delegate);
   // If a distiller is already running for one URL, don't start another.
   if (was_created) {
     task_tracker->StartDistiller(distiller_factory_.get(),
                                  std::move(distiller_page));
     task_tracker->StartBlobFetcher();
   }
 
   return viewer_handle;
 }
 
@@ skipping 84 matching lines @@
 void DomDistillerService::RemoveObserver(DomDistillerObserver* observer) {
   DCHECK(observer);
   store_->RemoveObserver(observer);
 }
 
 DistilledPagePrefs* DomDistillerService::GetDistilledPagePrefs() {
   return distilled_page_prefs_.get();
 }
 
 }  // namespace dom_distiller