Clean up windows printing workflow.

chrome/renderer/print_web_view_helper_win.cc

 // Copyright (c) 2009 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 "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/renderer/render_view.h"
@@ skipping 55 matching lines @@
                                    const gfx::Size& canvas_size,
                                    WebFrame* frame) {
   // Generate a memory-based metafile. It will use the current screen's DPI.
   printing::NativeMetafile metafile;
 
   metafile.CreateDc(NULL, NULL);
   HDC hdc = metafile.hdc();
   DCHECK(hdc);
   skia::PlatformDevice::InitializeDC(hdc);
 
-  double content_width_in_points;
-  double content_height_in_points;
-  double margin_top_in_points;
-  double margin_right_in_points;
-  double margin_bottom_in_points;
-  double margin_left_in_points;
-  GetPageSizeAndMarginsInPoints(frame,
-                                params.page_number,
-                                params.params,
-                                &content_width_in_points,
-                                &content_height_in_points,
-                                &margin_top_in_points,
-                                &margin_right_in_points,
-                                &margin_bottom_in_points,
-                                &margin_left_in_points);
+  // Calculate the dpi adjustment.
+  float scale_factor = static_cast<float>(params.params.desired_dpi /
+                                          params.params.dpi);
+  int page_number = params.page_number;
 
-  // Since WebKit extends the page width depending on the magical shrink
-  // factor we make sure the canvas covers the worst case scenario
-  // (x2.0 currently).  PrintContext will then set the correct clipping region.
-  int size_x = static_cast<int>(content_width_in_points *
-                                params.params.max_shrink);
-  int size_y = static_cast<int>(content_height_in_points *
-                                params.params.max_shrink);
-  // Calculate the dpi adjustment.
-  float shrink = static_cast<float>(params.params.desired_dpi /
-                                    params.params.dpi);
+  int width = static_cast<int>(

[Lei Zhang, 2011/01/19 05:10:04]

width/height is suppose to be the same as size_x/size_y, right? I see different
values for the two:

width = size_x * scale_factor.

[kmadhusu, 2011/01/19 17:09:41]

In the old code, we calculated |size_x| and |size_y| with 
|content_width_in_points| and |content_height_in_points| respectively.

In the new code, |width| and |height| are calculated using
|content_width_in_points| and |content_height_in_points| which are scaled based
on dpi values  (Scaling is done in UpdatePrintableSizeInPrintParameters
function). I made this change because all the values set to |page_params| are
scaled based on dpi. I verified the printed output page and I did not see any
difference.  

[Lei Zhang, 2011/01/19 21:44:03]

(repeating our in person conversation for senorblanco's benefit)

The final output does looks the same, but I'm concerned we are creating a canvas
that's |scale_factor| times bigger in both width and height. How does that
affect memory usage? Does drawing to a canvas at a higher resolution make the
output look better?

[kmadhusu, 2011/01/19 23:25:12]

New code caused some random errors while handling alpha blend transparency. So
reverting my changes.

+      params.params.printable_size.width() * params.params.max_shrink);
+  int height = static_cast<int>(
+      params.params.printable_size.height() * params.params.max_shrink);
 #if 0
   // TODO(maruel): This code is kept for testing until the 100% GDI drawing
   // code is stable. maruels use this code's output as a reference when the
   // GDI drawing code fails.
 
   // Mix of Skia and GDI based.
-  skia::PlatformCanvas canvas(size_x, size_y, true);
+  skia::PlatformCanvas canvas(width, height, true);
   canvas.drawARGB(255, 255, 255, 255, SkXfermode::kSrc_Mode);
-  float webkit_shrink = frame->printPage(params.page_number, &canvas);
-  if (shrink <= 0 || webkit_shrink <= 0) {
-    NOTREACHED() << "Printing page " << params.page_number << " failed.";
+  float webkit_scale_factor = frame->printPage(page_number, &canvas);
+  if (scale_factor <= 0 || webkit_scale_factor <= 0) {
+    NOTREACHED() << "Printing page " << page_number << " failed.";
   } else {
-    // Update the dpi adjustment with the "page shrink" calculated in webkit.
-    shrink /= webkit_shrink;
+    // Update the dpi adjustment with the "page |scale_factor|" calculated
+    // in webkit.
+    scale_factor /= webkit_scale_factor;
   }
 
   // Create a BMP v4 header that we can serialize.
   BITMAPV4HEADER bitmap_header;
-  gfx::CreateBitmapV4Header(size_x, size_y, &bitmap_header);
+  gfx::CreateBitmapV4Header(width, height, &bitmap_header);
   const SkBitmap& src_bmp = canvas.getDevice()->accessBitmap(true);
   SkAutoLockPixels src_lock(src_bmp);
   int retval = StretchDIBits(hdc,
                              0,
                              0,
-                             size_x, size_y,
+                             width, height,
                              0, 0,
-                             size_x, size_y,
+                             width, height,
                              src_bmp.getPixels(),
                              reinterpret_cast<BITMAPINFO*>(&bitmap_header),
                              DIB_RGB_COLORS,
                              SRCCOPY);
   DCHECK(retval != GDI_ERROR);
 #else
   // 100% GDI based.
-  skia::VectorCanvas canvas(hdc, size_x, size_y);
-  float webkit_shrink = frame->printPage(params.page_number, &canvas);
-  if (shrink <= 0 || webkit_shrink <= 0) {
-    NOTREACHED() << "Printing page " << params.page_number << " failed.";
+  skia::VectorCanvas canvas(hdc, width, height);
+  float webkit_scale_factor = frame->printPage(page_number, &canvas);
+  if (scale_factor <= 0 || webkit_scale_factor <= 0) {
+    NOTREACHED() << "Printing page " << page_number << " failed.";
   } else {
-    // Update the dpi adjustment with the "page shrink" calculated in webkit.
-    shrink /= webkit_shrink;
+    // Update the dpi adjustment with the "page scale_factor" calculated
+    // in webkit.
+    scale_factor /= webkit_scale_factor;
   }
 #endif
 
   // Done printing. Close the device context to retrieve the compiled metafile.
   if (!metafile.CloseDc()) {
     NOTREACHED() << "metafile failed";
   }
   printing::NativeMetafile* mf = &metafile;
   printing::NativeMetafile metafile2;
 
   skia::VectorPlatformDevice* platform_device =
     static_cast<skia::VectorPlatformDevice*>(canvas.getDevice());
   if (platform_device->alpha_blend_used() &&
       !params.params.supports_alpha_blend) {
     // Page used alpha blend, but printer doesn't support it.  Rewrite the
     // metafile and flatten out the transparency.
     HDC bitmap_dc = CreateCompatibleDC(GetDC(NULL));
     if (!bitmap_dc) {
       NOTREACHED() << "Bitmap DC creation failed";
     }
     SetGraphicsMode(bitmap_dc, GM_ADVANCED);
     void* bits = NULL;
     BITMAPINFO hdr;
-    gfx::CreateBitmapHeader(size_x, size_y, &hdr.bmiHeader);
+    gfx::CreateBitmapHeader(width, height, &hdr.bmiHeader);
     HBITMAP hbitmap = CreateDIBSection(
         bitmap_dc, &hdr, DIB_RGB_COLORS, &bits, NULL, 0);
     if (!hbitmap) {
       NOTREACHED() << "Raster bitmap creation for printing failed";
     }
 
     HGDIOBJ old_bitmap = SelectObject(bitmap_dc, hbitmap);
-    RECT rect = {0, 0, size_x, size_y };
+    RECT rect = {0, 0, width, height };
     HBRUSH whiteBrush = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
     FillRect(bitmap_dc, &rect, whiteBrush);
 
     metafile2.CreateDc(NULL, NULL);
     HDC hdc = metafile2.hdc();
     DCHECK(hdc);
     skia::PlatformDevice::InitializeDC(hdc);
 
     RECT metafile_bounds = metafile.GetBounds().ToRECT();
     // Process the old metafile, placing all non-AlphaBlend calls into the
@@ skipping 12 matching lines @@
     }
     mf = &metafile2;
   }
 
   // Get the size of the compiled metafile.
   uint32 buf_size = mf->GetDataSize();
   DCHECK_GT(buf_size, 128u);
   ViewHostMsg_DidPrintPage_Params page_params;
   page_params.data_size = 0;
   page_params.metafile_data_handle = NULL;
-  page_params.page_number = params.page_number;
+  page_params.page_number = page_number;
   page_params.document_cookie = params.params.document_cookie;
-  page_params.actual_shrink = shrink;
-  page_params.page_size = gfx::Size(
-      static_cast<int>(ConvertUnitDouble(
-          content_width_in_points +
-          margin_left_in_points + margin_right_in_points,
-          kPointsPerInch, params.params.dpi)),
-      static_cast<int>(ConvertUnitDouble(
-          content_height_in_points +
-          margin_top_in_points + margin_bottom_in_points,
-          kPointsPerInch, params.params.dpi)));
-  page_params.content_area = gfx::Rect(
-      static_cast<int>(ConvertUnitDouble(
-          margin_left_in_points, kPointsPerInch, params.params.dpi)),
-      static_cast<int>(ConvertUnitDouble(
-          margin_top_in_points, kPointsPerInch, params.params.dpi)),
-      static_cast<int>(ConvertUnitDouble(
-          content_width_in_points, kPointsPerInch, params.params.dpi)),
-      static_cast<int>(ConvertUnitDouble(
-          content_height_in_points, kPointsPerInch, params.params.dpi)));
-  page_params.has_visible_overlays =
-      frame->isPageBoxVisible(params.page_number);
+  page_params.actual_shrink = scale_factor;
+  page_params.page_size = params.params.page_size;
+  page_params.content_area = gfx::Rect(params.params.margin_left,
+      params.params.margin_top, params.params.printable_size.width(),
+      params.params.printable_size.height());
+  page_params.has_visible_overlays = frame->isPageBoxVisible(page_number);
   base::SharedMemory shared_buf;
 
   // http://msdn2.microsoft.com/en-us/library/ms535522.aspx
   // Windows 2000/XP: When a page in a spooled file exceeds approximately 350
   // MB, it can fail to print and not send an error message.
   if (buf_size < 350*1024*1024) {
     // Allocate a shared memory buffer to hold the generated metafile data.
     if (shared_buf.CreateAndMapAnonymous(buf_size)) {
       // Copy the bits into shared memory.
       if (mf->GetData(shared_buf.memory(), buf_size)) {
@@ skipping 12 matching lines @@
   mf->CloseEmf();
   if (Send(new ViewHostMsg_DuplicateSection(
       routing_id(),
       page_params.metafile_data_handle,
       &page_params.metafile_data_handle))) {
     if (!is_preview_) {
       Send(new ViewHostMsg_DidPrintPage(routing_id(), page_params));
     }
   }
 }