Add a "Simplify Page" option to the print preview dialog

components/dom_distiller/content/dom_distiller_viewer_source.cc

 // Copyright 2014 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/dom_distiller_viewer_source.h"
 
 #include <sstream>
 #include <string>
 #include <vector>
 
@@ skipping 62 matching lines @@
 
   // content::WebContentsObserver implementation:
   void DidNavigateMainFrame(
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void WebContentsDestroyed() override;
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
                      const GURL& validated_url) override;
 
- private:
+ protected:
   // Sends JavaScript to the attached Viewer, buffering data if the viewer isn't
   // ready.
   void SendJavaScript(const std::string& buffer) override;
 
   // Cancels the current view request. Once called, no updates will be
   // propagated to the view, and the request to DomDistillerService will be
   // cancelled.
   void Cancel();
 
   // The scheme hosting the current view request;
@@ skipping 88 matching lines @@
     return;
   }
   waiting_for_page_ready_ = false;
   if (buffer_.empty()) {
     return;
   }
   web_contents()->GetMainFrame()->ExecuteJavaScript(base::UTF8ToUTF16(buffer_));
   buffer_.clear();
 }
 
+class DomDistillerViewerSource::PrintPreviewRequestViewerHandle

[cjhopman, 2015/05/20 02:00:02]

We probably don't want any printpreview-specific stuff in here. We'll need to
figure out a way to inject the things that you want to have different from
reader mode.

Things that are different in this change:

css (what parts?)
html (what parts?)
ignore theme changes
ignore font changes
no incremental loading

[arjunpatel, 2015/05/26 21:40:44]

We've been investigating how to remove the print preview specific
code here, but have had some issues. The main problem is that the
existing distiller UI is asynchronous. Distilled content is loaded
by executing JavaScript and filling out the empty content div. For
the case of the print preview, we need to know when to actually
generate the print preview PDF. We either need to fill out the content
synchronously during initial document load (current approach) or
to somehow signal to the HiddenPrintPreview that the document is ready
to print.

It's unclear what method to use to signal that the document is ready to
print. The DOM Distiller code knows when the div is filled out, but
that information seems to be hidden within the abstraction. To use
the existing UI, we would need to write code to plumb this through
to the HiddenPrintPreview. Would that be okay?

+    : public DomDistillerViewerSource::RequestViewerHandle {
+ public:
+  explicit PrintPreviewRequestViewerHandle(
+      content::WebContents* web_contents,
+      const std::string& expected_scheme,
+      const std::string& expected_request_path,
+      scoped_ptr<ContentDataCallback> callback,
+      DistilledPagePrefs* distilled_page_prefs);
+  ~PrintPreviewRequestViewerHandle() override;
+
+  // ViewRequestDelegate implementation:
+  void OnArticleReady(const DistilledArticleProto* article_proto) override;
+  void OnArticleUpdated(ArticleDistillationUpdate article_update) override;
+
+ private:
+  // DistilledPagePrefs::Observer implementation:
+  void OnChangeFontFamily(
+      DistilledPagePrefs::FontFamily new_font_family) override;
+  void OnChangeTheme(DistilledPagePrefs::Theme new_theme) override;
+};
+
+DomDistillerViewerSource::
+        PrintPreviewRequestViewerHandle::PrintPreviewRequestViewerHandle(
+    content::WebContents* web_contents,
+    const std::string& expected_scheme,
+    const std::string& expected_request_path,
+    scoped_ptr<ContentDataCallback> callback,
+    DistilledPagePrefs* distilled_page_prefs)
+    : DomDistillerViewerSource::RequestViewerHandle(
+        web_contents,
+        expected_scheme,
+        expected_request_path,
+        callback.Pass(),
+        distilled_page_prefs) {
+}
+
+DomDistillerViewerSource::
+        PrintPreviewRequestViewerHandle::~PrintPreviewRequestViewerHandle() {
+}
+
+void DomDistillerViewerSource::PrintPreviewRequestViewerHandle::OnArticleReady(
+    const DistilledArticleProto* article_proto) {
+  std::string content = dom_distiller::viewer::GetUnsafePrintPreviewHtml(
+      article_proto,
+      distilled_page_prefs_->GetTheme(),
+      distilled_page_prefs_->GetFontFamily());
+  callback_->RunCallback(content);
+
+  // No need to hold on to the ViewerHandle now that distillation is complete.
+  viewer_handle_.reset();
+}
+
+void DomDistillerViewerSource::
+        PrintPreviewRequestViewerHandle::OnArticleUpdated(
+    ArticleDistillationUpdate article_update) {
+}
+
+void DomDistillerViewerSource::PrintPreviewRequestViewerHandle::OnChangeTheme(
+    DistilledPagePrefs::Theme new_theme) {
+}
+
+void DomDistillerViewerSource::
+        PrintPreviewRequestViewerHandle::OnChangeFontFamily(
+    DistilledPagePrefs::FontFamily new_font) {
+}
+
 DomDistillerViewerSource::DomDistillerViewerSource(
     DomDistillerServiceInterface* dom_distiller_service,
     const std::string& scheme,
     scoped_ptr<ExternalFeedbackReporter> external_reporter)
     : scheme_(scheme),
       dom_distiller_service_(dom_distiller_service),
       external_feedback_reporter_(external_reporter.Pass()) {
 }
 
 DomDistillerViewerSource::~DomDistillerViewerSource() {
@@ skipping 13 matching lines @@
   if (!render_frame_host) return;
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DCHECK(render_view_host);
   CHECK_EQ(0, render_view_host->GetEnabledBindings());
 
   if (kViewerCssPath == path) {
     std::string css = viewer::GetCss();
     callback.Run(base::RefCountedString::TakeString(&css));
     return;
+  } else if (kPrintPreviewViewerCssPath == path) {
+    std::string css = viewer::GetPrintPreviewCss();
+    callback.Run(base::RefCountedString::TakeString(&css));
+    return;
   } else if (kViewerJsPath == path) {
     std::string js = viewer::GetJavaScript();
     callback.Run(base::RefCountedString::TakeString(&js));
     return;
   } else if (kViewerViewOriginalPath == path) {
     content::RecordAction(base::UserMetricsAction("DomDistiller_ViewOriginal"));
     callback.Run(NULL);
     return;
   } else if (kFeedbackBad == path) {
     FeedbackReporter::ReportQuality(false);
     callback.Run(NULL);
     if (!external_feedback_reporter_)
       return;
     content::WebContents* contents =
         content::WebContents::FromRenderFrameHost(render_frame_host);
     external_feedback_reporter_->ReportExternalFeedback(
         contents, contents->GetURL(), false);
     return;
   } else if (kFeedbackGood == path) {
     FeedbackReporter::ReportQuality(true);
     callback.Run(NULL);
     return;
   }
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   DCHECK(web_contents);
-  // An empty |path| is invalid, but guard against it. If not empty, assume
-  // |path| starts with '?', which is stripped away.
+
   scoped_ptr<ContentDataCallback> data_callback(
       new ContentDataCallback(callback));
-  const std::string path_after_query_separator =
-      path.size() > 0 ? path.substr(1) : "";
-  RequestViewerHandle* request_viewer_handle = new RequestViewerHandle(
+  RequestViewerHandle* request_viewer_handle = NULL;
+  std::string print_prefix = "printing/";
+  if (path.compare(0, print_prefix.length(), print_prefix) == 0) {
+    const std::string path_after_query_separator =
+        path.substr(print_prefix.length() + 1);
+    request_viewer_handle = new PrintPreviewRequestViewerHandle(
       web_contents, scheme_, path_after_query_separator, data_callback.Pass(),
       dom_distiller_service_->GetDistilledPagePrefs());
+
+  } else {
+    // An empty |path| is invalid, but guard against it. If not empty, assume
+    // |path| starts with '?', which is stripped away.
+    const std::string path_after_query_separator =
+        path.size() > 0 ? path.substr(1) : "";
+    request_viewer_handle = new RequestViewerHandle(
+        web_contents, scheme_, path_after_query_separator, data_callback.Pass(),
+        dom_distiller_service_->GetDistilledPagePrefs());
+  }
+
   scoped_ptr<ViewerHandle> viewer_handle = viewer::CreateViewRequest(
       dom_distiller_service_, path, request_viewer_handle,
       web_contents->GetContainerBounds().size());
 
   if (viewer_handle) {
     // The service returned a |ViewerHandle| and guarantees it will call
     // the |RequestViewerHandle|, so passing ownership to it, to ensure the
     // request is not cancelled. The |RequestViewerHandle| will delete itself
     // after receiving the callback.
     request_viewer_handle->TakeViewerHandle(viewer_handle.Pass());
@@ skipping 27 matching lines @@
 std::string DomDistillerViewerSource::GetContentSecurityPolicyObjectSrc()
     const {
   return "object-src 'none'; style-src 'self' https://fonts.googleapis.com;";
 }
 
 std::string DomDistillerViewerSource::GetContentSecurityPolicyFrameSrc() const {
   return "frame-src *;";
 }
 
 }  // namespace dom_distiller