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

components/dom_distiller/standalone/content_extractor_browsertest.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 <stddef.h>
 #include <sstream>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 38 matching lines @@
 
 typedef base::hash_map<std::string, std::string> FileToUrlMap;
 
 }
 
 // Factory for creating a Distiller that creates different DomDistillerOptions
 // for different URLs, i.e. a specific kOriginalUrl option for each URL.
 class TestDistillerFactoryImpl : public DistillerFactory {
  public:
   TestDistillerFactoryImpl(
-      scoped_ptr<DistillerURLFetcherFactory> distiller_url_fetcher_factory,
+      std::unique_ptr<DistillerURLFetcherFactory> distiller_url_fetcher_factory,
       const dom_distiller::proto::DomDistillerOptions& dom_distiller_options,
       const FileToUrlMap& file_to_url_map)
       : distiller_url_fetcher_factory_(
             std::move(distiller_url_fetcher_factory)),
         dom_distiller_options_(dom_distiller_options),
         file_to_url_map_(file_to_url_map) {}
 
   ~TestDistillerFactoryImpl() override {}
 
-  scoped_ptr<Distiller> CreateDistillerForUrl(const GURL& url) override {
+  std::unique_ptr<Distiller> CreateDistillerForUrl(const GURL& url) override {
     dom_distiller::proto::DomDistillerOptions options;
     options = dom_distiller_options_;
     FileToUrlMap::const_iterator it = file_to_url_map_.find(url.spec());
     if (it != file_to_url_map_.end()) {
       options.set_original_url(it->second);
     }
-    scoped_ptr<DistillerImpl> distiller(new DistillerImpl(
-        *distiller_url_fetcher_factory_, options));
+    std::unique_ptr<DistillerImpl> distiller(
+        new DistillerImpl(*distiller_url_fetcher_factory_, options));
     return std::move(distiller);
   }
 
  private:
-  scoped_ptr<DistillerURLFetcherFactory> distiller_url_fetcher_factory_;
+  std::unique_ptr<DistillerURLFetcherFactory> distiller_url_fetcher_factory_;
   dom_distiller::proto::DomDistillerOptions dom_distiller_options_;
   FileToUrlMap file_to_url_map_;
 };
 
 namespace {
 
 // The url to distill.
 const char* kUrlSwitch = "url";
 
 // A space-separated list of urls to distill.
@@ skipping 21 matching lines @@
 // A semi-colon-separated (i.e. ';') list of original URLs corresponding to
 // "kUrlsSwitch".
 const char* kOriginalUrls = "original-urls";
 
 // The pagination algorithm to use, one of "next", "pagenum".
 const char* kPaginationAlgo = "pagination-algo";
 
 // Maximum number of concurrent started extractor requests.
 const int kMaxExtractorTasks = 8;
 
-scoped_ptr<DomDistillerService> CreateDomDistillerService(
+std::unique_ptr<DomDistillerService> CreateDomDistillerService(
     content::BrowserContext* context,
     const base::FilePath& db_path,
     const FileToUrlMap& file_to_url_map) {
   scoped_refptr<base::SequencedTaskRunner> background_task_runner =
       content::BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
           content::BrowserThread::GetBlockingPool()->GetSequenceToken());
 
   // TODO(cjhopman): use an in-memory database instead of an on-disk one with
   // temporary directory.
-  scoped_ptr<leveldb_proto::ProtoDatabaseImpl<ArticleEntry> > db(
+  std::unique_ptr<leveldb_proto::ProtoDatabaseImpl<ArticleEntry>> db(
       new leveldb_proto::ProtoDatabaseImpl<ArticleEntry>(
           background_task_runner));
-  scoped_ptr<DomDistillerStore> dom_distiller_store(
+  std::unique_ptr<DomDistillerStore> dom_distiller_store(
       new DomDistillerStore(std::move(db), db_path));
 
-  scoped_ptr<DistillerPageFactory> distiller_page_factory(
+  std::unique_ptr<DistillerPageFactory> distiller_page_factory(
       new DistillerPageWebContentsFactory(context));
-  scoped_ptr<DistillerURLFetcherFactory> distiller_url_fetcher_factory(
+  std::unique_ptr<DistillerURLFetcherFactory> distiller_url_fetcher_factory(
       new DistillerURLFetcherFactory(
-          content::BrowserContext::GetDefaultStoragePartition(context)->
-              GetURLRequestContext()));
+          content::BrowserContext::GetDefaultStoragePartition(context)
+              ->GetURLRequestContext()));
 
   dom_distiller::proto::DomDistillerOptions options;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kExtractTextOnly)) {
     options.set_extract_text_only(true);
   }
   int debug_level = 0;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kDebugLevel) &&
       base::StringToInt(
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               kDebugLevel),
           &debug_level)) {
     options.set_debug_level(debug_level);
   }
   // Options for pagination algorithm:
   // - "next": detect anchors with "next" text
   // - "pagenum": detect anchors with numeric page numbers
   // Default is "next".
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kPaginationAlgo)) {
       options.set_pagination_algo(
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               kPaginationAlgo));
   }
 
-  scoped_ptr<DistillerFactory> distiller_factory(new TestDistillerFactoryImpl(
-      std::move(distiller_url_fetcher_factory), options, file_to_url_map));
+  std::unique_ptr<DistillerFactory> distiller_factory(
+      new TestDistillerFactoryImpl(std::move(distiller_url_fetcher_factory),
+                                   options, file_to_url_map));
 
   // Setting up PrefService for DistilledPagePrefs.
   user_prefs::TestingPrefServiceSyncable* pref_service =
       new user_prefs::TestingPrefServiceSyncable();
   DistilledPagePrefs::RegisterProfilePrefs(pref_service->registry());
 
-  return scoped_ptr<DomDistillerService>(new DomDistillerService(
+  return std::unique_ptr<DomDistillerService>(new DomDistillerService(
       std::move(dom_distiller_store), std::move(distiller_factory),
       std::move(distiller_page_factory),
-      scoped_ptr<DistilledPagePrefs>(new DistilledPagePrefs(pref_service))));
+      std::unique_ptr<DistilledPagePrefs>(
+          new DistilledPagePrefs(pref_service))));
 }
 
 void AddComponentsTestResources() {
   base::FilePath pak_file;
   base::FilePath pak_dir;
   PathService::Get(base::DIR_MODULE, &pak_dir);
   pak_file =
       pak_dir.Append(FILE_PATH_LITERAL("components_tests_resources.pak"));
   ui::ResourceBundle::GetSharedInstance().AddDataPackFromPath(
       pak_file, ui::SCALE_FACTOR_NONE);
@@ skipping 113 matching lines @@
   void OnArticleUpdated(ArticleDistillationUpdate article_update) override {}
 
   void OnArticleReady(const DistilledArticleProto* article_proto) override {
     article_proto_ = article_proto;
     CHECK(article_proto->pages_size()) << "Failed extracting " << url_;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   finished_callback_);
   }
 
   const DistilledArticleProto* article_proto_;
-  scoped_ptr<ViewerHandle> viewer_handle_;
+  std::unique_ptr<ViewerHandle> viewer_handle_;
   GURL url_;
   base::Closure finished_callback_;
 };
 
 class ContentExtractor : public ContentBrowserTest {
  public:
   ContentExtractor()
       : pending_tasks_(0),
         max_tasks_(kMaxExtractorTasks),
         next_request_(0),
@@ skipping 95 matching lines @@
     service_.reset();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   size_t pending_tasks_;
   size_t max_tasks_;
   size_t next_request_;
 
   base::ScopedTempDir db_dir_;
-  scoped_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_override_;
-  scoped_ptr<DomDistillerService> service_;
+  std::unique_ptr<net::ScopedDefaultHostResolverProc>
+      mock_host_resolver_override_;
+  std::unique_ptr<DomDistillerService> service_;
   ScopedVector<ContentExtractionRequest> requests_;
 
   std::string output_data_;
-  scoped_ptr<google::protobuf::io::StringOutputStream> protobuf_output_stream_;
+  std::unique_ptr<google::protobuf::io::StringOutputStream>
+      protobuf_output_stream_;
 };
 
 IN_PROC_BROWSER_TEST_F(ContentExtractor, MANUAL_ExtractUrl) {
   SetDistillerJavaScriptWorldId(content::ISOLATED_WORLD_ID_CONTENT_END);
   Start();
   base::RunLoop().Run();
 }
 
 }  // namespace dom_distiller