Move margin processing code to the browser process.

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(PrintMsg_Print_Params* settings) {
-  // This is the wrong way to do this.  But the pipeline for the right way is
-  // too long.  This will be removed soon. http://crbug.com/92000
-  settings->margin_top = 0;
-  settings->margin_left = 0;
-  settings->printable_size.set_width(settings->page_size.width());
-  settings->printable_size.set_height(settings->page_size.height());
-}
-
-// Get the margins option selected and set custom margins appropriately.
-void SetCustomMarginsIfSelected(const DictionaryValue& job_settings,
-                                PrintMsg_PrintPages_Params* settings) {
-  int margin_type = printing::DEFAULT_MARGINS;
-  if (!job_settings.GetInteger(printing::kSettingMarginsType, &margin_type)) {
-    NOTREACHED();
+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);
   }
 
-  if (margin_type == printing::DEFAULT_MARGINS)
-    return;
-
-  double custom_margin_top_in_points = 0;
-  double custom_margin_left_in_points = 0;
-  double custom_margin_right_in_points = 0;
-  double custom_margin_bottom_in_points = 0;
-  if (margin_type == printing::CUSTOM_MARGINS) {
-    DictionaryValue* custom_margins;
-    if (!job_settings.GetDictionary(printing::kSettingMarginsCustom,
-                                    &custom_margins)) {
-      NOTREACHED();
-      return;
-    }
-    if (!custom_margins->GetDouble(printing::kSettingMarginTop,
-                                   &custom_margin_top_in_points) ||
-        !custom_margins->GetDouble(printing::kSettingMarginLeft,
-                                   &custom_margin_left_in_points) ||
-        !custom_margins->GetDouble(printing::kSettingMarginRight,
-                                   &custom_margin_right_in_points) ||
-        !custom_margins->GetDouble(printing::kSettingMarginBottom,
-                                   &custom_margin_bottom_in_points)) {
-      NOTREACHED();
-      return;
-    }
-  }
-
-  int dpi = GetDPI(&settings->params);
-  double custom_margin_top_in_dots = ConvertUnitDouble(
-      custom_margin_top_in_points, printing::kPointsPerInch, dpi);
-  double custom_margin_left_in_dots = ConvertUnitDouble(
-      custom_margin_left_in_points, printing::kPointsPerInch, dpi);
-  double custom_margin_right_in_dots = ConvertUnitDouble(
-      custom_margin_right_in_points, printing::kPointsPerInch, dpi);
-  double custom_margin_bottom_in_dots = ConvertUnitDouble(
-      custom_margin_bottom_in_points, printing::kPointsPerInch, dpi);
-
-
-  if (custom_margin_left_in_dots < 0 || custom_margin_right_in_dots < 0 ||
-      custom_margin_top_in_dots < 0 || custom_margin_bottom_in_dots < 0) {
-    NOTREACHED();
-    return;
-  }
-
-  if (settings->params.page_size.width() < custom_margin_left_in_dots +
-          custom_margin_right_in_dots ||
-      settings->params.page_size.height() < custom_margin_top_in_dots +
-          custom_margin_bottom_in_dots) {
-    NOTREACHED();
-    return;
-  }
-
-  settings->params.margin_top = custom_margin_top_in_dots;
-  settings->params.margin_left = custom_margin_left_in_dots;
-  settings->params.printable_size.set_width(
-      settings->params.page_size.width() - custom_margin_right_in_dots -
-          custom_margin_left_in_dots);
-  settings->params.printable_size.set_height(
-      settings->params.page_size.height() - custom_margin_bottom_in_dots -
-          custom_margin_top_in_dots);
 }
 
 // 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 333 matching lines @@
 
   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;
   }
 
-  if (!UpdatePrintSettings(job_settings, false)) {
+  WebFrame* pdf_frame = pdf_element.document().frame();
+  if (!UpdatePrintSettings(pdf_frame, pdf_element, job_settings, false)) {
     LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
-  WebFrame* pdf_frame = pdf_element.document().frame();
   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);
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(pdf_frame, pdf_element, prepare.get())) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
@@ skipping 27 matching lines @@
     return;
   }
 
   Print(frame, print_preview_context_.node());
 }
 
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
   DCHECK(is_preview_);
   print_preview_context_.OnPrintPreview();
 
-  if (!UpdatePrintSettings(settings, true)) {
+  if (!UpdatePrintSettings(print_preview_context_.frame(),
+                           print_preview_context_.node(), settings, true)) {
     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 452 matching lines @@
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  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(
-    const DictionaryValue& job_settings, bool generating_preview) {
-  if (job_settings.empty()) {
+    WebKit::WebFrame* frame, const WebKit::WebNode& node,
+    const DictionaryValue& passed_job_settings, bool generating_preview) {
+  DCHECK(is_preview_);
+  const DictionaryValue* job_settings = &passed_job_settings;
+  DictionaryValue modified_job_settings;
+  if (job_settings->empty()) {
     if (generating_preview)
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
+  bool is_pdf = PrintingNodeOrPdfFrame(frame, node);
+  if (is_pdf || !generating_preview) {
+    modified_job_settings.MergeDictionary(job_settings);
+    SetMarginsForPdf(&modified_job_settings, !generating_preview);
+    if (is_pdf) {
+      modified_job_settings.SetBoolean(printing::kSettingHeaderFooterEnabled,
+                                       false);
+    }
+    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));
+      cookie, *job_settings, &settings));
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
 
   if (PrintMsg_Print_Params_IsEmpty(settings.params)) {
     if (generating_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) {
     // 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))) {
+    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;
     }
 
-    if (settings.params.is_first_request &&
-        !print_preview_context_.IsModifiable()) {
-      settings.params.display_header_footer = false;
-    }
-
     // Margins: Send default page layout to browser process.
     PageSizeMargins default_page_layout;
     GetPageSizeAndMarginsInPoints(NULL, -1, settings.params,
                                   &default_page_layout);
     if (!old_print_pages_params_.get() ||
         !PageLayoutIsEqual(*old_print_pages_params_, settings)) {
       Send(new PrintHostMsg_DidGetDefaultPageLayout(routing_id(),
                                                     default_page_layout));
     }
-    SetCustomMarginsIfSelected(job_settings, &settings);
 
     // Header/Footer: Set |header_footer_info_|.
     if (settings.params.display_header_footer) {
       header_footer_info_.reset(new DictionaryValue());
       header_footer_info_->SetString(printing::kSettingHeaderFooterDate,
                                      settings.params.date);
       header_footer_info_->SetString(printing::kSettingHeaderFooterURL,
                                      settings.params.url);
       header_footer_info_->SetString(printing::kSettingHeaderFooterTitle,
                                      settings.params.title);
     }
   }
 
-  if ((is_preview_ && !generating_preview) ||
-      PrintingNodeOrPdfFrame(print_preview_context_.frame(),
-                             print_preview_context_.node())) {
-    SetMarginsForPDF(&settings.params);
-  }
-
   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,
                                                   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.use_overlays = use_browser_overlays;
+  params.margin_type = printing::DEFAULT_MARGINS;
 
   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 355 matching lines @@
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }