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 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";
 }
 
+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),
+      default_margins_requested_(false),

[vandebo (ex-Chrome), 2011/11/17 23:05:23]

Should this default to true?

[kmadhusu, 2011/12/01 02:15:42]

Done.

       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 61 matching lines @@
   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);
+                                       &print_pages_params_->params,
+                                       default_margins_requested_);
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(pdf_frame, pdf_element, prepare.get())) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
 }
 
 bool PrintWebViewHelper::GetPrintFrame(WebKit::WebFrame** frame) {
   DCHECK(frame);
@@ skipping 18 matching lines @@
 void PrintWebViewHelper::OnPrintForSystemDialog() {
   WebFrame* frame = print_preview_context_.frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
 
   Print(frame, print_preview_context_.node());
 }
 
+void PrintWebViewHelper::UpdateDefaultMarginsRequested(
+    const DictionaryValue& settings) {
+  int margins_type = 0;
+  if (!settings.GetInteger(printing::kSettingMarginsType, &margins_type))
+    margins_type = printing::DEFAULT_MARGINS;
+  default_margins_requested_ = margins_type == printing::DEFAULT_MARGINS;
+}
+
 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, default_margins_requested_)) {
     return false;
+  }
+
+  // Margins: Send default page layout to browser process.
+  PageSizeMargins default_page_layout;
+  GetPageSizeAndMarginsInPoints(print_preview_context_.frame(), 0, print_params,
+                                &default_page_layout,
+                                default_margins_requested_);
+  if (!old_print_pages_params_.get() ||
+      !PageLayoutIsEqual(*old_print_pages_params_, *print_pages_params_)) {
+    Send(new PrintHostMsg_DidGetDefaultPageLayout(routing_id(),
+                                                  default_page_layout));
+  }
+
   PrintHostMsg_DidGetPreviewPageCount_Params params;
   params.page_count = print_preview_context_.total_page_count();
   params.is_modifiable = print_preview_context_.IsModifiable();
+  params.has_page_size_style = PrintingFrameHasPageSizeStyle(

[vandebo (ex-Chrome), 2011/11/17 23:05:23]

If we ask for the page size and margins in GetPageSizeAndMargins, but then
ignore them because the result isn't valid, this will give the wrong value. 
Maybe we need to store some state for that case???

[kmadhusu, 2011/12/01 02:15:42]

(repeating our conversation for reference): This is a corner case and hence we
ignore it as of now. 

+      print_preview_context_.frame());
   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;
 
   while (!print_preview_context_.IsFinalPageRendered()) {
     int page_number = print_preview_context_.GetNextPageNumber();
     DCHECK_GE(page_number, 0);
@@ skipping 202 matching lines @@
                                     WebFrame* frame,
                                     const WebNode& node,
                                     PrepareFrameAndViewForPrint* prepare) {
   PrintMsg_Print_Params print_params = params.params;
   scoped_ptr<PrepareFrameAndViewForPrint> prep_frame_view;
   if (!prepare) {
     prep_frame_view.reset(new PrepareFrameAndViewForPrint(print_params, frame,
                                                           node));
     prepare = prep_frame_view.get();
   }
-  UpdatePrintableSizeInPrintParameters(frame, node, prepare, &print_params);
+  UpdatePrintableSizeInPrintParameters(frame, node, prepare, &print_params,
+                                       default_margins_requested_);
 
   int page_count = prepare->GetExpectedPageCount();
   if (!page_count)
     return false;
   Send(new PrintHostMsg_DidGetPrintedPagesCount(routing_id(),
                                                 print_params.document_cookie,
                                                 page_count));
 
   const gfx::Size& canvas_size = prepare->GetPrintCanvasSize();
   PrintMsg_PrintPage_Params page_params;
@@ skipping 19 matching lines @@
   PrintMsg_PrintPages_Params* params = print_pages_params_.get();
   DCHECK(params != NULL);
   PrintPages(*params, print_web_view_->mainFrame(), WebNode(), NULL);
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::GetPageSizeAndMarginsInPoints(
     WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& default_params,
-    PageSizeMargins* page_layout_in_points) {
+    PageSizeMargins* page_layout_in_points,
+    bool default_margins_requested) {
   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) {
     frame->pageSizeAndMarginsInPixels(page_index,
                                       page_size_in_pixels,
                                       margin_top_in_pixels,
                                       margin_right_in_pixels,
                                       margin_bottom_in_pixels,
-                                      margin_left_in_pixels);
+                                      margin_left_in_pixels,
+                                      default_margins_requested);

[vandebo (ex-Chrome), 2011/11/17 23:05:23]

It seems like modifying webkit would be a bit much for what you're tying to
accomplish.  This method is GetPageSizeAndMarginsInPoints.  Seems like you could
also have GetPageSizeInPoints (maybe with a common implmentation), which only
sets page size.

[kmadhusu, 2011/12/01 02:15:42]

As we discussed, I am not doing to modify |pageSizeAndMarginsInPixels| function.
Instead, I made changes to this function. 

   }
 
   page_layout_in_points->content_width =
       ConvertPixelsToPoint(page_size_in_pixels.width -
                            margin_left_in_pixels -
                            margin_right_in_pixels);
   page_layout_in_points->content_height =
       ConvertPixelsToPoint(page_size_in_pixels.height -
                            margin_top_in_pixels -
                            margin_bottom_in_pixels);
 
   // 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) {
     CHECK(frame != NULL);
     GetPageSizeAndMarginsInPoints(NULL, page_index, default_params,
-                                  page_layout_in_points);
+                                  page_layout_in_points, true);

[vandebo (ex-Chrome), 2011/11/17 23:05:23]

Seems like you could/should change default_margins_requested_ to true here, and
then you wouldn't need to pass it into GetPageSizeAndMarginsInPoints either,
just use the member variable.

[kmadhusu, 2011/12/01 02:15:42]

Done.

     return;
   }
 
     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);
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::UpdatePrintableSizeInPrintParameters(
     WebFrame* frame,
     const WebNode& node,
     PrepareFrameAndViewForPrint* prepare,
-    PrintMsg_Print_Params* params) {
+    PrintMsg_Print_Params* params,
+    bool default_margins_requested) {
   if (PrintingNodeOrPdfFrame(frame, node))
     return;
   PageSizeMargins page_layout_in_points;
   PrintWebViewHelper::GetPageSizeAndMarginsInPoints(frame, 0, *params,
-                                                    &page_layout_in_points);
+                                                    &page_layout_in_points,
+                                                    default_margins_requested);
   int dpi = GetDPI(params);
   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 =
@@ skipping 53 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,
+                                       default_margins_requested_);
   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 33 matching lines @@
     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;
   }
+  UpdateDefaultMarginsRequested(*job_settings);

[vandebo (ex-Chrome), 2011/11/17 23:05:23]

If you move default_margins_requested_ to PrintPreviewContext, you can do this
in PrintPreviewContext::OnPrintPreview.

[kmadhusu, 2011/12/01 02:15:42]

Having the member variable in PrintWebViewHelper, I can reuse it for the native
printing workflow. 

 
   // 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));
 
@@ skipping 27 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));
-    }
-
     // 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 default_margins_requested) {
   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,
+                                       default_margins_requested);
 
   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;
 }