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

components/dom_distiller/content/browser/distiller_page_web_contents_browsertest.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/content/browser/distiller_page_web_contents.h"
 
 #include <utility>
 
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
@@ skipping 86 matching lines @@
   void DistillPage(const base::Closure& quit_closure, const std::string& url) {
     distiller_page_->DistillPage(
         embedded_test_server()->GetURL(url),
         dom_distiller::proto::DomDistillerOptions(),
         base::Bind(&DistillerPageWebContentsTest::OnPageDistillationFinished,
                    this, quit_closure));
   }
 
   void OnPageDistillationFinished(
       base::Closure quit_closure,
-      scoped_ptr<proto::DomDistillerResult> distiller_result,
+      std::unique_ptr<proto::DomDistillerResult> distiller_result,
       bool distillation_successful) {
     distiller_result_ = std::move(distiller_result);
     quit_closure.Run();
   }
 
   void OnJsExecutionDone(base::Closure callback, const base::Value* value) {
     js_result_.reset(value->DeepCopy());
     callback.Run();
   }
 
@@ skipping 23 matching lines @@
     ASSERT_TRUE(embedded_test_server()->Start());
   }
 
  protected:
   void RunUseCurrentWebContentsTest(const std::string& url,
                                     bool expect_new_web_contents,
                                     bool setup_main_frame_observer,
                                     bool wait_for_document_loaded);
 
   DistillerPageWebContents* distiller_page_;
-  scoped_ptr<proto::DomDistillerResult> distiller_result_;
-  scoped_ptr<base::Value> js_result_;
+  std::unique_ptr<proto::DomDistillerResult> distiller_result_;
+  std::unique_ptr<base::Value> js_result_;
 };
 
 // Use this class to be able to leak the WebContents, which is needed for when
 // the current WebContents is used for distillation.
 class TestDistillerPageWebContents : public DistillerPageWebContents {
  public:
   TestDistillerPageWebContents(
       content::BrowserContext* browser_context,
       const gfx::Size& render_view_size,
-      scoped_ptr<SourcePageHandleWebContents> optional_web_contents_handle,
+      std::unique_ptr<SourcePageHandleWebContents> optional_web_contents_handle,
       bool expect_new_web_contents)
       : DistillerPageWebContents(browser_context,
                                  render_view_size,
                                  std::move(optional_web_contents_handle)),
         expect_new_web_contents_(expect_new_web_contents),
         new_web_contents_created_(false) {}
 
   void CreateNewWebContents(const GURL& url) override {
     ASSERT_EQ(true, expect_new_web_contents_);
     new_web_contents_created_ = true;
     DistillerPageWebContents::CreateNewWebContents(url);
   }
 
   bool new_web_contents_created() { return new_web_contents_created_; }
 
  private:
   bool expect_new_web_contents_;
   bool new_web_contents_created_;
 };
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, BasicDistillationWorks) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      std::unique_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
   run_loop.Run();
 
   EXPECT_EQ("Test Page Title", distiller_result_->title());
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               HasSubstr("Lorem ipsum"));
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               Not(HasSubstr("questionable content")));
   EXPECT_EQ("", distiller_result_->pagination_info().next_page());
   EXPECT_EQ("", distiller_result_->pagination_info().prev_page());
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, HandlesRelativeLinks) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      std::unique_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
   run_loop.Run();
 
   // A relative link should've been updated.
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               ContainsRegex("href=\"http://127.0.0.1:.*/relativelink.html\""));
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               HasSubstr("href=\"http://www.google.com/absolutelink.html\""));
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, HandlesRelativeImages) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      std::unique_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
   run_loop.Run();
 
   // A relative link should've been updated.
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               ContainsRegex("src=\"http://127.0.0.1:.*/relativeimage.png\""));
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               HasSubstr("src=\"http://www.google.com/absoluteimage.png\""));
 }
 
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, HandlesRelativeVideos) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      std::unique_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kVideoArticlePath);
   run_loop.Run();
 
   // A relative source/track should've been updated.
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               ContainsRegex("src=\"http://127.0.0.1:.*/relative_video.webm\""));
   EXPECT_THAT(
       distiller_result_->distilled_content().html(),
       ContainsRegex("src=\"http://127.0.0.1:.*/relative_track_en.vtt\""));
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               HasSubstr("src=\"http://www.google.com/absolute_video.ogg\""));
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               HasSubstr("src=\"http://www.google.com/absolute_track_fr.vtt\""));
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, VisibilityDetection) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      std::unique_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   // visble_style.html and invisible_style.html only differ by the visibility
   // internal stylesheet.
 
   {
     base::RunLoop run_loop;
     DistillPage(run_loop.QuitClosure(), "/visible_style.html");
     run_loop.Run();
     EXPECT_THAT(distiller_result_->distilled_content().html(),
@@ skipping 71 matching lines @@
   WebContentsMainFrameHelper main_frame_loaded(current_web_contents,
                                                url_loaded_runner.QuitClosure(),
                                                wait_for_document_loaded);
   current_web_contents->GetController().LoadURL(
       embedded_test_server()->GetURL(url),
       content::Referrer(),
       ui::PAGE_TRANSITION_TYPED,
       std::string());
   url_loaded_runner.Run();
 
-  scoped_ptr<SourcePageHandleWebContents> source_page_handle(
+  std::unique_ptr<SourcePageHandleWebContents> source_page_handle(
       new SourcePageHandleWebContents(current_web_contents, false));
 
   TestDistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
       std::move(source_page_handle), expect_new_web_contents);
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
@@ skipping 16 matching lines @@
   WebContentsMainFrameHelper main_frame_loaded(current_web_contents,
                                                url_loaded_runner.QuitClosure(),
                                                true);
   current_web_contents->GetController().LoadURL(
       embedded_test_server()->GetURL(kSimpleArticlePath),
       content::Referrer(),
       ui::PAGE_TRANSITION_TYPED,
       std::string());
   url_loaded_runner.Run();
 
-  scoped_ptr<SourcePageHandleWebContents> source_page_handle(
+  std::unique_ptr<SourcePageHandleWebContents> source_page_handle(
       new SourcePageHandleWebContents(current_web_contents, false));
 
   TestDistillerPageWebContents* distiller_page(new TestDistillerPageWebContents(
       current_web_contents->GetBrowserContext(),
       current_web_contents->GetContainerBounds().size(),
       std::move(source_page_handle), false));
   distiller_page_ = distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
 
   // It can not crash the loop when returning the result.
   delete distiller_page_;
 
   // Make sure the test ends when it does not crash.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, run_loop.QuitClosure(), base::TimeDelta::FromSeconds(2));
 
   run_loop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, MarkupInfo) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      std::unique_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), "/markup_article.html");
   run_loop.Run();
 
   EXPECT_THAT(distiller_result_->distilled_content().html(),
               HasSubstr("Lorem ipsum"));
   EXPECT_EQ("Marked-up Markup Test Page Title", distiller_result_->title());
 
@@ skipping 32 matching lines @@
   EXPECT_EQ(1000, markup_image2.width());
   EXPECT_EQ(600, markup_image2.height());
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest,
                        TestNoContentDoesNotCrash) {
   const std::string no_content =
       l10n_util::GetStringUTF8(IDS_DOM_DISTILLER_VIEWER_NO_DATA_CONTENT);
 
   {  // Test zero pages.
-    scoped_ptr<DistilledArticleProto> article_proto(
+    std::unique_ptr<DistilledArticleProto> article_proto(
         new DistilledArticleProto());
     std::string js = viewer::GetUnsafeArticleContentJs(article_proto.get());
     EXPECT_THAT(js, HasSubstr(no_content));
   }
 
   {  // Test empty content.
-    scoped_ptr<DistilledArticleProto> article_proto(
+    std::unique_ptr<DistilledArticleProto> article_proto(
         new DistilledArticleProto());
     (*(article_proto->add_pages())).set_html("");
     std::string js = viewer::GetUnsafeArticleContentJs(article_proto.get());
     EXPECT_THAT(js, HasSubstr(no_content));
   }
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest,
                        TestPinch) {
   // Load the test file in content shell and wait until it has fully loaded.
@@ skipping 24 matching lines @@
   ASSERT_TRUE(js_result_);
   ASSERT_TRUE(js_result_->GetAsDictionary(&dict));
 
   ASSERT_TRUE(dict->HasKey("success"));
   bool success;
   ASSERT_TRUE(dict->GetBoolean("success", &success));
   EXPECT_TRUE(success);
 }
 
 }  // namespace dom_distiller