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

chrome/renderer/print_web_view_helper_win.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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
@@ skipping 91 matching lines @@
   // Generate a memory-based metafile. It will use the current screen's DPI.
   // Each metafile contains a single page.
   scoped_ptr<Metafile> metafile(new printing::NativeMetafile);
   metafile->Init();
   DCHECK(metafile->context());
   skia::InitializeDC(metafile->context());
 
   int page_number = params.page_number;
 
   // Calculate the dpi adjustment.
-  float scale_factor = static_cast<float>(params.params.desired_dpi /
-                                          params.params.dpi);
+  double scale_factor = static_cast<float>(params.params.desired_dpi /
+                                           params.params.dpi);
 
   // Render page for printing.
   metafile.reset(RenderPage(params.params, &scale_factor, page_number, false,
                             frame, metafile.get()));
 
   // Close the device context to retrieve the compiled metafile.
   if (!metafile->FinishDocument())
     NOTREACHED();
 
   // Get the size of the compiled metafile.
@@ skipping 15 matching lines @@
                                    &(page_params.metafile_data_handle))) {
     page_params.data_size = 0;
   }
 
   Send(new PrintHostMsg_DidPrintPage(routing_id(), page_params));
 }
 
 bool PrintWebViewHelper::RenderPreviewPage(int page_number) {
   PrintMsg_Print_Params print_params = print_preview_context_.print_params();
   // Calculate the dpi adjustment.
-  float scale_factor = static_cast<float>(print_params.desired_dpi /
-                                          print_params.dpi);
+  double scale_factor = static_cast<float>(print_params.desired_dpi /
+                                           print_params.dpi);
   scoped_ptr<Metafile> draft_metafile;
   printing::Metafile* initial_render_metafile =
       print_preview_context_.metafile();
 
   if (print_preview_context_.IsModifiable() && is_print_ready_metafile_sent_) {
     draft_metafile.reset(new printing::PreviewMetafile);
     initial_render_metafile = draft_metafile.get();
   }
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
@@ skipping 10 matching lines @@
   } else if (print_preview_context_.IsModifiable() &&
              print_preview_context_.generate_draft_pages()) {
     DCHECK(!draft_metafile.get());
     draft_metafile.reset(
         print_preview_context_.metafile()->GetMetafileForCurrentPage());
   }
   return PreviewPageRendered(page_number, draft_metafile.get());
 }
 
 Metafile* PrintWebViewHelper::RenderPage(
-    const PrintMsg_Print_Params& params, float* scale_factor, int page_number,
+    const PrintMsg_Print_Params& params, double* scale_factor, int page_number,
     bool is_preview, WebFrame* frame, Metafile* metafile) {
   printing::PageSizeMargins page_layout_in_points;
+  *scale_factor = frame->getPrintPageShrink(page_number);

[vandebo (ex-Chrome), 2011/12/14 19:05:38]

Don't we need both scale factors?  GetPageSizeANdMarginsInPoints will overwrite
this scale factor.

[kmadhusu, 2011/12/19 09:52:19]

Fixed.

   GetPageSizeAndMarginsInPoints(frame, page_number, params,
-                                &page_layout_in_points);
-
-  int width;
-  int height;
-  if (is_preview) {
-    int dpi = static_cast<int>(params.dpi);
-    int desired_dpi = printing::kPointsPerInch;
-    width = ConvertUnit(params.page_size.width(), dpi, desired_dpi);
-    height = ConvertUnit(params.page_size.height(), dpi, desired_dpi);
-  } else {
+                                ignore_css_margins_, fit_to_page_,
+                                scale_factor, &page_layout_in_points);
+  gfx::Size page_size;
+  gfx::Rect content_area;
+  UpdatePageSizeAndContentAreaFromPageLayout(page_layout_in_points, &page_size,
+                                             &content_area);
+  if (!is_preview) {
     // Since WebKit extends the page width depending on the magical scale factor
     // we make sure the canvas covers the worst case scenario (x2.0 currently).
     // PrintContext will then set the correct clipping region.
-    width = static_cast<int>(page_layout_in_points.content_width *
-                             params.max_shrink);
-    height = static_cast<int>(page_layout_in_points.content_height *
-                              params.max_shrink);
+    page_size = gfx::Size(
+        static_cast<int>(page_layout_in_points.content_width *
+                         params.max_shrink),
+        static_cast<int>(page_layout_in_points.content_height *
+                         params.max_shrink));
   }
 
-  gfx::Size page_size(width, height);
-  gfx::Rect content_area(
-      static_cast<int>(page_layout_in_points.margin_left),
-      static_cast<int>(page_layout_in_points.margin_top),
-      static_cast<int>(page_layout_in_points.content_width),
-      static_cast<int>(page_layout_in_points.content_height));
   SkDevice* device = metafile->StartPageForVectorCanvas(
-      page_size, content_area, frame->getPrintPageShrink(page_number));
+      page_size, content_area, *scale_factor);
   DCHECK(device);
   // The printPage method may take a reference to the canvas we pass down, so it
   // can't be a stack object.
   SkRefPtr<skia::VectorCanvas> canvas = new skia::VectorCanvas(device);
   canvas->unref();  // SkRefPtr and new both took a reference.
   if (is_preview) {
     printing::MetafileSkiaWrapper::SetMetafileOnCanvas(*canvas, metafile);
     skia::SetIsDraftMode(*canvas, is_print_ready_metafile_sent_);
     skia::SetIsPreviewMetafile(*canvas, is_preview);
   }
 
   float webkit_scale_factor = frame->printPage(page_number, canvas.get());
 
   if (params.display_header_footer) {
     // |page_number| is 0-based, so 1 is added.
     PrintHeaderAndFooter(canvas.get(), page_number + 1,
                          print_preview_context_.total_page_count(),
-                         webkit_scale_factor, page_layout_in_points,
+                         *scale_factor, page_layout_in_points,
                          *header_footer_info_);
   }
 
   if (*scale_factor <= 0 || webkit_scale_factor <= 0) {
     NOTREACHED() << "Printing page " << page_number << " failed.";
   } else {
     // Update the dpi adjustment with the "page |scale_factor|" calculated in
     // webkit.
     *scale_factor /= webkit_scale_factor;
   }
@@ skipping 17 matching lines @@
 
       // Page used alpha blend, but printer doesn't support it.  Rewrite the
       // metafile and flatten out the transparency.
       base::win::ScopedGetDC screen_dc(NULL);
       base::win::ScopedCreateDC bitmap_dc(CreateCompatibleDC(screen_dc));
       if (!bitmap_dc)
         NOTREACHED() << "Bitmap DC creation failed";
       SetGraphicsMode(bitmap_dc, GM_ADVANCED);
       void* bits = NULL;
       BITMAPINFO hdr;
-      gfx::CreateBitmapHeader(width, height, &hdr.bmiHeader);
+      gfx::CreateBitmapHeader(page_size.width(), page_size.height(),
+                              &hdr.bmiHeader);
       base::win::ScopedBitmap hbitmap(CreateDIBSection(
           bitmap_dc, &hdr, DIB_RGB_COLORS, &bits, NULL, 0));
       if (!hbitmap)
         NOTREACHED() << "Raster bitmap creation for printing failed";
 
       base::win::ScopedSelectObject selectBitmap(bitmap_dc, hbitmap);
-      RECT rect = {0, 0, width, height };
+      RECT rect = { 0, 0, page_size.width(), page_size.height() };
       HBRUSH whiteBrush = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
       FillRect(bitmap_dc, &rect, whiteBrush);
 
       Metafile* metafile2(new printing::NativeMetafile);
       metafile2->Init();
       HDC hdc = metafile2->context();
       DCHECK(hdc);
       skia::InitializeDC(hdc);
 
       RECT metafile_bounds = metafile->GetPageBounds(1).ToRECT();
@@ skipping 35 matching lines @@
     shared_buf.Unmap();
     return false;
   }
   shared_buf.GiveToProcess(base::GetCurrentProcessHandle(), shared_mem_handle);
   shared_buf.Unmap();
 
   Send(new PrintHostMsg_DuplicateSection(routing_id(), *shared_mem_handle,
                                          shared_mem_handle));
   return true;
 }