When printing a PDF, query and use the print scaling disabled option.

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/command_line.h"
 #include "base/logging.h"
@@ skipping 134 matching lines @@
                                  print_params.desired_dpi));
 }
 
 bool PrintingNodeOrPdfFrame(const WebFrame* frame, const WebNode& node) {
   if (!node.isNull())
     return true;
   std::string mime(frame->dataSource()->response().mimeType().utf8());
   return mime == "application/pdf";
 }
 
-void SetMarginsForPdf(DictionaryValue* job_settings, bool force_no_margins) {
-  // TODO(vandebo) When it's plumbed through, check if the plugin wants us to
-  // scale or not.  For now, assume the answer is yes.
-  if (force_no_margins) {
-    job_settings->SetInteger(printing::kSettingMarginsType,
-                             printing::NO_MARGINS);
-  } else {
-    job_settings->SetInteger(printing::kSettingMarginsType,
-                             printing::PRINTABLE_AREA_MARGINS);
-  }
-
+printing::MarginType GetMarginsForPdf(WebFrame* frame, const WebNode& node) {
+  if (frame->isPrintScalingDisabledForPlugin(node))
+    return printing::NO_MARGINS;
+  else
+    return printing::PRINTABLE_AREA_MARGINS;
 }
 
 // Get the (x, y) coordinate from where printing of the current text should
 // start depending on the horizontal alignment (LEFT, RIGHT, CENTER) and
 // vertical alignment (TOP, BOTTOM).
 SkPoint GetHeaderFooterPosition(
     float webkit_scale_factor,
     const PageSizeMargins& page_layout,
     printing::HorizontalHeaderFooterPosition horizontal_position,
     printing::VerticalHeaderFooterPosition vertical_position,
@@ skipping 261 matching lines @@
     web_view_->resize(prev_view_size_);
     if (WebFrame* web_frame = web_view_->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
 }
 
 PrintWebViewHelper::PrintWebViewHelper(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       print_web_view_(NULL),
-      is_preview_(switches::IsPrintPreviewEnabled()),
+      is_preview_enabled_(switches::IsPrintPreviewEnabled()),
       is_print_ready_metafile_sent_(false),
       user_cancelled_scripted_print_count_(0),
       notify_browser_of_print_failure_(true) {
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(WebKit::WebFrame* frame) {
   DCHECK(frame);
 
   // Allow Prerendering to cancel this print request if necessary.
   if (prerender::PrerenderHelper::IsPrerendering(render_view())) {
     Send(new ChromeViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
 
   if (IsScriptInitiatedPrintTooFrequent(frame))
     return;
   IncrementScriptedPrintCount();
 
-  if (is_preview_) {
+  if (is_preview_enabled_) {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview();
   } else {
     Print(frame, WebNode());
   }
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintNodeUnderContextMenu,
                         OnPrintNodeUnderContextMenu)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForPrintPreview, OnPrintForPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintingDone, OnPrintingDone)
     IPC_MESSAGE_HANDLER(PrintMsg_ResetScriptedPrintCount,
                         ResetScriptedPrintCount)
     IPC_MESSAGE_HANDLER(PrintMsg_PreviewPrintingRequestCancelled,
                         DisplayPrintJobError)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PrintWebViewHelper::OnPrintForPrintPreview(
     const DictionaryValue& job_settings) {
-  DCHECK(is_preview_);
+  DCHECK(is_preview_enabled_);
   // If still not finished with earlier print request simply ignore.
   if (print_web_view_)
     return;
 
   if (!render_view()->GetWebView())
     return;
   WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (!main_frame)
     return;
 
   WebDocument document = main_frame->document();
   // <object> with id="pdf-viewer" is created in
   // chrome/browser/resources/print_preview/print_preview.js
   WebElement pdf_element = document.getElementById("pdf-viewer");
   if (pdf_element.isNull()) {
     NOTREACHED();
     return;
   }
 
   WebFrame* pdf_frame = pdf_element.document().frame();
-  if (!UpdatePrintSettings(pdf_frame, pdf_element, job_settings, false)) {
+  if (!UpdatePrintSettings(pdf_frame, pdf_element, job_settings, true)) {
     LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   scoped_ptr<PrepareFrameAndViewForPrint> prepare;
   prepare.reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                 pdf_frame, pdf_element));
   UpdatePrintableSizeInPrintParameters(pdf_frame, pdf_element, prepare.get(),
                                        &print_pages_params_->params);
@@ skipping 29 matching lines @@
   WebFrame* frame = print_preview_context_.frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
 
   Print(frame, print_preview_context_.node());
 }
 
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
-  DCHECK(is_preview_);
+  DCHECK(is_preview_enabled_);
   print_preview_context_.OnPrintPreview();
 
   if (!UpdatePrintSettings(print_preview_context_.frame(),
-                           print_preview_context_.node(), settings, true)) {
+                           print_preview_context_.node(), settings, false)) {
     if (print_preview_context_.last_error() != PREVIEW_ERROR_BAD_SETTING) {
       Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
           routing_id(), print_pages_params_->params.document_cookie));
       notify_browser_of_print_failure_ = false;  // Already sent.
     }
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (!print_pages_params_->params.is_first_request &&
@@ skipping 124 matching lines @@
 
 void PrintWebViewHelper::OnPrintNodeUnderContextMenu() {
   const WebNode& context_menu_node = render_view()->GetContextMenuNode();
   if (context_menu_node.isNull()) {
     NOTREACHED();
     return;
   }
 
   // Make a copy of the node, in case RenderView::OnContextMenuClosed resets
   // its |context_menu_node_|.
-  if (is_preview_) {
+  if (is_preview_enabled_) {
     print_preview_context_.InitWithNode(context_menu_node);
     RequestPrintPreview();
   } else {
     WebNode duplicate_node(context_menu_node);
     Print(duplicate_node.document().frame(), duplicate_node);
   }
 }
 
 void PrintWebViewHelper::OnInitiatePrintPreview() {
-  DCHECK(is_preview_);
+  DCHECK(is_preview_enabled_);
   WebFrame* frame;
   if (GetPrintFrame(&frame)) {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview();
   }
 }
 
 void PrintWebViewHelper::Print(WebKit::WebFrame* frame,
                                const WebKit::WebNode& node) {
   // If still not finished with earlier print request simply ignore.
@@ skipping 18 matching lines @@
   // show UI and wait for the user.
   prepare.reset();
 
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
-  if (!GetPrintSettingsFromUser(frame, expected_page_count,
+  if (!GetPrintSettingsFromUser(frame, node, expected_page_count,
                                 use_browser_overlays)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame, node, NULL)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   ResetScriptedPrintCount();
 }
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   bool store_print_pages_params = true;
   if (result == FAIL_PRINT) {
     DisplayPrintJobError();
 
     if (notify_browser_of_print_failure_ && print_pages_params_.get()) {
       int cookie = print_pages_params_->params.document_cookie;
       Send(new PrintHostMsg_PrintingFailed(routing_id(), cookie));
     }
   } else if (result == FAIL_PREVIEW) {
-    DCHECK(is_preview_);
+    DCHECK(is_preview_enabled_);
     store_print_pages_params = false;
     int cookie = print_pages_params_.get() ?
                      print_pages_params_->params.document_cookie : 0;
     if (notify_browser_of_print_failure_)
       Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
     else
       Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
     print_preview_context_.Failed(notify_browser_of_print_failure_);
   }
 
@@ skipping 235 matching lines @@
                                                  frame, node));
   UpdatePrintableSizeInPrintParameters(frame, node, prepare->get(),
                                        &print_pages_params_->params);
   Send(new PrintHostMsg_DidGetDocumentCookie(
         routing_id(), print_pages_params_->params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
     WebKit::WebFrame* frame, const WebKit::WebNode& node,
-    const DictionaryValue& passed_job_settings, bool generating_preview) {
-  DCHECK(is_preview_);
+    const DictionaryValue& passed_job_settings, bool print_for_preview) {
+  DCHECK(is_preview_enabled_);
   const DictionaryValue* job_settings = &passed_job_settings;
   DictionaryValue modified_job_settings;
   if (job_settings->empty()) {
-    if (generating_preview)
+    if (!print_for_preview)
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
-  bool is_pdf = PrintingNodeOrPdfFrame(frame, node);
-  if (is_pdf || !generating_preview) {
+  bool source_is_html = true;
+  if (print_for_preview) {
+      if (!job_settings->GetBoolean(printing::kSettingPreviewModifiable,

[kmadhusu, 2011/10/17 17:09:33]

nit: Fix indentation

[vandebo (ex-Chrome), 2011/10/17 17:34:35]

Done.

+                                    &source_is_html)) {
+          NOTREACHED();
+      }
+  } else {
+    source_is_html = !PrintingNodeOrPdfFrame(frame, node);
+  }
+
+  if (print_for_preview || !source_is_html) {
     modified_job_settings.MergeDictionary(job_settings);
-    SetMarginsForPdf(&modified_job_settings, !generating_preview);
-    if (is_pdf) {
-      modified_job_settings.SetBoolean(printing::kSettingHeaderFooterEnabled,
-                                       false);
-    }
+    modified_job_settings.SetBoolean(printing::kSettingHeaderFooterEnabled,
+                                     false);
+
+    // - On Windows, we don't add a margin until we turn it into an EMF when
+    //   printing for print preview (We could add it in the plugin).
+    // - On Mac with Skia, we don't add a margin until we send it to the printer
+    //   using the CG PDF class (We could add it in the plugin).
+    // - On Mac with CG, we can add a margin when generating the preview.
+    // - On Linux, we never add a margin (We Could add it in the plugin).
+#if defined(OS_MACOSX) && !defined(USE_SKIA)
+    bool get_margins_from_pdf = !source_is_html && !print_for_preview;
+#elif defined(OS_WIN) || defined(OS_MACOSX)
+    bool get_margins_from_pdf = !source_is_html && print_for_preview;
+#else
+    bool get_margins_from_pdf = false;
+#endif
+
+    printing::MarginType margin_type = printing::NO_MARGINS;
+    if (get_margins_from_pdf)
+      margin_type = GetMarginsForPdf(frame, node);
+    modified_job_settings.SetInteger(printing::kSettingMarginsType,
+                                     margin_type);
     job_settings = &modified_job_settings;
   }
 
   // Send the cookie so that UpdatePrintSettings can reuse PrinterQuery when
   // possible.
   int cookie = print_pages_params_.get() ?
       print_pages_params_->params.document_cookie : 0;
   PrintMsg_PrintPages_Params settings;
   Send(new PrintHostMsg_UpdatePrintSettings(routing_id(),
       cookie, *job_settings, &settings));
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
 
   if (PrintMsg_Print_Params_IsEmpty(settings.params)) {
-    if (generating_preview) {
+    if (!print_for_preview) {
       print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
     } else {
       WebKit::WebFrame* frame = print_preview_context_.frame();
       if (!frame) {
         GetPrintFrame(&frame);
       }
       if (frame) {
         render_view()->RunModalAlertDialog(
             frame,
             l10n_util::GetStringUTF16(
                 IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
       }
     }
     return false;
   }
 
   if (settings.params.dpi < kMinDpi || !settings.params.document_cookie) {
     print_preview_context_.set_error(PREVIEW_ERROR_UPDATING_PRINT_SETTINGS);
     return false;
   }
 
-  if (generating_preview) {
+  if (!print_for_preview) {
     // Validate expected print preview settings.
     if (!job_settings->GetString(printing::kPreviewUIAddr,
                                  &(settings.params.preview_ui_addr)) ||
         !job_settings->GetInteger(printing::kPreviewRequestID,
                                   &(settings.params.preview_request_id)) ||
         !job_settings->GetBoolean(printing::kIsFirstRequest,
                                   &(settings.params.is_first_request))) {
       NOTREACHED();
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
       return false;
@@ skipping 21 matching lines @@
     }
   }
 
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
                                              settings.params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::GetPrintSettingsFromUser(WebKit::WebFrame* frame,
+                                                  const WebKit::WebNode& node,
                                                   int expected_pages_count,
                                                   bool use_browser_overlays) {
   PrintHostMsg_ScriptedPrint_Params params;
   PrintMsg_PrintPages_Params print_settings;
 
   // The routing id is sent across as it is needed to look up the
   // corresponding RenderViewHost instance to signal and reset the
   // pump messages event.
   params.routing_id = render_view()->GetRoutingId();
   // host_window_ may be NULL at this point if the current window is a
   // popup and the print() command has been issued from the parent. The
   // receiver of this message has to deal with this.
   params.host_window_id = render_view()->GetHostWindow();
   params.cookie = print_pages_params_->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
-  params.margin_type = printing::DEFAULT_MARGINS;
+  printing::MarginType margin_type = printing::DEFAULT_MARGINS;
+  if (PrintingNodeOrPdfFrame(frame, node))
+    margin_type = GetMarginsForPdf(frame, node);
+  params.margin_type = margin_type;
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
   print_pages_params_.reset();
   IPC::SyncMessage* msg =
       new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
   msg->EnableMessagePumping();
   Send(msg);
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
   return (print_settings.params.dpi && print_settings.params.document_cookie);
@@ skipping 154 matching lines @@
       error_(PREVIEW_ERROR_NONE),
       state_(UNINITIALIZED) {
 }
 
 PrintWebViewHelper::PrintPreviewContext::~PrintPreviewContext() {
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
     WebKit::WebFrame* web_frame) {
   DCHECK(web_frame);
+  DCHECK(!IsRendering());
   state_ = INITIALIZED;
   frame_ = web_frame;
   node_.reset();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
     const WebKit::WebNode& web_node) {
   DCHECK(!web_node.isNull());
+  DCHECK(!IsRendering());
   state_ = INITIALIZED;
   frame_ = web_node.document().frame();
   node_ = web_node;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
-  DCHECK(IsReadyToRender());
+  DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
     PrintMsg_Print_Params* print_params,
     const std::vector<int>& pages) {
-  DCHECK(IsReadyToRender());
+  DCHECK_EQ(INITIALIZED, state_);
   state_ = RENDERING;
 
   print_params_.reset(new PrintMsg_Print_Params(*print_params));
 
   metafile_.reset(new printing::PreviewMetafile);
   if (!metafile_->Init()) {
     set_error(PREVIEW_ERROR_METAFILE_INIT_FAILED);
     LOG(ERROR) << "PreviewMetafile Init failed";
     return false;
   }
@@ skipping 45 matching lines @@
   UMA_HISTOGRAM_TIMES("PrintPreview.RenderPDFPageTime", page_time);
 }
 
 void PrintWebViewHelper::PrintPreviewContext::AllPagesRendered() {
   DCHECK_EQ(RENDERING, state_);
   state_ = DONE;
   prep_frame_view_->FinishPrinting();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::FinalizePrintReadyDocument() {
-  if (state_ != DONE && state_ != RENDERING)
-    NOTREACHED();
+  DCHECK(IsRendering());
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   metafile_->FinishDocument();
 
   if (print_ready_metafile_page_count_ <= 0) {
     NOTREACHED();
     return;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderToPDFTime",
                              document_render_time_);
   base::TimeDelta total_time = (base::TimeTicks::Now() - begin_time) +
                                document_render_time_;
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTime",
                              total_time);
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTimeAvgPerPage",
                              total_time / pages_to_render_.size());
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Finished() {
   DCHECK_EQ(DONE, state_);
+  state_ = INITIALIZED;
   ClearContext();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::Failed(bool report_error) {
   DCHECK(state_ == INITIALIZED || state_ == RENDERING);
   state_ = INITIALIZED;
   if (report_error) {
     DCHECK_NE(PREVIEW_ERROR_NONE, error_);
     UMA_HISTOGRAM_ENUMERATION("PrintPreview.RendererError", error_,
                               PREVIEW_ERROR_LAST_ENUM);
   }
   ClearContext();
 }
 
 int PrintWebViewHelper::PrintPreviewContext::GetNextPageNumber() {
   DCHECK_EQ(RENDERING, state_);
   if (IsFinalPageRendered())
     return -1;
   return pages_to_render_[current_page_index_++];
 }
 
-bool PrintWebViewHelper::PrintPreviewContext::IsReadyToRender() const {
-  return state_ != UNINITIALIZED;
+bool PrintWebViewHelper::PrintPreviewContext::IsRendering() const {
+  return state_ == RENDERING || state_ == DONE;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() const {
   // The only kind of node we can print right now is a PDF node.
   return !PrintingNodeOrPdfFrame(frame(), node());
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()
     const {
+  DCHECK(IsRendering());
   return current_page_index_ == print_ready_metafile_page_count_;
 }
 
 bool  PrintWebViewHelper::PrintPreviewContext::IsFinalPageRendered() const {
+  DCHECK(IsRendering());
   return static_cast<size_t>(current_page_index_) == pages_to_render_.size();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::set_generate_draft_pages(
     bool generate_draft_pages) {
+  DCHECK_EQ(INITIALIZED, state_);
   generate_draft_pages_ = generate_draft_pages;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::set_error(
     enum PrintPreviewErrorBuckets error) {
   error_ = error;
 }
 
 WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() const {
   return frame_;
 }
 
 const WebKit::WebNode& PrintWebViewHelper::PrintPreviewContext::node() const {
+  DCHECK(state_ != UNINITIALIZED);
   return node_;
 }
 
 int PrintWebViewHelper::PrintPreviewContext::total_page_count() const {
-  DCHECK(IsReadyToRender());
+  DCHECK(IsRendering());
   return total_page_count_;
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::generate_draft_pages() {
   return generate_draft_pages_;
 }
 
 printing::PreviewMetafile*
 PrintWebViewHelper::PrintPreviewContext::metafile() const {
+  DCHECK(IsRendering());
   return metafile_.get();
 }
 
 const PrintMsg_Print_Params&
 PrintWebViewHelper::PrintPreviewContext::print_params() const {
+  DCHECK(state_ != UNINITIALIZED);
   return *print_params_;
 }
 
 int PrintWebViewHelper::PrintPreviewContext::last_error() const {
   return error_;
 }
 
 const gfx::Size&
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
+  DCHECK(IsRendering());
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }