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

components/dom_distiller/core/task_tracker.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/task_tracker.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 26 matching lines @@
       distilled_article_(),
       content_ready_(false),
       destruction_allowed_(true),
       weak_ptr_factory_(this) {}
 
 TaskTracker::~TaskTracker() {
   DCHECK(destruction_allowed_);
   DCHECK(viewers_.empty());
 }
 
-void TaskTracker::StartDistiller(DistillerFactory* factory,
-                                 scoped_ptr<DistillerPage> distiller_page) {
+void TaskTracker::StartDistiller(
+    DistillerFactory* factory,
+    std::unique_ptr<DistillerPage> distiller_page) {
   if (distiller_) {
     return;
   }
   if (entry_.pages_size() == 0) {
     return;
   }
   GURL url(entry_.pages(0).url());
   DCHECK(url.is_valid());
 
   distiller_ = factory->CreateDistillerForUrl(url);
@@ skipping 16 matching lines @@
 void TaskTracker::AddSaveCallback(const SaveCallback& callback) {
   DCHECK(!callback.is_null());
   save_callbacks_.push_back(callback);
   if (content_ready_) {
     // Distillation for this task has already completed, and so it can be
     // immediately saved.
     ScheduleSaveCallbacks(true);
   }
 }
 
-scoped_ptr<ViewerHandle> TaskTracker::AddViewer(ViewRequestDelegate* delegate) {
+std::unique_ptr<ViewerHandle> TaskTracker::AddViewer(
+    ViewRequestDelegate* delegate) {
   viewers_.push_back(delegate);
   if (content_ready_) {
     // Distillation for this task has already completed, and so the delegate can
     // be immediately told of the result.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&TaskTracker::NotifyViewer,
                               weak_ptr_factory_.GetWeakPtr(), delegate));
   }
-  return scoped_ptr<ViewerHandle>(new ViewerHandle(base::Bind(
+  return std::unique_ptr<ViewerHandle>(new ViewerHandle(base::Bind(
       &TaskTracker::RemoveViewer, weak_ptr_factory_.GetWeakPtr(), delegate)));
 }
 
 const std::string& TaskTracker::GetEntryId() const { return entry_.entry_id(); }
 
 bool TaskTracker::HasEntryId(const std::string& entry_id) const {
   return entry_.entry_id() == entry_id;
 }
 
 bool TaskTracker::HasUrl(const GURL& url) const {
@@ skipping 28 matching lines @@
 void TaskTracker::CancelSaveCallbacks() { ScheduleSaveCallbacks(false); }
 
 void TaskTracker::ScheduleSaveCallbacks(bool distillation_succeeded) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&TaskTracker::DoSaveCallbacks, weak_ptr_factory_.GetWeakPtr(),
                  distillation_succeeded));
 }
 
 void TaskTracker::OnDistillerFinished(
-    scoped_ptr<DistilledArticleProto> distilled_article) {
+    std::unique_ptr<DistilledArticleProto> distilled_article) {
   if (content_ready_) {
     return;
   }
 
   DistilledArticleReady(std::move(distilled_article));
   if (content_ready_) {
     AddDistilledContentToStore(*distilled_article_);
   }
 
   // 'distiller_ != null' is used as a signal that distillation is in progress,
   // so it needs to be released so that we know distillation is done.
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, distiller_.release());
 
   ContentSourceFinished();
 }
 
 void TaskTracker::CancelPendingSources() {
   if (distiller_) {
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, distiller_.release());
   }
 }
 
 void TaskTracker::OnBlobFetched(
     bool success,
-    scoped_ptr<DistilledArticleProto> distilled_article) {
+    std::unique_ptr<DistilledArticleProto> distilled_article) {
   blob_fetcher_running_ = false;
 
   if (content_ready_) {
     return;
   }
 
   DistilledArticleReady(std::move(distilled_article));
 
   ContentSourceFinished();
 }
 
 bool TaskTracker::IsAnySourceRunning() const {
   return distiller_ || blob_fetcher_running_;
 }
 
 void TaskTracker::ContentSourceFinished() {
   if (content_ready_) {
     CancelPendingSources();
   } else if (!IsAnySourceRunning()) {
     distilled_article_.reset(new DistilledArticleProto());
     NotifyViewersAndCallbacks();
   }
 }
 
 void TaskTracker::DistilledArticleReady(
-    scoped_ptr<DistilledArticleProto> distilled_article) {
+    std::unique_ptr<DistilledArticleProto> distilled_article) {
   DCHECK(!content_ready_);
 
   if (distilled_article->pages_size() == 0) {
     return;
   }
 
   content_ready_ = true;
 
   distilled_article_ = std::move(distilled_article);
   entry_.set_title(distilled_article_->title());
@@ skipping 42 matching lines @@
 void TaskTracker::AddDistilledContentToStore(
     const DistilledArticleProto& content) {
   if (content_store_) {
     content_store_->SaveContent(
         entry_, content, DistilledContentStore::SaveCallback());
   }
 }
 
 
 }  // namespace dom_distiller