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.content_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.content_size == newParams.params.content_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());
 }
 
+PrintMsg_Print_Params GetCssPrintParams(
+    WebFrame* frame,
+    int page_index,
+    const PrintMsg_Print_Params& default_params) {
+  PrintMsg_Print_Params page_css_params = default_params;
+  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.content_size.width() - default_params.margin_left,
+      dpi, printing::kPixelsPerInch);
+  int margin_bottom_in_pixels = ConvertUnit(
+      default_params.page_size.height() -
+      default_params.content_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);
+  }
+
+  int new_content_width = page_size_in_pixels.width -
+                          margin_left_in_pixels - margin_right_in_pixels;
+  int new_content_height = 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 (new_content_width < 1 || new_content_height < 1) {
+    CHECK(frame != NULL);
+    page_css_params = GetCssPrintParams(NULL, page_index, default_params);
+    return page_css_params;
+  }
+
+  page_css_params.content_size = gfx::Size(
+      static_cast<int>(ConvertUnit(new_content_width,
+          printing::kPixelsPerInch, dpi)),
+      static_cast<int>(ConvertUnit(new_content_height,
+          printing::kPixelsPerInch, dpi)));
+
+  page_css_params.page_size = gfx::Size(
+      static_cast<int>(ConvertUnit(page_size_in_pixels.width,
+          printing::kPixelsPerInch, dpi)),
+      static_cast<int>(ConvertUnit(page_size_in_pixels.height,
+          printing::kPixelsPerInch, dpi)));
+
+  page_css_params.margin_top =
+      static_cast<int>(ConvertUnit(margin_top_in_pixels,
+          printing::kPixelsPerInch, dpi));
+
+  page_css_params.margin_left =
+      static_cast<int>(ConvertUnit(margin_left_in_pixels,
+          printing::kPixelsPerInch, dpi));
+  return page_css_params;
+}
+
+double FitPrintParamsToPage(const PrintMsg_Print_Params& default_params,
+                            PrintMsg_Print_Params* page_css_params) {

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

nit: default_params -> page_params ?
nit: page_css_params -> params_to_fit or fit_params ?

[kmadhusu, 2012/01/09 17:15:55]

Done.

+  double content_width =
+      static_cast<double>(page_css_params->content_size.width());
+  double content_height =
+      static_cast<double>(page_css_params->content_size.height());
+  int default_page_size_height = default_params.page_size.height();
+  int default_page_size_width = default_params.page_size.width();
+  int css_page_size_height = page_css_params->page_size.height();
+  int css_page_size_width = page_css_params->page_size.width();
+
+  double scale_factor = 1.0f;
+  if (default_params.page_size == page_css_params->page_size)
+    return scale_factor;
+
+  if (default_page_size_width < css_page_size_width ||
+      default_page_size_height < css_page_size_height) {
+    double ratio_width =
+        static_cast<double>(default_params.printable_area.width()) /
+            css_page_size_width;
+    double ratio_height =
+        static_cast<double>(default_params.printable_area.height()) /
+            css_page_size_height;
+    scale_factor = ratio_width < ratio_height ? ratio_width : ratio_height;
+    content_width *= scale_factor;
+    content_height *= scale_factor;
+  }
+  page_css_params->margin_top = static_cast<int>(
+      (default_page_size_height - css_page_size_height * scale_factor) / 2 +
+      (page_css_params->margin_top * scale_factor));
+  page_css_params->margin_left = static_cast<int>(
+      (default_page_size_width - css_page_size_width * scale_factor) / 2 +
+      (page_css_params->margin_left * scale_factor));
+  page_css_params->content_size = gfx::Size(
+      static_cast<int>(content_width), static_cast<int>(content_height));
+  page_css_params->page_size = default_params.page_size;
+  return scale_factor;
+}
+
+void CalculatePageLayoutFromPrintParams(
+    const PrintMsg_Print_Params& page_css_params,
+    PageSizeMargins* page_layout_in_points) {
+  int dpi = GetDPI(&page_css_params);
+  int content_width = page_css_params.content_size.width();
+  int content_height = page_css_params.content_size.height();
+
+  int margin_bottom = page_css_params.page_size.height() -
+                      content_height - page_css_params.margin_top;
+  int margin_right = page_css_params.page_size.width() -
+                      content_width - page_css_params.margin_left;
+
+  page_layout_in_points->content_width = ConvertUnit(
+      content_width, dpi, printing::kPointsPerInch);
+  page_layout_in_points->content_height = ConvertUnit(
+      content_height, dpi, printing::kPointsPerInch);
+  page_layout_in_points->margin_top = ConvertUnit(
+      page_css_params.margin_top, dpi, printing::kPointsPerInch);
+  page_layout_in_points->margin_right = ConvertUnit(
+      margin_right, dpi, printing::kPointsPerInch);
+  page_layout_in_points->margin_bottom = ConvertUnit(
+      margin_bottom, dpi, printing::kPointsPerInch);
+  page_layout_in_points->margin_left = ConvertUnit(
+      page_css_params.margin_left, dpi, printing::kPointsPerInch);
+}
+
 void CalculatePrintCanvasSize(const PrintMsg_Print_Params& print_params,
                               gfx::Size* result) {
   int dpi = GetDPI(&print_params);
   result->set_width(ConvertUnit(print_params.content_size.width(), dpi,
                                 print_params.desired_dpi));
 
   result->set_height(ConvertUnit(print_params.content_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, int total_page_count) {
+  if (!frame)
+    return false;
+  bool frame_has_custom_page_size_style = false;
+  for (int i = 0; i < total_page_count; ++i) {
+    if (frame->hasCustomPageSizeStyle(i)) {
+      frame_has_custom_page_size_style = true;
+      break;
+    }
+  }
+  return frame_has_custom_page_size_style;
+}
+
 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_css_margins_(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::GetPageSizeAndContentAreaFromPageLayout(
+    const printing::PageSizeMargins& page_layout_in_points,
+    gfx::Size* page_size,
+    gfx::Rect* content_area) {
+  *page_size = gfx::Size(
+      page_layout_in_points.content_width +
+          page_layout_in_points.margin_right +
+          page_layout_in_points.margin_left,
+      page_layout_in_points.content_height +
+          page_layout_in_points.margin_top +
+          page_layout_in_points.margin_bottom);
+  *content_area = gfx::Rect(page_layout_in_points.margin_left,
+                            page_layout_in_points.margin_top,
+                            page_layout_in_points.content_width,
+                            page_layout_in_points.content_height);
+}
+
+void PrintWebViewHelper::UpdateFrameMarginsCssInfo(
+    const DictionaryValue& settings) {
+  int margins_type = 0;
+  if (!settings.GetInteger(printing::kSettingMarginsType, &margins_type))
+    margins_type = printing::DEFAULT_MARGINS;
+  ignore_css_margins_ = 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_css_margins_,
+                                                    fit_to_page_)) {
     return false;
+  }
+
+  PageSizeMargins default_page_layout;
+  ComputePageLayoutInPoints(print_preview_context_.frame(), 0, print_params,
+                            ignore_css_margins_, 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(),
+        print_preview_context_.total_page_count());
+    // 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 199 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);
+  UpdateFrameAndViewFromCssPageLayout(frame, node, &prep_frame_view,
+                                      print_params, ignore_css_margins_,
+                                      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 14 matching lines @@
   return true;
 }
 #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(
+PrintMsg_Print_Params CalculatePrintParams(

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

So when we have no CSS, this is a no-op, right?  Should we then call it
CalculatePrintParamsForCss?

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

Move this to the anonymous namespace.

[kmadhusu, 2012/01/09 17:15:55]

Done.

[kmadhusu, 2012/01/09 17:15:55]

Done.

     WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& default_params,
-    PageSizeMargins* page_layout_in_points) {
-  int dpi = GetDPI(&default_params);
+    bool ignore_css_margins,
+    bool fit_to_page,
+    double* scale_factor) {
+  if (ignore_css_margins && fit_to_page) {
+    return default_params;
+  } else {

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

Since the if body returns, don't use an else, just continue from there.

[kmadhusu, 2012/01/09 17:15:55]

Done.

+    PrintMsg_Print_Params params = GetCssPrintParams(frame, page_index,
+                                                     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.content_size.width() - default_params.margin_left,
-      dpi, printing::kPixelsPerInch);
-  int margin_bottom_in_pixels = ConvertUnit(
-      default_params.page_size.height() -
-      default_params.content_size.height() - default_params.margin_top,
-      dpi, printing::kPixelsPerInch);
-  int margin_left_in_pixels = ConvertUnit(
-      default_params.margin_left,
-      dpi, printing::kPixelsPerInch);
+    if (ignore_css_margins) {
+      params.margin_top = default_params.margin_top;
+      params.margin_left = default_params.margin_left;
 
-  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);
+      // Since we are ignoring the margins, the css page size is no longer
+      // valid.
+      if (fit_to_page) {

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

This if isn't needed, because you handeld the ignore_css_margins & fit_to_page
case above.  Add a DCHECK when you remove the if?

[kmadhusu, 2012/01/09 17:15:55]

Done.

+        params.content_size = default_params.content_size;
+        params.page_size = default_params.page_size;
+      } else {
+        int default_margin_right= default_params.page_size.width() -

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

nit space: default_margin_right =

[kmadhusu, 2012/01/09 17:15:55]

Done.

+            default_params.content_size.width() - default_params.margin_left;
+        int default_margin_bottom = default_params.page_size.height() -
+            default_params.content_size.height() - default_params.margin_top;
+        params.content_size = gfx::Size(
+            params.page_size.width() - params.margin_left -
+                default_margin_right,
+            params.page_size.height() - params.margin_top -
+                default_margin_bottom);
+      }
+    }
+
+    if (fit_to_page) {

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

note: This could be an else if because the case where they are both true is
already handled.  (But don't do that.)

[kmadhusu, 2012/01/09 17:15:55]

ok

+      double factor = FitPrintParamsToPage(default_params, &params);
+      if (scale_factor)
+        *scale_factor = factor;
+    }
+    return params;
   }
-
-  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);
-    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(
+void PrintWebViewHelper::ComputePageLayoutInPoints(

[vandebo (ex-Chrome), 2012/01/07 00:23:19]

ComputePageLayoutInPointsForCss

[kmadhusu, 2012/01/09 17:15:55]

Done.

+    WebFrame* frame,
+    int page_index,
+    const PrintMsg_Print_Params& default_params,
+    bool ignore_css_margins,
+    bool fit_to_page,
+    double* scale_factor,
+    PageSizeMargins* page_layout_in_points) {
+  PrintMsg_Print_Params params = CalculatePrintParams(frame, page_index,
+                                                      default_params,
+                                                      ignore_css_margins,
+                                                      fit_to_page,
+                                                      scale_factor);
+  CalculatePageLayoutFromPrintParams(params, page_layout_in_points);
+}
+
+// static - Not anonymous so that platform implementations can use it.
+void PrintWebViewHelper::UpdateFrameAndViewFromCssPageLayout(
     WebFrame* frame,
     const WebNode& node,
     PrepareFrameAndViewForPrint* prepare,
-    PrintMsg_Print_Params* params) {
+    const PrintMsg_Print_Params& params,
+    bool ignore_css_margins,
+    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->content_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(
-      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(
-      page_layout_in_points.margin_left, printing::kPointsPerInch, dpi));
-
-  prepare->UpdatePrintParams(*params);
+  PrintMsg_Print_Params print_params = CalculatePrintParams(
+      frame, 0, params, ignore_css_margins, ignore_css_margins && fit_to_page,
+      NULL);
+  prepare->UpdatePrintParams(print_params);
 }
 
 bool PrintWebViewHelper::InitPrintSettings(WebKit::WebFrame* frame,
                                            const WebKit::WebNode& node) {
   DCHECK(frame);
   PrintMsg_PrintPages_Params settings;
 
+  // Reset to default values.
+  ignore_css_margins_ = false;
+  fit_to_page_ = true;
+
   Send(new PrintHostMsg_GetDefaultPrintSettings(routing_id(),
                                                 &settings.params));
   // 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.
   bool result = true;
   if (PrintMsg_Print_Params_IsEmpty(settings.params)) {
     render_view()->RunModalAlertDialog(
         frame,
         l10n_util::GetStringUTF16(
@@ skipping 15 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);
+  UpdateFrameAndViewFromCssPageLayout(frame, node, prepare->get(),
+                                      print_pages_params_->params,
+                                      ignore_css_margins_, 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_css_margins,
+    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);
+  UpdateFrameAndViewFromCssPageLayout(frame_, node_, prep_frame_view_.get(),
+                                      *print_params, ignore_css_margins,
+                                      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;
 }