Print Preview: Make preview generation event driven to eliminate synchronous messages.

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"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/print_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "content/renderer/render_view.h"
 #include "grit/generated_resources.h"
-#include "printing/metafile.h"
+#include "printing/metafile_impl.h"
 #include "printing/print_job_constants.h"
 #include "printing/units.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
@@ skipping 115 matching lines @@
     web_view_->resize(prev_view_size_);
     if (WebFrame* web_frame = web_view_->mainFrame())
       web_frame->setScrollOffset(prev_scroll_offset_);
   }
 }
 
 PrintWebViewHelper::PrintWebViewHelper(RenderView* render_view)
     : RenderViewObserver(render_view),
       RenderViewObserverTracker<PrintWebViewHelper>(render_view),
       print_web_view_(NULL),
-      script_initiated_preview_frame_(NULL),
-      context_menu_preview_node_(NULL),
       user_cancelled_scripted_print_count_(0),
-      notify_browser_of_print_failure_(true),
-      preview_page_count_(0) {
+      notify_browser_of_print_failure_(true) {
   is_preview_ = switches::IsPrintPreviewEnabled();
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(WebKit::WebFrame* frame) {
   DCHECK(frame);
 
   // Allow Prerendering to cancel this print request if necessary.
   if (prerender::PrerenderHelper::IsPrerendering(render_view())) {
     Send(new ViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
 
   if (IsScriptInitiatedPrintTooFrequent(frame))
     return;
   IncrementScriptedPrintCount();
 
   if (is_preview_) {
-    script_initiated_preview_frame_ = frame;
-    context_menu_preview_node_.reset();
+    print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview();
   } else {
     Print(frame, NULL);
   }
 }
 
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview,
                         OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintNodeUnderContextMenu,
                         OnPrintNodeUnderContextMenu)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForPrintPreview,
                         OnPrintForPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintingDone, OnPrintingDone)
     IPC_MESSAGE_HANDLER(PrintMsg_ResetScriptedPrintCount,
                         ResetScriptedPrintCount)
+    IPC_MESSAGE_HANDLER(PrintMsg_ContinuePreview,
+                        OnContinuePreview)

[kmadhusu, 2011/07/15 01:22:46]

nit: This argument will fit in the previous line. 

[Lei Zhang, 2011/07/15 01:48:02]

Done.

+    IPC_MESSAGE_HANDLER(PrintMsg_CancelPreview,
+                        OnCancelPreview)

[kmadhusu, 2011/07/15 01:22:46]

same here

[Lei Zhang, 2011/07/15 01:48:02]

Done.

+    IPC_MESSAGE_HANDLER(PrintMsg_AbortPreview,
+                        OnAbortPreview)

[kmadhusu, 2011/07/15 01:22:46]

same here

[Lei Zhang, 2011/07/15 01:48:02]

Done.

     IPC_MESSAGE_HANDLER(PrintMsg_PreviewPrintingRequestCancelled,
                         DisplayPrintJobError)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PrintWebViewHelper::OnPrintForPrintPreview(
     const DictionaryValue& job_settings) {
   DCHECK(is_preview_);
@@ skipping 47 matching lines @@
 }
 
 void PrintWebViewHelper::OnPrintPages() {
   WebFrame* frame;
   if (GetPrintFrame(&frame))
     Print(frame, NULL);
 }
 
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
   DCHECK(is_preview_);
-  DCHECK(!context_menu_preview_node_.get() || !script_initiated_preview_frame_);
+  print_preview_context_.OnPrintPreview();
 
-  if (script_initiated_preview_frame_) {
-    // Script initiated print preview.
-    PrintPreview(script_initiated_preview_frame_, NULL, settings);
-  } else if (context_menu_preview_node_.get()) {
-    // User initiated - print node under context menu.
-    PrintPreview(context_menu_preview_node_->document().frame(),
-                 context_menu_preview_node_.get(), settings);
-  } else {
-    // User initiated - normal print preview.
-    WebFrame* frame;
-    if (GetPrintFrame(&frame))
-      PrintPreview(frame, NULL, settings);
+  if (!InitPrintSettings(print_preview_context_.frame(),
+                         print_preview_context_.node())) {
+    NOTREACHED();
+    return;
   }
+
+  if (!UpdatePrintSettings(settings)) {
+    DidFinishPrinting(FAIL_PREVIEW);
+    return;
+  }
+
+  if (print_pages_params_->params.preview_request_id != 0 &&
+      old_print_pages_params_.get() &&
+      PrintMsg_Print_Params_IsEqual(*old_print_pages_params_,
+                                    *print_pages_params_)) {
+    PrintHostMsg_DidPreviewDocument_Params preview_params;
+    preview_params.reuse_existing_data = true;
+    preview_params.data_size = 0;
+    preview_params.document_cookie =
+        print_pages_params_->params.document_cookie;
+    preview_params.expected_pages_count = print_preview_context_.page_count();
+    preview_params.modifiable = print_preview_context_.IsModifiable();
+    preview_params.preview_request_id =
+        print_pages_params_->params.preview_request_id;
+
+    Send(new PrintHostMsg_PagesReadyForPreview(routing_id(), preview_params));
+    return;
+  }
+
+  // PDF printer device supports alpha blending.
+  print_pages_params_->params.supports_alpha_blend = true;
+  if (!CreatePreviewDocument())
+    DidFinishPrinting(FAIL_PREVIEW);
+}
+
+bool PrintWebViewHelper::CreatePreviewDocument() {
+  PrintMsg_Print_Params printParams = print_pages_params_->params;
+  UpdatePrintableSizeInPrintParameters(print_preview_context_.frame(),
+                                       print_preview_context_.node(),
+                                       &printParams);
+
+  const std::vector<int>& pages = print_pages_params_->pages;
+  if (!print_preview_context_.CreatePreviewDocument(printParams, pages))
+    return false;
+  int page_count = print_preview_context_.page_count();
+  Send(new PrintHostMsg_DidGetPreviewPageCount(routing_id(), page_count));
+  PreviewPageRendered(-1);
+  return true;
+}
+
+void PrintWebViewHelper::OnContinuePreview() {
+  // Spurious message. We already finished/cancelled/aborted the print preview.
+  if (!print_preview_context_.IsBusy())
+    return;
+
+  int page_number = -1;
+  if (!print_preview_context_.GetNextPage(&page_number)) {
+    // Continue generating the print preview.
+    RenderPreviewPage(page_number);
+    return;
+  }
+
+  // Finished generating preview. Finalize the document.
+  if (!FinalizePreviewDocument())
+    DidFinishPrinting(FAIL_PREVIEW);
+}
+
+void PrintWebViewHelper::OnCancelPreview() {
+  DidFinishPrinting(CANCEL_PREVIEW);
+  return;
+}
+
+void PrintWebViewHelper::OnAbortPreview() {
+  DidFinishPrinting(ABORT_PREVIEW);
+  return;
+}
+
+bool PrintWebViewHelper::FinalizePreviewDocument() {
+  print_preview_context_.FinalizePreviewDocument();
+
+  // Get the size of the resulting metafile.
+  printing::Metafile* metafile = print_preview_context_.metafile();
+  uint32 buf_size = metafile->GetDataSize();
+  DCHECK_GT(buf_size, 0u);

[kmadhusu, 2011/07/15 01:22:46]

http://codereview.chromium.org/7365003/diff/9001/chrome/renderer/print_web_vi...

Ref line: 194 

It says, the metafile file size should be greater than 128u on Win. 

[Lei Zhang, 2011/07/15 01:48:02]

That was a copy and paste from the Windows EMF printing code. Why does our PDF
file have to be > 128 bytes on Windows but not on Linux/Mac?

+
+  PrintHostMsg_DidPreviewDocument_Params preview_params;
+  preview_params.reuse_existing_data = false;
+  preview_params.data_size = buf_size;
+  preview_params.document_cookie = print_pages_params_->params.document_cookie;
+  preview_params.expected_pages_count = print_preview_context_.page_count();
+  preview_params.modifiable = print_preview_context_.IsModifiable();
+  preview_params.preview_request_id =
+      print_pages_params_->params.preview_request_id;
+
+  // Ask the browser to create the shared memory for us.
+  if (!CopyMetafileDataToSharedMem(metafile,
+                                   &(preview_params.metafile_data_handle))) {
+    return false;
+  }
+#if defined(OS_WIN)
+  Send(new PrintHostMsg_DuplicateSection(routing_id(),
+                                         preview_params.metafile_data_handle,
+                                         &preview_params.metafile_data_handle));
+#endif
+  Send(new PrintHostMsg_PagesReadyForPreview(routing_id(), preview_params));
+  return true;
 }
 
 void PrintWebViewHelper::OnPrintingDone(bool success) {
   notify_browser_of_print_failure_ = false;
   DidFinishPrinting(success ? OK : FAIL_PRINT);
 }
 
 void PrintWebViewHelper::OnPrintNodeUnderContextMenu() {
   const WebNode& context_menu_node = render_view()->context_menu_node();
   if (context_menu_node.isNull()) {
     NOTREACHED();
     return;
   }
 
   // Make a copy of the node, in case RenderView::OnContextMenuClosed resets
   // its |context_menu_node_|.
   if (is_preview_) {
-    context_menu_preview_node_.reset(new WebNode(context_menu_node));
-    script_initiated_preview_frame_ = NULL;
+    print_preview_context_.InitWithNode(context_menu_node);
     RequestPrintPreview();
   } else {
     WebNode duplicate_node(context_menu_node);
     Print(duplicate_node.document().frame(), &duplicate_node);
   }
 }
 
 void PrintWebViewHelper::OnInitiatePrintPreview() {
   DCHECK(is_preview_);
-  script_initiated_preview_frame_ = NULL;
-  context_menu_preview_node_.reset();
+  WebFrame* frame;
+  if (GetPrintFrame(&frame))

[kmadhusu, 2011/07/15 01:22:46]

Handle the else case.

[Lei Zhang, 2011/07/15 01:48:02]

The else case is to do nothing. I changed this to reflect that.

+    print_preview_context_.InitWithFrame(frame);
   RequestPrintPreview();
 }
 
 void PrintWebViewHelper::Print(WebKit::WebFrame* frame, WebKit::WebNode* node) {
   // If still not finished with earlier print request simply ignore.
   if (print_web_view_)
     return;
 
   // Initialize print settings.
   if (!InitPrintSettings(frame, node))
@@ skipping 24 matching lines @@
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame, node))
     DidFinishPrinting(FAIL_PRINT);
   ResetScriptedPrintCount();
 }
 
-void PrintWebViewHelper::PrintPreview(WebKit::WebFrame* frame,
-                                      WebKit::WebNode* node,
-                                      const DictionaryValue& settings) {
-  DCHECK(is_preview_);
-
-  if (!InitPrintSettings(frame, node)) {
-    NOTREACHED() << "Failed to initialize print page settings";
-    return;
-  }
-
-  if (!UpdatePrintSettings(settings)) {
-    DidFinishPrinting(FAIL_PREVIEW);
-    return;
-  }
-
-  if (print_pages_params_->params.preview_request_id != 0 &&
-      old_print_pages_params_.get() &&
-      PrintMsg_Print_Params_IsEqual(*old_print_pages_params_,
-                                    *print_pages_params_)) {
-    PrintHostMsg_DidPreviewDocument_Params preview_params;
-    preview_params.reuse_existing_data = true;
-    preview_params.data_size = 0;
-    preview_params.document_cookie =
-        print_pages_params_->params.document_cookie;
-    preview_params.expected_pages_count = preview_page_count_;
-    preview_params.modifiable = IsModifiable(frame, node);
-    preview_params.preview_request_id =
-        print_pages_params_->params.preview_request_id;
-
-    Send(new PrintHostMsg_PagesReadyForPreview(routing_id(), preview_params));
-    return;
-  }
-
-  // Render Pages for preview.
-  if (!RenderPagesForPreview(frame, node))
-    DidFinishPrinting(FAIL_PREVIEW);
-}
-
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   bool store_print_pages_params = true;
   if (result == FAIL_PRINT) {
     DisplayPrintJobError();
 
     if (notify_browser_of_print_failure_) {
       int cookie = print_pages_params_->params.document_cookie;
       Send(new PrintHostMsg_PrintingFailed(routing_id(), cookie));
     }
   } else if (result == FAIL_PREVIEW) {
+    DCHECK(is_preview_);
+    store_print_pages_params = false;
     int cookie = print_pages_params_->params.document_cookie;
+    Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
+    print_preview_context_.Abort();
+  } else if (result == CANCEL_PREVIEW) {
+    DCHECK(is_preview_);
     store_print_pages_params = false;
-    if (notify_browser_of_print_failure_) {
-      Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
-    } else {
-      Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
-    }
+    print_preview_context_.Cancel();
+  } else if (result == ABORT_PREVIEW) {
+    DCHECK(is_preview_);
+    store_print_pages_params = false;
+    print_preview_context_.Abort();
+  } else if (result == OK && is_preview_) {
+    print_preview_context_.Finished();
   }
 
   if (print_web_view_) {
     print_web_view_->close();
     print_web_view_ = NULL;
   }
 
   if (store_print_pages_params) {
     old_print_pages_params_.reset(print_pages_params_.release());
   } else {
@@ skipping 143 matching lines @@
     *margin_right_in_points =
         ConvertPixelsToPointDouble(margin_right_in_pixels);
   if (margin_bottom_in_points)
     *margin_bottom_in_points =
         ConvertPixelsToPointDouble(margin_bottom_in_pixels);
   if (margin_left_in_points)
     *margin_left_in_points =
         ConvertPixelsToPointDouble(margin_left_in_pixels);
 }
 
-bool PrintWebViewHelper::IsModifiable(WebKit::WebFrame* frame,
-                                      WebKit::WebNode* node) {
-  if (node)
-    return false;
-  std::string mime(frame->dataSource()->response().mimeType().utf8());
-  if (mime == "application/pdf")
-    return false;
-  return true;
-}
-
 void PrintWebViewHelper::UpdatePrintableSizeInPrintParameters(
     WebFrame* frame,
     WebNode* node,
     PrintMsg_Print_Params* params) {
   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;
@@ skipping 20 matching lines @@
       static_cast<int>(ConvertUnitDouble(
           page_height_in_points, printing::kPointsPerInch, dpi)));
 
   params->margin_top = static_cast<int>(ConvertUnitDouble(
       margin_top_in_points, printing::kPointsPerInch, dpi));
   params->margin_left = static_cast<int>(ConvertUnitDouble(
       margin_left_in_points, printing::kPointsPerInch, dpi));
 }
 
 bool PrintWebViewHelper::InitPrintSettings(WebKit::WebFrame* frame,
                                            WebKit::WebNode* node) {

[kmadhusu, 2011/07/15 01:22:46]

Add DCHECK(frame) here.

[Lei Zhang, 2011/07/15 01:48:02]

Done.

   PrintMsg_PrintPages_Params settings;
 
   // TODO(abodenha@chromium.org) It doesn't make sense to do this if our
   // "default" is a cloud based printer.  Split InitPrintSettings up
   // so that we can avoid the overhead of unneeded calls into the native
   // print system.
   Send(new PrintHostMsg_GetDefaultPrintSettings(routing_id(),
                                                 &settings.params));
   // Check if the printer returned any settings, if the settings is empty, we
   // can safely assume there are no printer drivers configured. So we safely
@@ skipping 105 matching lines @@
                                              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);
   }
 }
 
-bool PrintWebViewHelper::RenderPagesForPreview(WebKit::WebFrame* frame,
-                                               WebKit::WebNode* node) {
-  PrintMsg_PrintPages_Params print_settings = *print_pages_params_;
-  // PDF printer device supports alpha blending.
-  print_settings.params.supports_alpha_blend = true;
-  // TODO(kmadhusu): Handle print selection.
-  return CreatePreviewDocument(print_settings, frame, node);
-}
-
-base::TimeTicks PrintWebViewHelper::ReportPreviewPageRenderTime(
-    base::TimeTicks start_time) {
-  base::TimeTicks now = base::TimeTicks::Now();
-  UMA_HISTOGRAM_TIMES("PrintPreview.RenderPDFPageTime", now - start_time);
-  return now;
-}
-
-void PrintWebViewHelper::ReportTotalPreviewGenerationTime(
-        int selected_pages_length, int total_pages,
-        base::TimeDelta render_time, base::TimeDelta total_time) {
-  if (selected_pages_length == 0)
-    selected_pages_length = total_pages;
-
-  if (selected_pages_length <= 0) {
-    // This shouldn't happen, but this makes sure it doesn't affect the
-    // statistics if it does.
-    return;
-  }
-
-  UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderToPDFTime",
-                             render_time);
-  UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTime",
-                             total_time);
-  UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTimeAvgPerPage",
-                             total_time / selected_pages_length);
-}
-
 #if defined(OS_POSIX)
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     printing::Metafile* metafile,
     base::SharedMemoryHandle* shared_mem_handle) {
   uint32 buf_size = metafile->GetDataSize();
   base::SharedMemoryHandle mem_handle;
   Send(new ViewHostMsg_AllocateSharedMemoryBuffer(buf_size, &mem_handle));
   if (base::SharedMemory::IsHandleValid(mem_handle)) {
     base::SharedMemory shared_buf(mem_handle, false);
     if (shared_buf.Map(buf_size)) {
       metafile->GetData(shared_buf.memory(), buf_size);
       shared_buf.GiveToProcess(base::GetCurrentProcessHandle(),
                                shared_mem_handle);
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 #endif  // defined(OS_POSIX)
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintTooFrequent(
     WebKit::WebFrame* frame) {
   const int kMinSecondsToIgnoreJavascriptInitiatedPrint = 2;
   const int kMaxSecondsToIgnoreJavascriptInitiatedPrint = 32;
+  bool too_frequent = false;

[kmadhusu, 2011/07/15 01:22:46]

Declare this variable after the comments

[Lei Zhang, 2011/07/15 01:48:02]

I don't think it helps with readability.

 
   // Check if there is script repeatedly trying to print and ignore it if too
   // frequent.  The first 3 times, we use a constant wait time, but if this
   // gets excessive, we switch to exponential wait time. So for a page that
   // calls print() in a loop the user will need to cancel the print dialog
   // after: [2, 2, 2, 4, 8, 16, 32, 32, ...] seconds.
   // This gives the user time to navigate from the page.
   if (user_cancelled_scripted_print_count_ > 0) {
     base::TimeDelta diff = base::Time::Now() - last_cancelled_script_print_;
     int min_wait_seconds = kMinSecondsToIgnoreJavascriptInitiatedPrint;
     if (user_cancelled_scripted_print_count_ > 3) {
       min_wait_seconds = std::min(
           kMinSecondsToIgnoreJavascriptInitiatedPrint <<
               (user_cancelled_scripted_print_count_ - 3),
           kMaxSecondsToIgnoreJavascriptInitiatedPrint);
     }
     if (diff.InSeconds() < min_wait_seconds) {
-      WebString message(WebString::fromUTF8(
-          "Ignoring too frequent calls to print()."));
-      frame->addMessageToConsole(WebConsoleMessage(
-          WebConsoleMessage::LevelWarning,
-          message));
-      return true;
+      too_frequent = true;
     }
   }
-  return false;
+
+  if (!too_frequent && print_preview_context_.IsBusy())
+    too_frequent = true;
+
+  if (!too_frequent)
+    return false;
+
+  WebString message(WebString::fromUTF8(
+      "Ignoring too frequent calls to print()."));
+  frame->addMessageToConsole(WebConsoleMessage(WebConsoleMessage::LevelWarning,
+                                               message));
+  return true;
 }
 
 void PrintWebViewHelper::ResetScriptedPrintCount() {
   // Reset cancel counter on successful print.
   user_cancelled_scripted_print_count_ = 0;
 }
 
 void PrintWebViewHelper::IncrementScriptedPrintCount() {
   ++user_cancelled_scripted_print_count_;
   last_cancelled_script_print_ = base::Time::Now();
 }
 
 void PrintWebViewHelper::DisplayPrintJobError() {
   WebView* web_view = print_web_view_;
   if (!web_view)
     web_view = render_view()->webview();
 
   render_view()->runModalAlertDialog(
       web_view->mainFrame(),
       l10n_util::GetStringUTF16(IDS_PRINT_SPOOL_FAILED_ERROR_TEXT));
 }
 
 void PrintWebViewHelper::RequestPrintPreview() {
   old_print_pages_params_.reset();
   Send(new PrintHostMsg_RequestPrintPreview(routing_id()));
 }
 
-bool PrintWebViewHelper::PreviewPageRendered(int page_number) {
-  bool cancel = false;
-  Send(new PrintHostMsg_DidPreviewPage(routing_id(), page_number, &cancel));
-  if (cancel)
-    notify_browser_of_print_failure_ = false;
-  return !cancel;
+void PrintWebViewHelper::PreviewPageRendered(int page_number) {
+  int cookie = print_pages_params_->params.document_cookie;
+  Send(new PrintHostMsg_DidPreviewPage(routing_id(), page_number, cookie));
 }
+
+PrintWebViewHelper::PrintPreviewContext::PrintPreviewContext()
+    : frame_(NULL),
+      page_count_(0),
+      actual_page_count_(0),
+      current_page_(0),
+      state_(UNINITIALIZED) {
+}
+
+void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
+    WebKit::WebFrame* web_frame) {
+  DCHECK(web_frame);
+  if (IsInitialized())
+    return;
+  state_ = INITIALIZED;
+  frame_ = web_frame;
+  node_.reset();
+}
+
+void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
+    const WebKit::WebNode& web_node) {
+  DCHECK(!web_node.isNull());
+  if (IsInitialized())
+    return;
+  state_ = INITIALIZED;
+  frame_ = web_node.document().frame();
+  node_.reset(new WebNode(web_node));
+}
+
+void PrintWebViewHelper::PrintPreviewContext::OnPrintPreview() {
+  DCHECK(IsInitialized());
+  Reset();
+}
+
+bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
+    const PrintMsg_Print_Params& printParams,
+    const std::vector<int>& pages) {
+  DCHECK(IsInitialized());

[kmadhusu, 2011/07/15 01:22:46]

If (!IsInitialized())
  return false;

is better than DCHECK()

[Lei Zhang, 2011/07/15 01:48:02]

The DCHECK should never fail. If it fails in a release build, then just crash.
That way we will actually see the problem and we can figure out how to deal with
it. (One way to deal with it is to do what you suggested)

+  state_ = PRINTING;
+
+  print_params_.reset(new PrintMsg_Print_Params(printParams));
+
+  metafile_.reset(new printing::PreviewMetafile);
+  if (!metafile_->Init())
+    return false;
+
+  // Need to make sure old object gets destroyed first.
+  prep_frame_view_.reset(new PrepareFrameAndViewForPrint(printParams,
+                                                         frame(),

[kmadhusu, 2011/07/15 01:22:46]

nit: frame() can fit in the previous line.

[Lei Zhang, 2011/07/15 01:48:02]

Done.

+                                                         node(),
+                                                         frame()->view()));
+  page_count_ = prep_frame_view_->GetExpectedPageCount();
+  if (page_count_ == 0)
+    return false;
+
+  current_page_ = 0;
+  if (pages.empty()) {

[kmadhusu, 2011/07/15 01:22:46]

How about:

actual_page_count = pages.empty()? page_count_ : pages.size();

if (actual_page_count_) {
line 956
} else {
  lines 959 - 964
}

[Lei Zhang, 2011/07/15 01:48:02]

Your logic is wrong.

[kmadhusu, 2011/07/15 19:25:46]

oops.. I meant if (actual_page_count_ == page_count_)

+    actual_page_count_ = page_count_;
+    rendered_pages_ = std::vector<bool>(page_count_, false);
+  } else {
+    actual_page_count_ = pages.size();
+    rendered_pages_ = std::vector<bool>(page_count_, true);
+    for (size_t i = 0; i < pages.size(); ++i) {

[kmadhusu, 2011/07/15 01:22:46]

"i < actual_page_count_"

[Lei Zhang, 2011/07/15 01:48:02]

Done.

+      int page_number = pages[i];
+      if (page_number < 0 || page_number >= page_count_)
+        return false;
+      rendered_pages_[page_number] = false;
+    }
+  }
+
+  document_render_time_ = base::TimeDelta();
+  begin_time_ = base::TimeTicks::Now();
+
+  return true;
+}
+
+void PrintWebViewHelper::PrintPreviewContext::RenderedPreviewPage(
+    const base::TimeDelta& page_time) {
+  DCHECK_EQ(PRINTING, state_);
+  document_render_time_ += page_time;
+  UMA_HISTOGRAM_TIMES("PrintPreview.RenderPDFPageTime", page_time);
+}
+
+void PrintWebViewHelper::PrintPreviewContext::FinalizePreviewDocument() {
+  DCHECK_EQ(PRINTING, state_);
+  state_ = DONE;
+
+  base::TimeTicks begin_time = base::TimeTicks::Now();
+
+  prep_frame_view_->FinishPrinting();

[kmadhusu, 2011/07/15 01:22:46]

Please retain the previous comment.

http://codereview.chromium.org/7365003/diff/9001/chrome/renderer/print_web_vi...

Ref line: 178

[Lei Zhang, 2011/07/15 01:48:02]

We have the comment on Windows only, but not Linux and Mac. I think we are fine
without it.

+  metafile_->FinishDocument();

[kmadhusu, 2011/07/15 01:22:46]

if (!metafile->FinishDocument)
  NOTREACHED();

[Lei Zhang, 2011/07/15 01:48:02]

Again, we don't have it on Mac/Linux.

[kmadhusu, 2011/07/15 19:25:46]

At least on linux, we should have handled this case.
PdfMetafileSkia::FinishDocument can return true/false. So its better to handle
it now. 

+
+  if (actual_page_count_ <= 0) {
+    NOTREACHED();
+    return;
+  }
+
+  UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderToPDFTime",
+                             document_render_time_);
+  base::TimeDelta total_time = (base::TimeTicks::Now() - begin_time) +
+      document_render_time_;

[kmadhusu, 2011/07/15 01:22:46]

nit: Fix indentation.

[Lei Zhang, 2011/07/15 01:48:02]

Done.

+  UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTime",
+                             total_time);
+  UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderAndGeneratePDFTimeAvgPerPage",
+                             total_time / actual_page_count_);
+}
+
+void PrintWebViewHelper::PrintPreviewContext::Finished() {
+  DCHECK_EQ(DONE, state_);
+  Reset();
+}
+
+void PrintWebViewHelper::PrintPreviewContext::Abort() {
+  state_ = UNINITIALIZED;
+  Reset();
+  frame_ = NULL;
+  node_.reset();
+}
+
+void PrintWebViewHelper::PrintPreviewContext::Cancel() {
+  DCHECK(IsInitialized());
+  state_ = DONE;
+  Reset();
+}
+
+bool PrintWebViewHelper::PrintPreviewContext::GetNextPage(
+    int* page_number) {
+  DCHECK_EQ(PRINTING, state_);
+  while (current_page_ < page_count_ && rendered_pages_[current_page_])
+    ++current_page_;
+  if (current_page_ == page_count_)
+    return true;
+  rendered_pages_[current_page_] = true;
+  *page_number = current_page_++;
+  return false;
+}
+
+bool PrintWebViewHelper::PrintPreviewContext::IsInitialized() const {

[kmadhusu, 2011/07/15 01:22:46]

I was expecting "return state_ == INITIALIZED;" as the function definition. 

The function name is misleading. Either change the name or the definition. 

[Lei Zhang, 2011/07/15 01:48:02]

Changed to "IsReadyToRender()"

+  return state_ != UNINITIALIZED;
+}
+
+bool PrintWebViewHelper::PrintPreviewContext::IsBusy() const {

[kmadhusu, 2011/07/15 01:22:46]

This function needs a better name. 

state PRINTING == Busy
state INITIALIZED != BUSY ( it is a ready state).

[Lei Zhang, 2011/07/15 01:48:02]

I can't think of a better name. "Busy" is relative and here INITIALIZED is
"busy".

+  return state_ == INITIALIZED || state_ == PRINTING;
+}
+
+bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() const {
+  if (node())
+    return false;
+  std::string mime(frame()->dataSource()->response().mimeType().utf8());
+  if (mime == "application/pdf")

[kmadhusu, 2011/07/15 01:22:46]

Instead of lines 1047-1049, use 

return mime != "application/pdf";

[Lei Zhang, 2011/07/15 01:48:02]

Done.

+    return false;
+  return true;
+}
+
+WebKit::WebFrame* PrintWebViewHelper::PrintPreviewContext::frame() const {
+  return frame_;
+}
+
+WebKit::WebNode* PrintWebViewHelper::PrintPreviewContext::node() const {
+  return node_.get();
+}
+
+int PrintWebViewHelper::PrintPreviewContext::page_count() const {
+  return page_count_;
+}
+
+printing::Metafile* PrintWebViewHelper::PrintPreviewContext::metafile() const {
+  return metafile_.get();
+}
+
+const PrintMsg_Print_Params&
+PrintWebViewHelper::PrintPreviewContext::print_params() const {
+  return *print_params_;
+}
+
+const gfx::Size&
+PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
+  return prep_frame_view_->GetPrintCanvasSize();
+}
+
+void PrintWebViewHelper::PrintPreviewContext::Reset() {
+  prep_frame_view_.reset();
+  metafile_.reset();
+  rendered_pages_.clear();
+}