Remove DistilledPageInfo and related structs.

components/dom_distiller/content/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 "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "components/dom_distiller/content/distiller_page_web_contents.h"
 #include "components/dom_distiller/content/web_contents_main_frame_observer.h"
 #include "components/dom_distiller/core/distiller_page.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/shell/browser/shell.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "third_party/dom_distiller_js/dom_distiller.pb.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::ContentBrowserTest;
 using testing::ContainsRegex;
 using testing::HasSubstr;
 using testing::Not;
 
 namespace dom_distiller {
 
 const char* kSimpleArticlePath = "/simple_article.html";
@@ skipping 10 matching lines @@
 
   void DistillPage(const base::Closure& quit_closure, const std::string& url) {
     quit_closure_ = quit_closure;
     distiller_page_->DistillPage(
         embedded_test_server()->GetURL(url),
         dom_distiller::proto::DomDistillerOptions(),
         base::Bind(&DistillerPageWebContentsTest::OnPageDistillationFinished,
                    this));
   }
 
-  void OnPageDistillationFinished(scoped_ptr<DistilledPageInfo> distilled_page,
-                                  bool distillation_successful) {
-    page_info_ = distilled_page.Pass();
+  void OnPageDistillationFinished(
+      scoped_ptr<proto::DomDistillerResult> distiller_result,
+      bool distillation_successful) {
+    distiller_result_ = distiller_result.Pass();
     quit_closure_.Run();
   }
 
  private:
   void AddComponentsResources() {
     base::FilePath pak_file;
     base::FilePath pak_dir;
     PathService::Get(base::DIR_MODULE, &pak_dir);
     pak_file = pak_dir.Append(FILE_PATH_LITERAL("components_resources.pak"));
     ui::ResourceBundle::GetSharedInstance().AddDataPackFromPath(
         pak_file, ui::SCALE_FACTOR_NONE);
   }
 
   void SetUpTestServer() {
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.AppendASCII("components/test/data/dom_distiller");
     embedded_test_server()->ServeFilesFromDirectory(path);
     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   }
 
  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_;
   base::Closure quit_closure_;
-  scoped_ptr<DistilledPageInfo> page_info_;
+  scoped_ptr<proto::DomDistillerResult> distiller_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,
@@ skipping 69 matching lines @@
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
       scoped_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
   run_loop.Run();
 
-  EXPECT_EQ("Test Page Title", page_info_.get()->title);
-  EXPECT_THAT(page_info_.get()->html, HasSubstr("Lorem ipsum"));
-  EXPECT_THAT(page_info_.get()->html, Not(HasSubstr("questionable content")));
-  EXPECT_EQ("", page_info_.get()->next_page_url);
-  EXPECT_EQ("", page_info_.get()->prev_page_url);
+  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>());
   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(page_info_.get()->html,
+  EXPECT_THAT(distiller_result_->distilled_content().html(),
               ContainsRegex("href=\"http://127.0.0.1:.*/relativelink.html\""));
-  EXPECT_THAT(page_info_.get()->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>());
   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(page_info_.get()->html,
+  EXPECT_THAT(distiller_result_->distilled_content().html(),
               ContainsRegex("src=\"http://127.0.0.1:.*/relativeimage.png\""));
-  EXPECT_THAT(page_info_.get()->html,
+  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>());
   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.mp4\""));
   EXPECT_THAT(
-      page_info_.get()->html,
-      ContainsRegex("src=\"http://127.0.0.1:.*/relative_video.mp4\""));
-  EXPECT_THAT(
-      page_info_.get()->html,
+      distiller_result_->distilled_content().html(),
       ContainsRegex("src=\"http://127.0.0.1:.*/relative_track_en.vtt\""));
-  EXPECT_THAT(
-      page_info_.get()->html,
-      HasSubstr("src=\"http://www.google.com/absolute_video.ogg\""));
-  EXPECT_THAT(
-      page_info_.get()->html,
-      HasSubstr("src=\"http://www.google.com/absolute_track_fr.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>());
   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(page_info_.get()->html, HasSubstr("Lorem ipsum"));
+    EXPECT_THAT(distiller_result_->distilled_content().html(),
+                HasSubstr("Lorem ipsum"));
   }
 
   {
     base::RunLoop run_loop;
     DistillPage(run_loop.QuitClosure(), "/invisible_style.html");
     run_loop.Run();
-    EXPECT_THAT(page_info_.get()->html, Not(HasSubstr("Lorem ipsum")));
+    EXPECT_THAT(distiller_result_->distilled_content().html(),
+                Not(HasSubstr("Lorem ipsum")));
   }
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest,
                        UsingCurrentWebContentsWrongUrl) {
   std::string url("/bogus");
   bool expect_new_web_contents = true;
   bool setup_main_frame_observer = true;
   bool wait_for_document_loaded = true;
   RunUseCurrentWebContentsTest(url,
@@ skipping 69 matching lines @@
       source_page_handle.Pass(),
       expect_new_web_contents);
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kSimpleArticlePath);
   run_loop.Run();
 
   // Sanity check of distillation process.
   EXPECT_EQ(expect_new_web_contents, distiller_page.new_web_contents_created());
-  EXPECT_EQ("Test Page Title", page_info_.get()->title);
+  EXPECT_EQ("Test Page Title", distiller_result_->title());
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, MarkupInfo) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
       scoped_ptr<SourcePageHandleWebContents>());
   distiller_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), "/markup_article.html");
   run_loop.Run();
 
-  EXPECT_THAT(page_info_.get()->html, HasSubstr("Lorem ipsum"));
-  EXPECT_EQ("Marked-up Markup Test Page Title", page_info_.get()->title);
+  EXPECT_THAT(distiller_result_->distilled_content().html(),
+              HasSubstr("Lorem ipsum"));
+  EXPECT_EQ("Marked-up Markup Test Page Title", distiller_result_->title());
 
-  const DistilledPageInfo::MarkupInfo& markup_info = page_info_->markup_info;
-  EXPECT_EQ("Marked-up Markup Test Page Title", markup_info.title);
-  EXPECT_EQ("Article", markup_info.type);
-  EXPECT_EQ("http://test/markup.html", markup_info.url);
-  EXPECT_EQ("This page tests Markup Info.", markup_info.description);
-  EXPECT_EQ("Whoever Published", markup_info.publisher);
-  EXPECT_EQ("Copyright 2000-2014 Whoever Copyrighted", markup_info.copyright);
-  EXPECT_EQ("Whoever Authored", markup_info.author);
+  const proto::MarkupInfo markup_info = distiller_result_->markup_info();
+  EXPECT_EQ("Marked-up Markup Test Page Title", markup_info.title());
+  EXPECT_EQ("Article", markup_info.type());
+  EXPECT_EQ("http://test/markup.html", markup_info.url());
+  EXPECT_EQ("This page tests Markup Info.", markup_info.description());
+  EXPECT_EQ("Whoever Published", markup_info.publisher());
+  EXPECT_EQ("Copyright 2000-2014 Whoever Copyrighted", markup_info.copyright());
+  EXPECT_EQ("Whoever Authored", markup_info.author());
 
-  const DistilledPageInfo::MarkupArticle& markup_article = markup_info.article;
-  EXPECT_EQ("Whatever Section", markup_article.section);
-  EXPECT_EQ("July 23, 2014", markup_article.published_time);
-  EXPECT_EQ("2014-07-23T23:59", markup_article.modified_time);
-  EXPECT_EQ("", markup_article.expiration_time);
-  ASSERT_EQ(1U, markup_article.authors.size());
-  EXPECT_EQ("Whoever Authored", markup_article.authors[0]);
+  const proto::MarkupArticle markup_article = markup_info.article();
+  EXPECT_EQ("Whatever Section", markup_article.section());
+  EXPECT_EQ("July 23, 2014", markup_article.published_time());
+  EXPECT_EQ("2014-07-23T23:59", markup_article.modified_time());
+  EXPECT_EQ("", markup_article.expiration_time());
+  ASSERT_EQ(1, markup_article.authors_size());
+  EXPECT_EQ("Whoever Authored", markup_article.authors(0));
 
-  ASSERT_EQ(2U, markup_info.images.size());
+  ASSERT_EQ(2, markup_info.images_size());
 
-  const DistilledPageInfo::MarkupImage& markup_image1 = markup_info.images[0];
-  EXPECT_EQ("http://test/markup1.jpeg", markup_image1.url);
-  EXPECT_EQ("https://test/markup1.jpeg", markup_image1.secure_url);
-  EXPECT_EQ("jpeg", markup_image1.type);
-  EXPECT_EQ("", markup_image1.caption);
-  EXPECT_EQ(600, markup_image1.width);
-  EXPECT_EQ(400, markup_image1.height);
+  const proto::MarkupImage markup_image1 = markup_info.images(0);
+  EXPECT_EQ("http://test/markup1.jpeg", markup_image1.url());
+  EXPECT_EQ("https://test/markup1.jpeg", markup_image1.secure_url());
+  EXPECT_EQ("jpeg", markup_image1.type());
+  EXPECT_EQ("", markup_image1.caption());
+  EXPECT_EQ(600, markup_image1.width());
+  EXPECT_EQ(400, markup_image1.height());
 
-  const DistilledPageInfo::MarkupImage& markup_image2 = markup_info.images[1];
-  EXPECT_EQ("http://test/markup2.gif", markup_image2.url);
-  EXPECT_EQ("https://test/markup2.gif", markup_image2.secure_url);
-  EXPECT_EQ("gif", markup_image2.type);
-  EXPECT_EQ("", markup_image2.caption);
-  EXPECT_EQ(1000, markup_image2.width);
-  EXPECT_EQ(600, markup_image2.height);
+  const proto::MarkupImage markup_image2 = markup_info.images(1);
+  EXPECT_EQ("http://test/markup2.gif", markup_image2.url());
+  EXPECT_EQ("https://test/markup2.gif", markup_image2.secure_url());
+  EXPECT_EQ("gif", markup_image2.type());
+  EXPECT_EQ("", markup_image2.caption());
+  EXPECT_EQ(1000, markup_image2.width());
+  EXPECT_EQ(600, markup_image2.height());
 }
 
 }  // namespace dom_distiller