Implement window.print() on Android

chrome/renderer/printing/print_web_view_helper.cc

 // Copyright (c) 2012 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 "chrome/renderer/printing/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 800 matching lines @@
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 // static
 void PrintWebViewHelper::DisablePreview() {
   g_is_preview_enabled_ = false;
 }
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
     blink::WebFrame* frame, bool user_initiated) {
-#if defined(OS_ANDROID)
-  return false;
-#endif  // defined(OS_ANDROID)
   // If preview is enabled, then the print dialog is tab modal, and the user
   // can always close the tab on a mis-behaving page (the system print dialog
   // is app modal). If the print was initiated through user action, don't
   // throttle. Or, if the command line flag to skip throttling has been set.
   return !is_scripted_printing_blocked_ &&
          (user_initiated || g_is_preview_enabled_ ||
           scripting_throttler_.IsAllowed(frame));
 }
 
 void PrintWebViewHelper::DidStartLoading() {
@@ skipping 17 matching lines @@
   if (prerender::PrerenderHelper::IsPrerendering(
           render_view()->GetMainRenderFrame())) {
     Send(new ChromeViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
 
   if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
     return;
 
   if (!g_is_preview_enabled_) {
-    Print(frame, blink::WebNode());
+    bool use_system_specific_flow = false;
+
+#if defined(OS_ANDROID)
+    use_system_specific_flow = true;
+#endif
+
+    Print(frame, blink::WebNode(), use_system_specific_flow);
   } else {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
   }
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
 #if defined(ENABLE_BASIC_PRINTING)
@@ skipping 89 matching lines @@
   blink::WebLocalFrame* focusedFrame =
       webView->focusedFrame()->toWebLocalFrame();
   *frame = focusedFrame->hasSelection()
                ? focusedFrame
                : webView->mainFrame()->toWebLocalFrame();
   return true;
 }
 
 #if defined(ENABLE_BASIC_PRINTING)
 void PrintWebViewHelper::OnPrintPages() {
+  DLOG(INFO) << "DGN - OnPrintPages - Call from PrintManager";
   blink::WebLocalFrame* frame;
   if (!GetPrintFrame(&frame))
     return;
   // If we are printing a PDF extension frame, find the plugin node and print
   // that instead.
   auto plugin = GetPdfElement(frame);
   Print(frame, plugin);
 }
 
 void PrintWebViewHelper::OnPrintForSystemDialog() {
@@ skipping 287 matching lines @@
     Print(duplicate_node.document().frame(), duplicate_node);
   } else {
     print_preview_context_.InitWithNode(node);
     RequestPrintPreview(PRINT_PREVIEW_USER_INITIATED_CONTEXT_NODE);
   }
 
   print_node_in_progress_ = false;
 }
 
 void PrintWebViewHelper::Print(blink::WebLocalFrame* frame,
-                               const blink::WebNode& node) {
+                               const blink::WebNode& node,
+                               const bool use_system_specific_flow) {
   // If still not finished with earlier print request simply ignore.
-  if (prep_frame_view_)
+  DLOG(INFO) << "DGN Print";
+
+  if (prep_frame_view_) {
+    DLOG(INFO) << "DGN Print request ignored";
     return;
+  }
 
   FrameReference frame_ref(frame);
 
   int expected_page_count = 0;
   if (!CalculateNumberOfPages(frame, node, &expected_page_count)) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
 
+  DLOG(INFO) << "DGN CalculateNumberOfPages OK";
+
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
   if (!GetPrintSettingsFromUser(frame_ref.GetFrame(), node,
-                                expected_page_count)) {
+                                expected_page_count,
+                                use_system_specific_flow)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
+  DLOG(INFO) << "DGN GetPrintSettingsFromUser OK";
+
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame_ref.GetFrame(), node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   scripting_throttler_.Reset();
 }
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   switch (result) {
@@ skipping 252 matching lines @@
       Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
 
     return false;
   }
 
   return true;
 }
 
 bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebFrame* frame,
                                                   const blink::WebNode& node,
-                                                  int expected_pages_count) {
+                                                  int expected_pages_count,
+                                                  const bool system_specific) {
   PrintHostMsg_ScriptedPrint_Params params;
   PrintMsg_PrintPages_Params print_settings;
 
   params.cookie = print_pages_params_->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
   MarginType margin_type = DEFAULT_MARGINS;
   if (PrintingNodeOrPdfFrame(frame, node))
     margin_type = GetMarginsForPdf(frame, node);
   params.margin_type = margin_type;
+  params.use_system_specific_flow = system_specific;
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
   // PrintHostMsg_ScriptedPrint will reset print_scaling_option, so we save the
   // value before and restore it afterwards.
   blink::WebPrintScalingOption scaling_option =
       print_pages_params_->params.print_scaling_option;
 
   print_pages_params_.reset();
   IPC::SyncMessage* msg =
       new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
   msg->EnableMessagePumping();
   Send(msg);
   print_settings.params.print_scaling_option = scaling_option;
   SetPrintPagesParams(print_settings);
   return (print_settings.params.dpi && print_settings.params.document_cookie);
 }
 
 bool PrintWebViewHelper::RenderPagesForPrint(blink::WebLocalFrame* frame,
                                              const blink::WebNode& node) {
   if (!frame || prep_frame_view_)
     return false;
+
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   const PrintMsg_Print_Params& print_params = params.params;
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(
       print_params, frame, node, ignore_css_margins_));
   DCHECK(!print_pages_params_->params.selection_only ||
          print_pages_params_->pages.empty());
   prep_frame_view_->CopySelectionIfNeeded(
       render_view()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPrintPages,
                  base::Unretained(this)));
@@ skipping 436 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing