Print Preview: Hook up the print button to initiate printing without displaying a print dialog.

chrome/renderer/print_web_view_helper.cc

 // Copyright (c) 2011 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/print_web_view_helper.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/process_util.h"
@@ skipping 98 matching lines @@
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 void PrintWebViewHelper::PrintFrame(WebFrame* frame,
                                     bool script_initiated,
                                     bool is_preview) {
   Print(frame, NULL, script_initiated, is_preview);
 }
 
 void PrintWebViewHelper::PrintNode(WebNode* node,
                                    bool script_initiated,
-                                   bool is_preview) {
-  Print(node->document().frame(), node, script_initiated, is_preview);
+                                   bool is_preview,
+                                   bool is_print_for_print_preview) {
+  if (is_print_for_print_preview)
+    PrintForPrintPreview(node->document().frame(), node);
+  else
+    Print(node->document().frame(), node, script_initiated, is_preview);
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintForPrintPreview,
                         OnPrintForPrintPreview)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintingDone, OnPrintingDone)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintNodeUnderContextMenu,
                         OnPrintNodeUnderContextMenu)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void PrintWebViewHelper::OnPrintForPrintPreview() {
+void PrintWebViewHelper::OnPrintForPrintPreview(
+    const std::string& job_settings) {
+#if defined(OS_MACOSX)
   if (!render_view()->webview())
     return;
   WebFrame* main_frame = render_view()->webview()->mainFrame();
   if (!main_frame)
     return;
 
   WebDocument document = main_frame->document();
   // <object> with id="pdf-viewer" is created in
   // chrome/browser/resources/print_preview.js
   WebElement element = document.getElementById("pdf-viewer");
   if (element.isNull()) {
     NOTREACHED();
     return;
   }
 
-  PrintNode(&element, false, false);
+  InitPrintSettings(element.document().frame(), &element,
+                    PrintWebViewHelper::DEFAULT);
+  UpdatePrintSettings(job_settings);
+  PrintNode(&element, false, false, true);

[Lei Zhang, 2011/02/18 05:21:42]

Why change PrintNode()? Why not just call PrintForPrintPreview() directly?

[kmadhusu, 2011/02/21 01:30:26]

Fixed.

+#endif
 }
 
 void PrintWebViewHelper::OnPrint(bool is_preview) {
   DCHECK(render_view()->webview());
   if (!render_view()->webview())
     return;
 
   // If the user has selected text in the currently focused frame we print
   // only that frame (this makes print selection work for multiple frames).
   if (render_view()->webview()->focusedFrame()->hasSelection())
@@ skipping 18 matching lines @@
 
 void PrintWebViewHelper::OnPrintNodeUnderContextMenu() {
   if (render_view()->context_menu_node().isNull()) {
     NOTREACHED();
     return;
   }
 
   // Make a copy of the node, since we will do a sync call to the browser and
   // during that time OnContextMenuClosed might reset context_menu_node_.
   WebNode context_menu_node(render_view()->context_menu_node());
-  PrintNode(&context_menu_node, false, false);
+  PrintNode(&context_menu_node, false, false, false);
+}
+
+void PrintWebViewHelper::PrintForPrintPreview(WebKit::WebFrame* frame,
+                                              WebNode* node) {
+  // If still not finished with earlier print request simply ignore.
+  if (print_web_view_)
+    return;
+
+  // Initialize print params with current print settings.
+  if (!InitPrintSettings(frame, node, PrintWebViewHelper::CURRENT)) {
+    NOTREACHED();
+    DidFinishPrinting(true); // Release all printing resources.
+    return;  // Failed to init print page settings.
+  }
+
+  // Render Pages for printing.
+  RenderPagesForPrint(frame, node);
 }
 
 void PrintWebViewHelper::Print(WebKit::WebFrame* frame,
                                WebNode* node,
                                bool script_initiated,
                                bool is_preview) {
   const int kMinSecondsToIgnoreJavascriptInitiatedPrint = 2;
   const int kMaxSecondsToIgnoreJavascriptInitiatedPrint = 2 * 60;  // 2 Minutes.
 
   // If still not finished with earlier print request simply ignore.
@@ skipping 18 matching lines @@
           WebConsoleMessage::LevelWarning,
           message));
       return;
     }
   }
 
   bool print_cancelled = false;
   is_preview_ = is_preview;
 
   // Initialize print settings.
-  if (!InitPrintSettings(frame, node))
+  if (!InitPrintSettings(frame, node, PrintWebViewHelper::DEFAULT))
     return;  // Failed to init print page settings.
 
   int expected_pages_count = 0;
   bool use_browser_overlays = true;
 
   // Prepare once to calculate the estimated page count.  This must be in
   // a scope for itself (see comments on PrepareFrameAndViewForPrint).
   {
     PrepareFrameAndViewForPrint prep_frame_view(
         (*print_pages_params_).params, frame, node, frame->view());
@@ skipping 235 matching lines @@
       static_cast<int>(ConvertUnitDouble(
           page_height_in_points, printing::kPointsPerInch, dpi)));
 
   params->margin_top = static_cast<int>(ConvertUnitDouble(
       margin_top_in_points, printing::kPointsPerInch, dpi));
   params->margin_left = static_cast<int>(ConvertUnitDouble(
       margin_left_in_points, printing::kPointsPerInch, dpi));
 }
 
 bool PrintWebViewHelper::InitPrintSettings(WebFrame* frame,
-                                           WebNode* node) {
+                                           WebNode* node,
+                                           GetSettingsParam setting_type) {
   ViewMsg_PrintPages_Params settings;
-  if (GetDefaultPrintSettings(frame, node, &settings.params)) {
+  if (GetPrintSettings(frame, node, setting_type, &settings.params)) {
     print_pages_params_.reset(new ViewMsg_PrintPages_Params(settings));
     print_pages_params_->pages.clear();
     return true;
   }
   return false;
 }
 
-bool PrintWebViewHelper::GetDefaultPrintSettings(
-    WebFrame* frame,
-    WebNode* node,
-    ViewMsg_Print_Params* params) {
-  if (!render_view()->Send(new ViewHostMsg_GetDefaultPrintSettings(
-          render_view()->routing_id(), params))) {
+bool PrintWebViewHelper::UpdatePrintSettings(const std::string& job_settings) {
+  ViewMsg_PrintPages_Params settings;
+  IPC::SyncMessage* msg = new ViewHostMsg_UpdatePrintSettings(
+      render_view()->routing_id(),
+      (*print_pages_params_).params.document_cookie,
+      job_settings, &settings.params);
+  if (!render_view()->Send(msg)) {
     NOTREACHED();
     return false;
   }
+  print_pages_params_.reset(new ViewMsg_PrintPages_Params(settings));
+  return true;
+}
+
+bool PrintWebViewHelper::GetPrintSettings(WebFrame* frame, WebNode* node,
+    GetSettingsParam setting_type, ViewMsg_Print_Params* params) {
+  IPC::SyncMessage* msg = NULL;
+  if (setting_type == CURRENT) {
+    msg = new ViewHostMsg_GetCurrentPrintSettings(render_view()->routing_id(),
+              (*print_pages_params_).params.document_cookie,
+              params);
+  } else {
+    msg = new ViewHostMsg_GetDefaultPrintSettings(render_view()->routing_id(),
+                                                  params);
+  }
+  if (!render_view()->Send(msg)) {
+    NOTREACHED();
+    return false;
+  }
   // Check if the printer returned any settings, if the settings is empty, we
   // can safely assume there are no printer drivers configured. So we safely
   // terminate.
   if (params->IsEmpty()) {
     render_view()->runModalAlertDialog(
         frame,
         l10n_util::GetStringUTF16(IDS_DEFAULT_PRINTER_NOT_FOUND_WARNING));
     return false;
   }
   if (!(params->dpi && params->document_cookie)) {
@@ skipping 81 matching lines @@
         shared_buf.GiveToProcess(base::GetCurrentProcessHandle(),
                                  shared_mem_handle);
         return true;
       }
     }
   }
   NOTREACHED();
   return false;
 }
 #endif