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 776 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;

[dgn, 2014/11/20 12:26:16]

That's how window.print() was disabled

-#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() {
   is_loading_ = true;
 }
 
 void PrintWebViewHelper::DidStopLoading() {
   is_loading_ = false;
   if (!on_stop_loading_closure_.is_null()) {
     on_stop_loading_closure_.Run();
     on_stop_loading_closure_.Reset();
   }
 }
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(blink::WebLocalFrame* frame,
                                    bool user_initiated) {
+
+  DLOG(INFO) << "DGN PrintPage - From Script - routing_id: " << routing_id();
+
   DCHECK(frame);
 
   // Allow Prerendering to cancel this print request if necessary.
   if (prerender::PrerenderHelper::IsPrerendering(
           render_view()->GetMainRenderFrame())) {
     Send(new ChromeViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
 
-  if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
+  if (!IsScriptInitiatedPrintAllowed(frame, user_initiated)) {
+    DLOG(INFO) << "DGN PrintPage - Script printing not allowed";
     return;
+  }
 
+#if defined(OS_ANDROID)
+  int cookie = 0;
+  if (!print_pages_params_) {
+    DLOG(INFO) << "DGN PrintPage - no print_pages_params_";
+  } else {
+    cookie = print_pages_params_->params.document_cookie;

[dgn, 2014/11/20 12:26:16]

how to properly initialize params? I currently always have 0 for cookie

+    DLOG(INFO) << "DGN PrintPage - print_pages_params_->params.document_cookie is " << cookie;
+  }
+
+  DLOG(INFO) << "DGN PrintPage - Sending InitiateAndroidPrint";
+  IPC::SyncMessage* msg = new PrintHostMsg_InitiateAndroidPrint(routing_id(), cookie);
+  msg->EnableMessagePumping();
+  Send(msg);

[dgn, 2014/11/20 12:26:16]

This is the where the renderer should wait until printing is completely done.
Currently it returns once android's printingmanager's initialization is done,
right before the dialog is shown

+  DLOG(INFO) << "DGN PrintPage - InitiateAndroidPrint returned";
+#else
   if (!g_is_preview_enabled_) {
     Print(frame, blink::WebNode());

[Vitaly Buka (NO REVIEWS), 2014/11/21 17:05:13]

it should go into Print(frame, blink::WebNode());

   } else {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
   }
+#endif
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
 #if defined(ENABLE_BASIC_PRINTING)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
 #endif  // ENABLE_BASIC_PRINTING
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
@@ skipping 87 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))
     Print(frame, blink::WebNode());
 }
 
 void PrintWebViewHelper::OnPrintForSystemDialog() {
   blink::WebLocalFrame* frame = print_preview_context_.source_frame();
   if (!frame) {
     NOTREACHED();
     return;
@@ skipping 278 matching lines @@
     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) {
   // 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,

[Vitaly Buka (NO REVIEWS), 2014/11/21 17:05:13]

this will set print_pages_params_

                                 expected_page_count)) {
     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) {
+  if (result == OK) DLOG(INFO) << "DGN DidFinishPrinting";
+  else DLOG(INFO) << "DGN DidFinishPrinting - Failure: " << result;
+
   switch (result) {
     case OK:
       break;
 
     case FAIL_PRINT_INIT:
       DCHECK(!notify_browser_of_print_failure_);
       break;
 
     case FAIL_PRINT:
       if (notify_browser_of_print_failure_ && print_pages_params_) {
@@ skipping 270 matching lines @@
   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