Add support for providing an external file for extracting content.

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 "components/dom_distiller/core/proto/distilled_article.pb.h"
 #include "components/dom_distiller/core/proto/distilled_page.pb.h"
 #include "components/dom_distiller/core/viewer.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 "grit/components_resources.h"
 #include "grit/components_strings.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/l10n/l10n_util.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";
 const char* kVideoArticlePath = "/video_article.html";
 
 class DistillerPageWebContentsTest : public ContentBrowserTest {
  public:
   // ContentBrowserTest:
   void SetUpOnMainThread() override {
     AddComponentsResources();
     SetUpTestServer();
     ContentBrowserTest::SetUpOnMainThread();
+    distiller_js_script_ = ResourceBundle::GetSharedInstance()
+                               .GetRawDataResource(IDR_DISTILLER_JS)
+                               .as_string();
   }
 
   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));
   }
@@ skipping 26 matching lines @@
 
  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<proto::DomDistillerResult> distiller_result_;
+  std::string distiller_js_script_;
 };
 
 // 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,
+      const std::string& distiller_js_script,
       scoped_ptr<SourcePageHandleWebContents> optional_web_contents_handle,
       bool expect_new_web_contents)
-      : DistillerPageWebContents(browser_context, render_view_size,
+      : DistillerPageWebContents(browser_context,
+                                 render_view_size,
+                                 distiller_js_script,
                                  optional_web_contents_handle.Pass()),
         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 resets the scoped_ptr to
     // the WebContents, so intentionally leak WebContents here, since it is
     // owned by the shell.
@@ skipping 50 matching lines @@
 
  private:
   base::Closure callback_;
   bool wait_for_document_loaded_;
 };
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, BasicDistillationWorks) {
   DistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      scoped_ptr<SourcePageHandleWebContents>());
+      distiller_js_script_, scoped_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>());
+      distiller_js_script_, 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(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>());
+      distiller_js_script_, 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(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>());
+      distiller_js_script_, 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(
       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>());
+      distiller_js_script_, 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(distiller_result_->distilled_content().html(),
@@ skipping 78 matching lines @@
       std::string());
   url_loaded_runner.Run();
 
   scoped_ptr<content::WebContents> old_web_contents_sptr(current_web_contents);
   scoped_ptr<SourcePageHandleWebContents> source_page_handle(
       new SourcePageHandleWebContents(old_web_contents_sptr.Pass()));
 
   TestDistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      source_page_handle.Pass(),
-      expect_new_web_contents);
+      distiller_js_script_, 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", 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_js_script_, scoped_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 133 matching lines @@
     std::string html = viewer::GetUnsafePartialArticleHtml(page_proto.get(),
         DistilledPagePrefs::LIGHT, DistilledPagePrefs::SERIF);
     EXPECT_THAT(html, HasSubstr(some_title));
     EXPECT_THAT(html, HasSubstr(no_content));
     EXPECT_THAT(html, Not(HasSubstr(no_title)));
     EXPECT_THAT(html, Not(HasSubstr(some_content)));
   }
 }
 
 }  // namespace dom_distiller