Expose distiller functions to JavaScript

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 "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/dom_distiller/content/browser/distiller_javascript_utils.h"
@@ skipping 139 matching lines @@
 
 // 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,
       bool expect_new_web_contents)
-      : DistillerPageWebContents(browser_context, render_view_size,
+      : DistillerPageWebContents(browser_context,
+                                 render_view_size,
                                  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(url);
   }
 
@@ skipping 53 matching lines @@
   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_page_ = &distiller_page;
 
   base::RunLoop run_loop;
   DistillPage(run_loop.QuitClosure(), kVideoArticlePath);
   run_loop.Run();
@@ skipping 36 matching lines @@
                 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,
-                               expect_new_web_contents,
+  RunUseCurrentWebContentsTest(url, expect_new_web_contents,
                                setup_main_frame_observer,
                                wait_for_document_loaded);
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest,
                        UsingCurrentWebContentsNoMainFrameObserver) {
   std::string url(kSimpleArticlePath);
   bool expect_new_web_contents = true;
   bool setup_main_frame_observer = false;
   bool wait_for_document_loaded = true;
-  RunUseCurrentWebContentsTest(url,
-                               expect_new_web_contents,
+  RunUseCurrentWebContentsTest(url, expect_new_web_contents,
                                setup_main_frame_observer,
                                wait_for_document_loaded);
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest,
                        UsingCurrentWebContentsNotFinishedLoadingYet) {
   std::string url(kSimpleArticlePath);
   bool expect_new_web_contents = false;
   bool setup_main_frame_observer = true;
   bool wait_for_document_loaded = false;
-  RunUseCurrentWebContentsTest(url,
-                               expect_new_web_contents,
+  RunUseCurrentWebContentsTest(url, expect_new_web_contents,
                                setup_main_frame_observer,
                                wait_for_document_loaded);
 }
 
 IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest,
                        UsingCurrentWebContentsReadyForDistillation) {
   std::string url(kSimpleArticlePath);
   bool expect_new_web_contents = false;
   bool setup_main_frame_observer = true;
   bool wait_for_document_loaded = true;
-  RunUseCurrentWebContentsTest(url,
-                               expect_new_web_contents,
+  RunUseCurrentWebContentsTest(url, expect_new_web_contents,
                                setup_main_frame_observer,
                                wait_for_document_loaded);
 }
 
 void DistillerPageWebContentsTest::RunUseCurrentWebContentsTest(
     const std::string& url,
     bool expect_new_web_contents,
     bool setup_main_frame_observer,
     bool wait_for_document_loaded) {
   content::WebContents* current_web_contents = shell()->web_contents();
   if (setup_main_frame_observer) {
     dom_distiller::WebContentsMainFrameObserver::CreateForWebContents(
         current_web_contents);
   }
   base::RunLoop url_loaded_runner;
   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());
+      embedded_test_server()->GetURL(url), content::Referrer(),
+      ui::PAGE_TRANSITION_TYPED, std::string());
   url_loaded_runner.Run();
 
   scoped_ptr<SourcePageHandleWebContents> source_page_handle(
       new SourcePageHandleWebContents(current_web_contents, false));
 
   TestDistillerPageWebContents distiller_page(
       shell()->web_contents()->GetBrowserContext(),
       shell()->web_contents()->GetContainerBounds().size(),
-      source_page_handle.Pass(),
-      expect_new_web_contents);
+      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,
                        PageDestroyedBeforeFinishDistillation) {
-
   content::WebContents* current_web_contents = shell()->web_contents();
 
   dom_distiller::WebContentsMainFrameObserver::CreateForWebContents(
       current_web_contents);
 
   base::RunLoop url_loaded_runner;
-  WebContentsMainFrameHelper main_frame_loaded(current_web_contents,
-                                               url_loaded_runner.QuitClosure(),
-                                               true);
+  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());
+      embedded_test_server()->GetURL(kSimpleArticlePath), content::Referrer(),
+      ui::PAGE_TRANSITION_TYPED, std::string());
   url_loaded_runner.Run();
 
   scoped_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(),
-          source_page_handle.Pass(),
-          false));
+  TestDistillerPageWebContents* distiller_page(new TestDistillerPageWebContents(
+      current_web_contents->GetBrowserContext(),
+      current_web_contents->GetContainerBounds().size(),
+      source_page_handle.Pass(), 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(
@@ skipping 67 matching lines @@
 
   {  // Test empty content.
     scoped_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) {
+IN_PROC_BROWSER_TEST_F(DistillerPageWebContentsTest, TestPinch) {
   // Load the test file in content shell and wait until it has fully loaded.
   content::WebContents* web_contents = shell()->web_contents();
   dom_distiller::WebContentsMainFrameObserver::CreateForWebContents(
       web_contents);
   base::RunLoop url_loaded_runner;
-  WebContentsMainFrameHelper main_frame_loaded(web_contents,
-                                               url_loaded_runner.QuitClosure(),
-                                               true);
+  WebContentsMainFrameHelper main_frame_loaded(
+      web_contents, url_loaded_runner.QuitClosure(), true);
   web_contents->GetController().LoadURL(
-      embedded_test_server()->GetURL("/pinch_tester.html"),
-      content::Referrer(),
-      ui::PAGE_TRANSITION_TYPED,
-      std::string());
+      embedded_test_server()->GetURL("/pinch_tester.html"), content::Referrer(),
+      ui::PAGE_TRANSITION_TYPED, std::string());
   url_loaded_runner.Run();
 
   // Execute the JS to run the tests, and wait until it has finished.
   base::RunLoop run_loop;
   web_contents->GetMainFrame()->ExecuteJavaScriptForTests(
       base::UTF8ToUTF16("(function() {return pinchtest.run();})();"),
       base::Bind(&DistillerPageWebContentsTest::OnJsExecutionDone,
                  base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
 
   // Convert to dictionary and parse the results.
   const base::DictionaryValue* dict;
   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