Print Preview: Prevent a crash and add error logging.

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"
 
 #if defined(OS_MACOSX) && !defined(USE_SKIA)
 #include <CoreGraphics/CGContext.h>
 #endif
 
@@ skipping 559 matching lines @@
   }
 
   WebFrame* pdf_frame = pdf_element.document().frame();
   scoped_ptr<PrepareFrameAndViewForPrint> prepare;
   if (!InitPrintSettingsAndPrepareFrame(pdf_frame, &pdf_element, &prepare)) {
     NOTREACHED() << "Failed to initialize print page settings";
     return;
   }
 
   if (!UpdatePrintSettings(job_settings, false)) {
+    LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
   // Render Pages for printing.
-  if (!RenderPagesForPrint(pdf_frame, &pdf_element, prepare.get()))
+  if (!RenderPagesForPrint(pdf_frame, &pdf_element, prepare.get())) {
+    LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
+  }
 }
 
 bool PrintWebViewHelper::GetPrintFrame(WebKit::WebFrame** frame) {
   DCHECK(frame);
   DCHECK(render_view()->webview());
   if (!render_view()->webview())
     return false;
 
   // If the user has selected text in the currently focused frame we print
   // only that frame (this makes print selection work for multiple frames).
@@ skipping 31 matching lines @@
   DCHECK(is_preview_);
   print_preview_context_.OnPrintPreview();
 
   if (!InitPrintSettings(print_preview_context_.frame(),
                          print_preview_context_.node())) {
     NOTREACHED();
     return;
   }
 
   if (!UpdatePrintSettings(settings, true)) {
+    LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (!print_pages_params_->params.is_first_request &&
       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_.total_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;
   }
   // Always clear |old_print_pages_params_| before rendering the pages.
   old_print_pages_params_.reset();
 
   // PDF printer device supports alpha blending.
   print_pages_params_->params.supports_alpha_blend = true;
-  if (CreatePreviewDocument())
+  if (CreatePreviewDocument()) {
     DidFinishPrinting(OK);
-  else
+  } else {
+    if (notify_browser_of_print_failure_)
+      LOG(ERROR) << "CreatePreviewDocument failed";
     DidFinishPrinting(FAIL_PREVIEW);
+  }
 }
 
 bool PrintWebViewHelper::CreatePreviewDocument() {
   PrintMsg_Print_Params print_params = print_pages_params_->params;
   const std::vector<int>& pages = print_pages_params_->pages;
   if (!print_preview_context_.CreatePreviewDocument(&print_params, pages))
     return false;
   PrintHostMsg_DidGetPreviewPageCount_Params params;
   params.page_count = print_preview_context_.total_page_count();
   params.is_modifiable = print_preview_context_.IsModifiable();
@@ skipping 32 matching lines @@
   preview_params.document_cookie = print_pages_params_->params.document_cookie;
   preview_params.expected_pages_count =
       print_preview_context_.total_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))) {
+    LOG(ERROR) << "CopyMetafileDataToSharedMem failed";
     return false;
   }
   Send(new PrintHostMsg_PagesReadyForPreview(routing_id(), preview_params));
   return true;
 }
 
 void PrintWebViewHelper::OnPrintingDone(bool success) {
   notify_browser_of_print_failure_ = false;
+  if (success == FAIL_PRINT)
+    LOG(ERROR) << "Failure in OnPrintingDone";
   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;
   }
 
@@ skipping 45 matching lines @@
   }
 
   // Ask the browser to show UI to retrieve the final print settings.
   if (!GetPrintSettingsFromUser(frame, 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, NULL)) {
+    LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
+  }
   ResetScriptedPrintCount();
 }
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   bool store_print_pages_params = true;
   if (result == FAIL_PRINT) {
     DisplayPrintJobError();
 
-    if (notify_browser_of_print_failure_) {
+    if (notify_browser_of_print_failure_ && print_pages_params_.get()) {
       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;
     if (notify_browser_of_print_failure_)
       Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
     else
@@ skipping 438 matching lines @@
     NOTREACHED();
     return false;
   }
 
   PrintHostMsg_DidPreviewPage_Params preview_page_params;
   // Get the size of the resulting metafile.
   uint32 buf_size = metafile->GetDataSize();
   DCHECK_GT(buf_size, 0u);
   if (!CopyMetafileDataToSharedMem(
       metafile, &(preview_page_params.metafile_data_handle))) {
+    LOG(ERROR) << "CopyMetafileDataToSharedMem failed";
     return false;
   }
   preview_page_params.data_size = buf_size;
   preview_page_params.page_number = page_number;
   preview_page_params.preview_request_id =
       print_pages_params_->params.preview_request_id;
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
   return true;
 }
@@ skipping 32 matching lines @@
 
 bool PrintWebViewHelper::PrintPreviewContext::CreatePreviewDocument(
     PrintMsg_Print_Params* print_params,
     const std::vector<int>& pages) {
   DCHECK(IsReadyToRender());
   state_ = RENDERING;
 
   print_params_.reset(new PrintMsg_Print_Params(*print_params));
 
   metafile_.reset(new printing::PreviewMetafile);
-  if (!metafile_->Init())
+  if (!metafile_->Init()) {
+    LOG(ERROR) << "PreviewMetafile Init failed";
     return false;
+  }
 
   // Need to make sure old object gets destroyed first.
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(*print_params, frame(),
                                                          node()));
   UpdatePrintableSizeInPrintParameters(frame_, node_.get(),
                                        prep_frame_view_.get(), print_params);
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
-  if (total_page_count_ == 0)
+  if (total_page_count_ == 0) {
+    LOG(ERROR) << "CreatePreviewDocument got 0 page count";
     return false;
+  }
 
   current_page_index_ = 0;
   if (pages.empty()) {
     actual_page_count_ = total_page_count_;
     for (int i = 0; i < actual_page_count_; ++i)
       pages_to_render_.push_back(i);
   } else {
     actual_page_count_ = pages.size();
     for (int i = 0; i < actual_page_count_; ++i) {
       int page_number = pages[i];
       if (page_number < printing::FIRST_PAGE_INDEX ||
           page_number >= total_page_count_) {
+        LOG(ERROR) << "CreatePreviewDocument got invalid page count "
+                << page_number << " at index " << i;
         return false;
       }
       pages_to_render_.push_back(page_number);
     }
   }
 
   document_render_time_ = base::TimeDelta();
   begin_time_ = base::TimeTicks::Now();
 
   return true;
@@ skipping 88 matching lines @@
 const gfx::Size&
 PrintWebViewHelper::PrintPreviewContext::GetPrintCanvasSize() const {
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
 }