PrintPreview: Remove |page_number| from StartPageForVectorCanvas function.

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 66 matching lines @@
     const gfx::Size& canvas_size,
     WebFrame* frame) {
   // 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;
-  int page_slot = params.page_slot;
 
   // 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, page_slot, false, frame,
+  RenderPage(params.params, &scale_factor, page_number, false, frame,
              &metafile);
 
   // 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);
 
@@ skipping 21 matching lines @@
   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();
-  RenderPage(print_params, &scale_factor, page_number,
-             print_preview_context_.GetPageSlotForPage(page_number), true,
+  RenderPage(print_params, &scale_factor, page_number, true,
              print_preview_context_.frame(), &metafile);
 
   print_preview_context_.RenderedPreviewPage(
       base::TimeTicks::Now() - begin_time);
 
   // Release since |print_preview_context_| is the real owner.
   metafile.release();
   printing::Metafile* page_metafile = NULL;
   if (print_preview_context_.IsModifiable()) {
     page_metafile = reinterpret_cast<printing::PreviewMetafile*>(
         print_preview_context_.metafile())->GetMetafileForCurrentPage();
   }
   PreviewPageRendered(page_number, page_metafile);
 }
 
 void PrintWebViewHelper::RenderPage(
     const PrintMsg_Print_Params& params, float* scale_factor, int page_number,
-    int page_slot, bool is_preview, WebFrame* frame,
-    scoped_ptr<Metafile>* metafile) {
+    bool is_preview, WebFrame* frame, scoped_ptr<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(
-      page_slot, page_size, content_area,
-      frame->getPrintPageShrink(page_number));
+      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());
   }
 
@@ skipping 89 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;
 }