PrintPreview: Honor the print media page size and margin values.

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 91 matching lines @@
   return !params.document_cookie && !params.desired_dpi && !params.max_shrink &&
          !params.min_shrink && !params.dpi && params.printable_size.IsEmpty() &&
          !params.selection_only && params.page_size.IsEmpty() &&
          !params.margin_top && !params.margin_left &&
          !params.supports_alpha_blend;
 }
 
 bool PageLayoutIsEqual(const PrintMsg_PrintPages_Params& oldParams,
                        const PrintMsg_PrintPages_Params& newParams) {
   return oldParams.params.printable_size == newParams.params.printable_size &&
+         oldParams.params.printable_area == newParams.params.printable_area &&
          oldParams.params.page_size == newParams.params.page_size &&
          oldParams.params.margin_top == newParams.params.margin_top &&
          oldParams.params.margin_left == newParams.params.margin_left &&
          oldParams.params.desired_dpi == newParams.params.desired_dpi &&
          oldParams.params.dpi == newParams.params.dpi;
 }
 
 bool PrintMsg_Print_Params_IsEqual(
     const PrintMsg_PrintPages_Params& oldParams,
     const PrintMsg_PrintPages_Params& newParams) {
   return PageLayoutIsEqual(oldParams, newParams) &&
          oldParams.params.max_shrink == newParams.params.max_shrink &&
          oldParams.params.min_shrink == newParams.params.min_shrink &&
          oldParams.params.selection_only == newParams.params.selection_only &&
          oldParams.params.supports_alpha_blend ==
              newParams.params.supports_alpha_blend &&
          oldParams.pages.size() == newParams.pages.size() &&
+         oldParams.params.print_to_pdf == newParams.params.print_to_pdf &&
          oldParams.params.display_header_footer ==
              newParams.params.display_header_footer &&
          oldParams.params.date == newParams.params.date &&
          oldParams.params.title == newParams.params.title &&
          oldParams.params.url == newParams.params.url &&
          std::equal(oldParams.pages.begin(), oldParams.pages.end(),
              newParams.pages.begin());
 }
 
 void CalculatePrintCanvasSize(const PrintMsg_Print_Params& print_params,
                               gfx::Size* result) {
   int dpi = GetDPI(&print_params);
   result->set_width(ConvertUnit(print_params.printable_size.width(), dpi,
                                 print_params.desired_dpi));
 
   result->set_height(ConvertUnit(print_params.printable_size.height(), dpi,
                                  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";
 }
 
+bool PrintingFrameHasPageSizeStyle(WebFrame* frame) {
+  if (!frame)
+    return false;
+  return frame->hasCustomPageSizeStyle(0);
+}
+
 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).
@@ skipping 268 matching lines @@
       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_enabled_(switches::IsPrintPreviewEnabled()),
       is_print_ready_metafile_sent_(false),
+      ignore_frame_margins_css_(false),
+      fit_to_page_(true),
       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);
 
@@ skipping 100 matching lines @@
 void PrintWebViewHelper::OnPrintForSystemDialog() {
   WebFrame* frame = print_preview_context_.frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
 
   Print(frame, print_preview_context_.node());
 }
 
+void PrintWebViewHelper::UpdateFrameMarginsCssInfo(
+    const DictionaryValue& settings) {
+  int margins_type = 0;
+  if (!settings.GetInteger(printing::kSettingMarginsType, &margins_type))
+    margins_type = printing::DEFAULT_MARGINS;
+  ignore_frame_margins_css_ = margins_type != printing::DEFAULT_MARGINS;
+}
+
+bool PrintWebViewHelper::IsPrintToPdfRequested(
+    const DictionaryValue& job_settings) {
+  bool print_to_pdf = false;
+  if (!job_settings.GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf))
+    NOTREACHED();
+  return print_to_pdf;
+}
+
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
   DCHECK(is_preview_enabled_);
   print_preview_context_.OnPrintPreview();
 
   if (!UpdatePrintSettings(print_preview_context_.frame(),
                            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.
@@ skipping 40 matching lines @@
   } else {
     if (notify_browser_of_print_failure_)
       LOG(ERROR) << "CreatePreviewDocument failed";
     DidFinishPrinting(FAIL_PREVIEW);
   }
 }
 
 bool PrintWebViewHelper::CreatePreviewDocument() {
   PrintMsg_Print_Params print_params = print_pages_params_->params;
   const std::vector<int>& pages = print_pages_params_->pages;
-  if (!print_preview_context_.CreatePreviewDocument(&print_params, pages))
+  if (!print_preview_context_.CreatePreviewDocument(
+          &print_params, pages, ignore_frame_margins_css_,
+          fit_to_page_)) {
     return false;
+  }
+
+  PageSizeMargins default_page_layout;
+  GetPageSizeAndMarginsInPoints(print_preview_context_.frame(), 0, print_params,
+      ignore_frame_margins_css_, fit_to_page_, NULL, &default_page_layout);
+  if (!old_print_pages_params_.get() ||
+      !PageLayoutIsEqual(*old_print_pages_params_, *print_pages_params_)) {
+    bool has_page_size_style = PrintingFrameHasPageSizeStyle(
+        print_preview_context_.frame());
+    // Margins: Send default page layout to browser process.
+    Send(new PrintHostMsg_DidGetDefaultPageLayout(
+        routing_id(), default_page_layout, has_page_size_style));
+  }
+
   PrintHostMsg_DidGetPreviewPageCount_Params params;
   params.page_count = print_preview_context_.total_page_count();
   params.is_modifiable = print_preview_context_.IsModifiable();
   params.document_cookie = print_pages_params_->params.document_cookie;
   params.preview_request_id = print_pages_params_->params.preview_request_id;
   params.clear_preview_data = print_preview_context_.generate_draft_pages();
   Send(new PrintHostMsg_DidGetPreviewPageCount(routing_id(), params));
   if (CheckForCancel())
     return false;
 
@@ skipping 200 matching lines @@
   return true;
 }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
 bool PrintWebViewHelper::PrintPages(const PrintMsg_PrintPages_Params& params,
                                     WebFrame* frame,
                                     const WebNode& node) {
   PrintMsg_Print_Params print_params = params.params;
   PrepareFrameAndViewForPrint prep_frame_view(print_params, frame, node);
   UpdatePrintableSizeInPrintParameters(frame, node, &prep_frame_view,
-                                       &print_params);
+                                       print_params, ignore_frame_margins_css_,
+                                       fit_to_page_);
 
   int page_count = prep_frame_view.GetExpectedPageCount();
   if (!page_count)
     return false;
   Send(new PrintHostMsg_DidGetPrintedPagesCount(routing_id(),
                                                 print_params.document_cookie,
                                                 page_count));
 
   const gfx::Size& canvas_size = prep_frame_view.GetPrintCanvasSize();
   PrintMsg_PrintPage_Params page_params;
@@ skipping 15 matching lines @@
 }
 #endif  // OS_MACOSX || OS_WIN
 
 void PrintWebViewHelper::didStopLoading() {
   PrintMsg_PrintPages_Params* params = print_pages_params_.get();
   DCHECK(params != NULL);
   PrintPages(*params, print_web_view_->mainFrame(), WebNode());
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::GetPageSizeAndMarginsInPoints(

[vandebo (ex-Chrome), 2011/12/04 22:20:34]

The variable names in this method get confusing because in one case we're just
updating the values based on a different information source, where as in the
other case we're ignore the other information source's literal values, but using
it to calculate third values.  I wonder if it would make sense to basically
leave this method alone and to create a different method
"FitCssPageSizeAndMarginsToPaperSize()" or something like that, that would take
two PrintMsg_Print_Params - one for the physical page parameters and one for the
CSS parameters.  You would then just call that new function that you've already
modified to call this method with new parameters. In some of them, you might not
need to call the new method, if you know that it's only used in the native flow.

[kmadhusu, 2011/12/05 09:06:54]

Done.

     WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& default_params,
+    bool ignore_frame_margins_css,
+    bool fit_to_page,
+    double* scale_factor,
     PageSizeMargins* page_layout_in_points) {
   int dpi = GetDPI(&default_params);
 
   WebSize page_size_in_pixels(
       ConvertUnit(default_params.page_size.width(),
                   dpi, printing::kPixelsPerInch),
       ConvertUnit(default_params.page_size.height(),
                   dpi, printing::kPixelsPerInch));
   int margin_top_in_pixels = ConvertUnit(
       default_params.margin_top,
       dpi, printing::kPixelsPerInch);
   int margin_right_in_pixels = ConvertUnit(
       default_params.page_size.width() -
       default_params.printable_size.width() - default_params.margin_left,
       dpi, printing::kPixelsPerInch);
   int margin_bottom_in_pixels = ConvertUnit(
       default_params.page_size.height() -
       default_params.printable_size.height() - default_params.margin_top,
       dpi, printing::kPixelsPerInch);
   int margin_left_in_pixels = ConvertUnit(
       default_params.margin_left,
       dpi, printing::kPixelsPerInch);
 
-  if (frame) {
+  if (frame && !(ignore_frame_margins_css && fit_to_page)) {
+    int old_margin_top_in_pixels = margin_top_in_pixels;
+    int old_margin_bottom_in_pixels = margin_bottom_in_pixels;
+    int old_margin_left_in_pixels = margin_left_in_pixels;
+    int old_margin_right_in_pixels = margin_right_in_pixels;
+
     frame->pageSizeAndMarginsInPixels(page_index,
                                       page_size_in_pixels,
                                       margin_top_in_pixels,
                                       margin_right_in_pixels,
                                       margin_bottom_in_pixels,
                                       margin_left_in_pixels);
+    if (ignore_frame_margins_css) {
+      margin_top_in_pixels = old_margin_top_in_pixels;
+      margin_bottom_in_pixels = old_margin_bottom_in_pixels;
+      margin_left_in_pixels = old_margin_left_in_pixels;
+      margin_right_in_pixels = old_margin_right_in_pixels;
+    }
   }
 
-  page_layout_in_points->content_width =
+  double new_content_width =
       ConvertPixelsToPoint(page_size_in_pixels.width -
-                           margin_left_in_pixels -
-                           margin_right_in_pixels);
-  page_layout_in_points->content_height =
+                           margin_left_in_pixels - margin_right_in_pixels);

[vandebo (ex-Chrome), 2011/12/04 22:20:34]

When we are ignoring the css margins, I think these margins
(margin_left_in_pixels, etc) are based on the full page size, not the css page
size, right?  Maybe you don't want to do this step when we're ignoring the css
margins, I'm not sure?

[kmadhusu, 2011/12/05 09:06:54]

Done. 

When the selected printer is "PRINT_TO_PDF", we don't have the physical paper
size information. Therefore, there is no "MINIMUM" margins. We should disable
the minimum margins option. 
 

+  double new_content_height =
       ConvertPixelsToPoint(page_size_in_pixels.height -
-                           margin_top_in_pixels -
-                           margin_bottom_in_pixels);
+                           margin_top_in_pixels - margin_bottom_in_pixels);
+  double new_page_box_width =
+      ConvertPixelsToPoint(page_size_in_pixels.width);
+  double new_page_box_height=
+      ConvertPixelsToPoint(page_size_in_pixels.height);
+
+  double default_page_size_height =
+      ConvertUnit(default_params.page_size.height(), dpi,
+                  printing::kPointsPerInch);
+  double default_page_size_width =
+      ConvertUnit(default_params.page_size.width(), dpi,
+                  printing::kPointsPerInch);
 
   // Invalid page size and/or margins. We just use the default setting.
-  if (page_layout_in_points->content_width < 1.0 ||
-      page_layout_in_points->content_height < 1.0) {
+  if (new_content_width < 1.0 || new_content_height < 1.0) {
     CHECK(frame != NULL);
-    GetPageSizeAndMarginsInPoints(NULL, page_index, default_params,
-                                  page_layout_in_points);
+    GetPageSizeAndMarginsInPoints(NULL, page_index, default_params, false,
+                                  false, NULL, page_layout_in_points);
     return;
   }
+  double margin_top_in_points =
+      ConvertPixelsToPointDouble(margin_top_in_pixels);
+  double margin_right_in_points =
+      ConvertPixelsToPointDouble(margin_right_in_pixels);
+  double margin_left_in_points =
+      ConvertPixelsToPointDouble(margin_left_in_pixels);
+  double margin_bottom_in_points =
+      ConvertPixelsToPointDouble(margin_bottom_in_pixels);
 
-    page_layout_in_points->margin_top =
-        ConvertPixelsToPointDouble(margin_top_in_pixels);
-    page_layout_in_points->margin_right =
-        ConvertPixelsToPointDouble(margin_right_in_pixels);
-    page_layout_in_points->margin_bottom =
-        ConvertPixelsToPointDouble(margin_bottom_in_pixels);
-    page_layout_in_points->margin_left =
-        ConvertPixelsToPointDouble(margin_left_in_pixels);
+  if (fit_to_page && (default_page_size_height != new_page_box_height ||
+      default_page_size_width != new_page_box_width)) {
+    double factor = 1.0f;
+    if (default_page_size_width < new_page_box_width ||
+        default_page_size_height < new_page_box_height) {
+      double minimum_printable_width =
+          ConvertUnit(default_params.printable_area.width(), dpi,
+                      printing::kPointsPerInch);
+      double minimum_printable_height =
+          ConvertUnit(default_params.printable_area.height(), dpi,
+                      printing::kPointsPerInch);
+      double ratio_width = minimum_printable_width / new_page_box_width;
+      double ratio_height = minimum_printable_height / new_page_box_height;
+      factor = ratio_width < ratio_height ? ratio_width : ratio_height;
+      if (scale_factor)
+        *scale_factor = factor;
+
+      new_content_width *= factor;
+      new_content_height *= factor;
+    }
+    margin_top_in_points =
+        (default_page_size_height - new_page_box_height * factor)/2  +
+        (margin_top_in_points * factor);
+    margin_bottom_in_points =
+        (default_page_size_height - new_page_box_height * factor)/2  +
+        (margin_bottom_in_points * factor);
+    margin_right_in_points =
+        (default_page_size_width - new_page_box_width * factor)/2  +
+        (margin_right_in_points * factor);
+    margin_left_in_points =
+        (default_page_size_width - new_page_box_width * factor)/2  +
+        (margin_left_in_points * factor);
+  }
+  page_layout_in_points->content_width = new_content_width;
+  page_layout_in_points->content_height = new_content_height;
+  page_layout_in_points->margin_top = margin_top_in_points;
+  page_layout_in_points->margin_right = margin_right_in_points;
+  page_layout_in_points->margin_bottom = margin_bottom_in_points;
+  page_layout_in_points->margin_left = margin_left_in_points;
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::UpdatePrintableSizeInPrintParameters(
     WebFrame* frame,
     const WebNode& node,
     PrepareFrameAndViewForPrint* prepare,
-    PrintMsg_Print_Params* params) {
+    const PrintMsg_Print_Params& params,
+    bool ignore_frame_margins_css,
+    bool fit_to_page) {
   if (PrintingNodeOrPdfFrame(frame, node))
     return;
   PageSizeMargins page_layout_in_points;
-  PrintWebViewHelper::GetPageSizeAndMarginsInPoints(frame, 0, *params,
-                                                    &page_layout_in_points);
-  int dpi = GetDPI(params);
-  params->printable_size = gfx::Size(
+  PrintMsg_Print_Params current_params = params;
+  PrintWebViewHelper::GetPageSizeAndMarginsInPoints(frame, 0, current_params,
+      ignore_frame_margins_css, false, NULL, &page_layout_in_points);
+  int dpi = GetDPI(&current_params);
+  current_params.printable_size = gfx::Size(
       static_cast<int>(ConvertUnitDouble(
           page_layout_in_points.content_width,
           printing::kPointsPerInch, dpi)),
       static_cast<int>(ConvertUnitDouble(
           page_layout_in_points.content_height,
           printing::kPointsPerInch, dpi)));
-
   double page_width_in_points =
       page_layout_in_points.content_width +
       page_layout_in_points.margin_left +
       page_layout_in_points.margin_right;
   double page_height_in_points =
       page_layout_in_points.content_height +
       page_layout_in_points.margin_top +
       page_layout_in_points.margin_bottom;
 
-  params->page_size = gfx::Size(
+  current_params.page_size = gfx::Size(
       static_cast<int>(ConvertUnitDouble(
           page_width_in_points, printing::kPointsPerInch, dpi)),
       static_cast<int>(ConvertUnitDouble(
           page_height_in_points, printing::kPointsPerInch, dpi)));
-
-  params->margin_top = static_cast<int>(ConvertUnitDouble(
-      page_layout_in_points.margin_top, printing::kPointsPerInch, dpi));
-  params->margin_left = static_cast<int>(ConvertUnitDouble(
+  current_params.margin_top =
+      static_cast<int>(ConvertUnitDouble(
+          page_layout_in_points.margin_top, printing::kPointsPerInch, dpi));
+  current_params.margin_left = static_cast<int>(ConvertUnitDouble(
       page_layout_in_points.margin_left, printing::kPointsPerInch, dpi));
-
-  prepare->UpdatePrintParams(*params);
+  prepare->UpdatePrintParams(current_params);
 }
 
 bool PrintWebViewHelper::InitPrintSettings(WebKit::WebFrame* frame,
                                            const WebKit::WebNode& node) {
   DCHECK(frame);
   PrintMsg_PrintPages_Params settings;
 
   Send(new PrintHostMsg_GetDefaultPrintSettings(routing_id(),
                                                 &settings.params));
   // Check if the printer returned any settings, if the settings is empty, we
@@ skipping 23 matching lines @@
 bool PrintWebViewHelper::InitPrintSettingsAndPrepareFrame(
     WebKit::WebFrame* frame, const WebKit::WebNode& node,
     scoped_ptr<PrepareFrameAndViewForPrint>* prepare) {
   if (!InitPrintSettings(frame, node))
     return false;
 
   DCHECK(!prepare->get());
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  frame, node));
   UpdatePrintableSizeInPrintParameters(frame, node, prepare->get(),
-                                       &print_pages_params_->params);
+                                       print_pages_params_->params,
+                                       ignore_frame_margins_css_,
+                                       fit_to_page_);
   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 print_for_preview) {
   DCHECK(is_preview_enabled_);
   const DictionaryValue* job_settings = &passed_job_settings;
@@ skipping 80 matching lines @@
                                  &(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;
     }
 
-    // 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));
-    }
+    settings.params.print_to_pdf = IsPrintToPdfRequested(*job_settings);
+    UpdateFrameMarginsCssInfo(*job_settings);
+    fit_to_page_ = source_is_html && !IsPrintToPdfRequested(*job_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);
@@ skipping 217 matching lines @@
   node_ = web_node;
 }
 
 void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
     PrintMsg_Print_Params* print_params,
-    const std::vector<int>& pages) {
+    const std::vector<int>& pages,
+    bool ignore_frame_margins_css,
+    bool fit_to_page) {
   DCHECK_EQ(INITIALIZED, state_);
   state_ = RENDERING;
 
   metafile_.reset(new printing::PreviewMetafile);
   if (!metafile_->Init()) {
     set_error(PREVIEW_ERROR_METAFILE_INIT_FAILED);
     LOG(ERROR) << "PreviewMetafile Init failed";
     return false;
   }
 
   // Need to make sure old object gets destroyed first.
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(*print_params, frame(),
                                                          node()));
   UpdatePrintableSizeInPrintParameters(frame_, node_,
-                                       prep_frame_view_.get(), print_params);
+                                       prep_frame_view_.get(), *print_params,
+                                       ignore_frame_margins_css,
+                                       fit_to_page);
 
   print_params_.reset(new PrintMsg_Print_Params(*print_params));
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
   if (total_page_count_ == 0) {
     LOG(ERROR) << "CreatePreviewDocument got 0 page count";
     set_error(PREVIEW_ERROR_ZERO_PAGES);
     return false;
   }
 
@@ skipping 155 matching lines @@
   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;
 }