PrintPreview: [Cleanup] Remove unwanted function calls.

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 499 matching lines @@
     return;
   }
 
   WebFrame* pdf_frame = pdf_element.document().frame();
   if (!UpdatePrintSettings(pdf_frame, pdf_element, job_settings, true)) {
     LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
-  scoped_ptr<PrepareFrameAndViewForPrint> prepare;
-  prepare.reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
-                                                pdf_frame, pdf_element));
-  UpdatePrintableSizeInPrintParameters(pdf_frame, pdf_element, prepare.get(),
-                                       &print_pages_params_->params);
-
   // Render Pages for printing.
-  if (!RenderPagesForPrint(pdf_frame, pdf_element, prepare.get())) {
+  if (!RenderPagesForPrint(pdf_frame, pdf_element)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
 }
 
 bool PrintWebViewHelper::GetPrintFrame(WebKit::WebFrame** frame) {
   DCHECK(frame);
   DCHECK(render_view()->GetWebView());
   if (!render_view()->GetWebView())
     return false;
@@ skipping 221 matching lines @@
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
   if (!GetPrintSettingsFromUser(frame, node, expected_page_count,
                                 use_browser_overlays)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
-  if (!RenderPagesForPrint(frame, node, NULL)) {
+  if (!RenderPagesForPrint(frame, node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   ResetScriptedPrintCount();
 }
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   bool store_print_pages_params = true;
   if (result == FAIL_PRINT) {
     DisplayPrintJobError();
@@ skipping 51 matching lines @@
   // When loading is done this will call DidStopLoading that will do the
   // actual printing.
   print_web_view_->mainFrame()->loadRequest(WebURLRequest(url));
 
   return true;
 }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
 bool PrintWebViewHelper::PrintPages(const PrintMsg_PrintPages_Params& params,
                                     WebFrame* frame,
-                                    const WebNode& node,
-                                    PrepareFrameAndViewForPrint* prepare) {
+                                    const WebNode& node) {
   PrintMsg_Print_Params print_params = params.params;
-  scoped_ptr<PrepareFrameAndViewForPrint> prep_frame_view;
-  if (!prepare) {
-    prep_frame_view.reset(new PrepareFrameAndViewForPrint(print_params, frame,
-                                                          node));
-    prepare = prep_frame_view.get();
-  }
-  UpdatePrintableSizeInPrintParameters(frame, node, prepare, &print_params);
+  PrepareFrameAndViewForPrint prep_frame_view(print_params, frame, node);
+  UpdatePrintableSizeInPrintParameters(frame, node, &prep_frame_view,
+                                       &print_params);
 
-  int page_count = prepare->GetExpectedPageCount();
+  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 = prepare->GetPrintCanvasSize();
+  const gfx::Size& canvas_size = prep_frame_view.GetPrintCanvasSize();
   PrintMsg_PrintPage_Params page_params;
   page_params.params = print_params;
   if (params.pages.empty()) {
     for (int i = 0; i < page_count; ++i) {
       page_params.page_number = i;
       PrintPageInternal(page_params, canvas_size, frame);
     }
   } else {
     for (size_t i = 0; i < params.pages.size(); ++i) {
       if (params.pages[i] >= page_count)
         break;
       page_params.page_number = params.pages[i];
       PrintPageInternal(page_params, canvas_size, frame);
     }
   }
   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(), NULL);
+  PrintPages(*params, print_web_view_->mainFrame(), WebNode());
 }
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::GetPageSizeAndMarginsInPoints(
     WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& default_params,
     PageSizeMargins* page_layout_in_points) {
   int dpi = GetDPI(&default_params);
 
@@ skipping 292 matching lines @@
   IPC::SyncMessage* msg =
       new PrintHostMsg_ScriptedPrint(routing_id(), params, &print_settings);
   msg->EnableMessagePumping();
   Send(msg);
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(print_settings));
   return (print_settings.params.dpi && print_settings.params.document_cookie);
 }
 
 bool PrintWebViewHelper::RenderPagesForPrint(
     WebKit::WebFrame* frame,
-    const WebKit::WebNode& node,
-    PrepareFrameAndViewForPrint* prepare) {
+    const WebKit::WebNode& node) {
   PrintMsg_PrintPages_Params print_settings = *print_pages_params_;
   if (print_settings.params.selection_only) {
     return CopyAndPrint(frame);
   } else {
     // TODO: Always copy before printing.
-    return PrintPages(print_settings, frame, node, prepare);
+    return PrintPages(print_settings, frame, node);
   }
 }
 
 #if defined(OS_POSIX)
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     printing::Metafile* metafile,
     base::SharedMemoryHandle* shared_mem_handle) {
   uint32 buf_size = metafile->GetDataSize();
   base::SharedMemoryHandle mem_handle =
       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(buf_size);
@@ skipping 350 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;
 }