Fix smelly scoped_ptr code in print_web_view_helper_win.

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 72 matching lines @@
   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);
 
   // Render page for printing.
-  RenderPage(params.params, &scale_factor, page_number, false, frame,
-             &metafile);
+  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.
   uint32 buf_size = metafile->GetDataSize();
   DCHECK_GT(buf_size, 128u);
 
   PrintHostMsg_DidPrintPage_Params page_params;
@@ skipping 15 matching lines @@
 
   Send(new PrintHostMsg_DidPrintPage(routing_id(), page_params));
 }
 
 void 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);
 
-  // |metafile| is needed for RenderPage() below. |metafile| will not take the
-  // ownership of |print_preview_context_| metafile.
-  scoped_ptr<Metafile> metafile(print_preview_context_.metafile());
-
   base::TimeTicks begin_time = base::TimeTicks::Now();
+  // In the preview flow, RenderPage will never return a new metafile.

[Lei Zhang, 2011/08/08 22:08:59]

Should we add a DCHECK() to make sure this stays true?

[vandebo (ex-Chrome), 2011/08/08 22:11:29]

Can we do that without introducing a warning?  The variable will only be used in
a DCHECK and therefore won't be used in Release mode.

[vandebo (ex-Chrome), 2011/08/09 00:22:47]

Done.

   RenderPage(print_params, &scale_factor, page_number, true,
-             print_preview_context_.frame(), &metafile);
+             print_preview_context_.frame(), print_preview_context_.metafile());
 
   print_preview_context_.RenderedPreviewPage(
       base::TimeTicks::Now() - begin_time);
 
-  // Release since |print_preview_context_| is the real owner.
-  metafile.release();
   scoped_ptr<printing::Metafile> page_metafile;
   if (print_preview_context_.IsModifiable()) {
     page_metafile.reset(reinterpret_cast<printing::PreviewMetafile*>(
         print_preview_context_.metafile())->GetMetafileForCurrentPage());
   }
   PreviewPageRendered(page_number, page_metafile.get());
 }
 
-void PrintWebViewHelper::RenderPage(
+Metafile* PrintWebViewHelper::RenderPage(
     const PrintMsg_Print_Params& params, float* scale_factor, int page_number,
-    bool is_preview, WebFrame* frame, scoped_ptr<Metafile>* metafile) {
+    bool is_preview, WebFrame* frame, Metafile* metafile) {
   PageSizeMargins page_layout_in_points;
   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 {
     // 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);
   }
 
   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(
+  SkDevice* device = metafile->StartPageForVectorCanvas(
       page_size, content_area, frame->getPrintPageShrink(page_number));
   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.get(),
-                                                       metafile->get());
-  }
+  if (is_preview)
+    printing::MetafileSkiaWrapper::SetMetafileOnCanvas(canvas.get(), metafile);
 
   float webkit_scale_factor = frame->printPage(page_number, canvas.get());
   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;
   }
 
-  bool result = (*metafile)->FinishPage();
+  bool result = metafile->FinishPage();
   DCHECK(result);
 
   if (!params.supports_alpha_blend) {
     // PreviewMetafile (PDF) supports alpha blend, so we only hit this case
     // for NativeMetafile.
     DCHECK(!is_preview);
     skia::PlatformDevice* platform_device = skia::GetPlatformDevice(device);
     if (platform_device && platform_device->AlphaBlendUsed()) {
       // Currently, we handle alpha blend transparency for a single page.
       // Therefore, expecting a metafile with page count 1.
-      DCHECK_EQ(1U, (*metafile)->GetPageCount());
+      DCHECK_EQ(1U, metafile->GetPageCount());
 
       // Close the device context to retrieve the compiled metafile.
-      if (!(*metafile)->FinishDocument())
+      if (!metafile->FinishDocument())
         NOTREACHED();
 
       // 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(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, width, height };
       HBRUSH whiteBrush = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
       FillRect(bitmap_dc, &rect, whiteBrush);
 
-      scoped_ptr<Metafile> metafile2(new printing::NativeMetafile);
+      Metafile* metafile2(new printing::NativeMetafile);
       metafile2->Init();
       HDC hdc = metafile2->context();
       DCHECK(hdc);
       skia::InitializeDC(hdc);
 
-      RECT metafile_bounds = (*metafile)->GetPageBounds(1).ToRECT();
+      RECT metafile_bounds = metafile->GetPageBounds(1).ToRECT();
       // Process the old metafile, placing all non-AlphaBlend calls into the
       // new metafile, and copying the results of all the AlphaBlend calls
       // from the bitmap DC.
       EnumEnhMetaFile(hdc,
-                      (*metafile)->emf(),
+                      metafile->emf(),
                       EnhMetaFileProc,
                       &bitmap_dc,
                       &metafile_bounds);
 
       SelectObject(bitmap_dc, old_bitmap);
-      metafile->reset(metafile2.release());
+      return metafile2;
     }
   }
+  return metafile;
 }
 
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     Metafile* metafile, base::SharedMemoryHandle* shared_mem_handle) {
   uint32 buf_size = metafile->GetDataSize();
   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) {
@@ skipping 13 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;
 }