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
+    : 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