Cleanup of PrepareFrameAndViewForPrint code.

chrome/renderer/printing/print_web_view_helper_linux.cc

 // Copyright (c) 2012 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/printing/print_web_view_helper.h"
 
 #include "base/file_descriptor_posix.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 39 matching lines @@
     draft_metafile->FinishDocument();
   } 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());
 }
 
-bool PrintWebViewHelper::PrintPages(WebFrame* frame, const WebNode& node) {
+bool PrintWebViewHelper::PrintPagesNative(WebKit::WebFrame* frame,
+                                          const WebKit::WebNode& node,
+                                          int page_count,
+                                          const gfx::Size& canvas_size) {
   NativeMetafile metafile;
   if (!metafile.Init())
     return false;
 
   const PrintMsg_PrintPages_Params& params = *print_pages_params_;
   std::vector<int> printed_pages;
-  if (!RenderPages(params, frame, node, &printed_pages, &metafile)) {
+  if (!RenderPages(params, frame, &printed_pages, page_count, canvas_size,
+                   &metafile)) {
     return false;
   }
 
   metafile.FinishDocument();
 
   // Get the size of the resulting metafile.
   uint32 buf_size = metafile.GetDataSize();
   DCHECK_GT(buf_size, 0u);
 
 #if defined(OS_CHROMEOS)
@@ skipping 38 matching lines @@
     Send(new PrintHostMsg_DidPrintPage(routing_id(), printed_page_params));
     // Send the rest of the pages with an invalid metafile handle.
     printed_page_params.metafile_data_handle.fd = -1;
   }
   return true;
 #endif  // defined(OS_CHROMEOS)
 }
 
 bool PrintWebViewHelper::RenderPages(const PrintMsg_PrintPages_Params& params,
                                      WebKit::WebFrame* frame,
-                                     const WebKit::WebNode& node,
                                      std::vector<int>* printed_pages,
+                                     int page_count,

[Lei Zhang, 2013/01/23 08:31:38]

With |page_count| coming from outside, RenderPages() can return void, because
you already know if it will fail or not. Lines 134-145 can also be moved
outside, so you won't even need |page_count|, and |printed_pages| can be an in
parameter.

Of course, doing all that would strip RenderPages() down to a 6 line function.
At which point, maybe we don't even need it anymore. I think if you do get rid
of it, then the workflow on all platforms become PrintPages() ->
PrintPagesNative() -> PrintPagesInternal(), right?

[Vitaly Buka (NO REVIEWS), 2013/01/23 09:32:31]

I can remove RenderPage.

I see that loop in PrintPagesNative is very similar on all platforms. Only
problems that Linux sends fake messages after entire doc is rendered. I'd like
to think about that later.


On 2013/01/23 08:31:38, Lei Zhang wrote:

+                                     const gfx::Size& canvas_size,
                                      Metafile* metafile) {
-  PrepareFrameAndViewForPrint prepare(params.params, frame, node);
-  PrintMsg_Print_Params print_params = params.params;
-  UpdateFrameAndViewFromCssPageLayout(frame, node, &prepare, print_params,
-                                      ignore_css_margins_);
-
-  int page_count = prepare.GetExpectedPageCount();
-  if (!page_count)
-    return false;
-
-#if !defined(OS_CHROMEOS)
-  // TODO(vitalybuka): should be page_count or valid pages from params.pages.
-  // See http://crbug.com/161576
-  Send(new PrintHostMsg_DidGetPrintedPagesCount(routing_id(),
-                                                print_params.document_cookie,
-                                                page_count));
-#endif
-
   if (params.pages.empty()) {
     for (int i = 0; i < page_count; ++i) {
       printed_pages->push_back(i);
     }
   } else {
     // TODO(vitalybuka): redesign to make more code cross platform.
     for (size_t i = 0; i < params.pages.size(); ++i) {
       if (params.pages[i] >= 0 && params.pages[i] < page_count) {
         printed_pages->push_back(params.pages[i]);
       }
     }
   }
 
   if (printed_pages->empty())
     return false;
 
   PrintMsg_PrintPage_Params page_params;
-  page_params.params = print_params;
-  const gfx::Size& canvas_size = prepare.GetPrintCanvasSize();
+  page_params.params = params.params;
   for (size_t i = 0; i < printed_pages->size(); ++i) {
     page_params.page_number = (*printed_pages)[i];
     PrintPageInternal(page_params, canvas_size, frame, metafile);
   }
 
   return true;
 }
 
 void PrintWebViewHelper::PrintPageInternal(
     const PrintMsg_PrintPage_Params& params,
@@ skipping 35 matching lines @@
   }
   RenderPageContent(frame, params.page_number, canvas_area, content_area,
                     scale_factor, canvas.get());
 
   // Done printing. Close the device context to retrieve the compiled metafile.
   if (!metafile->FinishPage())
     NOTREACHED() << "metafile failed";
 }
 
 }  // namespace printing