Changing font size with pinch gesture in Reader Mode

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/strings/utf_string_conversions.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"
@@ skipping 35 matching lines @@
                    this));
   }
 
   void OnPageDistillationFinished(
       scoped_ptr<proto::DomDistillerResult> distiller_result,
       bool distillation_successful) {
     distiller_result_ = distiller_result.Pass();
     quit_closure_.Run();
   }
 
+  void OnJsExecutionDone(const base::Value* value) {
+    js_result_ = value->DeepCopy();
+    callback_.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_tests_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<proto::DomDistillerResult> distiller_result_;
+  base::Closure callback_;
+  const 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,
@@ skipping 411 matching lines @@
     page_proto->set_title(some_title);
     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)));
   }
 }
 
+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);
+  web_contents->GetController().LoadURL(
+      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;
+  callback_ = run_loop.QuitClosure();

[jdduke (slow), 2015/03/23 15:42:06]

To avoid confusion with the existing quit_closure_, what about just passing the
callback as the first arg when binding the |OnJsExecutionDone| callback?

[wychen, 2015/03/24 22:52:08]

Done.

+  web_contents->GetMainFrame()->ExecuteJavaScript(
+      base::UTF8ToUTF16("(function() {return pinchtest.run();})();"),
+      base::Bind(&DistillerPageWebContentsTest::OnJsExecutionDone,
+                 base::Unretained(this)));
+  run_loop.Run();
+
+  // Convert to dictionary and parse the results.
+  const base::DictionaryValue* dict;
+  js_result_->GetAsDictionary(&dict);
+  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