Use document from preview for System Dialog printing on Windows.

chrome/renderer/printing/print_web_view_helper.cc

+// Use of this source code is governed by a BSD-style license that can be

[Noam Samuel, 2014/08/20 00:04:17]

??? Pretty sure this line doesn't need to be moved.

[Vitaly Buka (NO REVIEWS), 2014/08/20 02:42:55]

Done.

 // 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 <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 71 matching lines @@
   return kPointsPerInch;
 #else
   return static_cast<int>(print_params->dpi);
 #endif  // defined(OS_MACOSX)
 }
 
 bool PrintMsg_Print_Params_IsValid(const PrintMsg_Print_Params& params) {
   return !params.content_size.IsEmpty() && !params.page_size.IsEmpty() &&
          !params.printable_area.IsEmpty() && params.document_cookie &&
          params.desired_dpi && params.max_shrink && params.min_shrink &&
-         params.dpi && (params.margin_top >= 0) && (params.margin_left >= 0);
+         params.dpi && (params.margin_top >= 0) && (params.margin_left >= 0) &&
+         params.dpi > kMinDpi && params.document_cookie != 0;
 }
 
 PrintMsg_Print_Params GetCssPrintParams(
     blink::WebFrame* frame,
     int page_index,
     const PrintMsg_Print_Params& page_params) {
   PrintMsg_Print_Params page_css_params = page_params;
   int dpi = GetDPI(&page_params);
 
   blink::WebSize page_size_in_pixels(
@@ skipping 908 matching lines @@
   if (!print_preview_context_.source_frame()) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   if (!UpdatePrintSettings(print_preview_context_.source_frame(),
                            print_preview_context_.source_node(), settings)) {
     if (print_preview_context_.last_error() != PREVIEW_ERROR_BAD_SETTING) {
       Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
           routing_id(),
-          print_pages_params_ ?
-              print_pages_params_->params.document_cookie : 0));
+          print_pages_params() ? print_pages_params()->params.document_cookie
+                               : 0));
       notify_browser_of_print_failure_ = false;  // Already sent.
     }
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   // Set the options from document if we are previewing a pdf and send a
   // message to browser.
-  if (print_pages_params_->params.is_first_request &&
+  if (print_pages_params()->params.is_first_request &&
       !print_preview_context_.IsModifiable()) {
     PrintHostMsg_SetOptionsFromDocument_Params params;
     SetOptionsFromDocument(params);
     Send(new PrintHostMsg_SetOptionsFromDocument(routing_id(), params));
   }
 
   is_print_ready_metafile_sent_ = false;
 
   // PDF printer device supports alpha blending.
   print_pages_params_->params.supports_alpha_blend = true;
 
   bool generate_draft_pages = false;
   if (!settings.GetBoolean(kSettingGenerateDraftData,
                            &generate_draft_pages)) {
     NOTREACHED();
   }
   print_preview_context_.set_generate_draft_pages(generate_draft_pages);
 
   PrepareFrameForPreviewDocument();
 }
 
 void PrintWebViewHelper::PrepareFrameForPreviewDocument() {
   reset_prep_frame_view_ = false;
 
-  if (!print_pages_params_ || CheckForCancel()) {
+  if (!print_pages_params() || CheckForCancel()) {
     DidFinishPrinting(FAIL_PREVIEW);
     return;
   }
 
   // Don't reset loading frame or WebKit will fail assert. Just retry when
   // current selection is loaded.
   if (prep_frame_view_ && prep_frame_view_->IsLoadingSelection()) {
     reset_prep_frame_view_ = true;
     return;
   }
 
-  const PrintMsg_Print_Params& print_params = print_pages_params_->params;
+  const PrintMsg_Print_Params& print_params = print_pages_params()->params;
   prep_frame_view_.reset(
       new PrepareFrameAndViewForPrint(print_params,
                                       print_preview_context_.source_frame(),
                                       print_preview_context_.source_node(),
                                       ignore_css_margins_));
   prep_frame_view_->CopySelectionIfNeeded(
       render_view()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPreviewDocument,
                  base::Unretained(this)));
 }
 
 void PrintWebViewHelper::OnFramePreparedForPreviewDocument() {
   if (reset_prep_frame_view_) {
     PrepareFrameForPreviewDocument();
     return;
   }
   DidFinishPrinting(CreatePreviewDocument() ? OK : FAIL_PREVIEW);
 }
 
 bool PrintWebViewHelper::CreatePreviewDocument() {
-  if (!print_pages_params_ || CheckForCancel())
+  if (!print_pages_params() || CheckForCancel())
     return false;
 
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.PreviewEvent",
                             PREVIEW_EVENT_CREATE_DOCUMENT, PREVIEW_EVENT_MAX);
 
-  const PrintMsg_Print_Params& print_params = print_pages_params_->params;
-  const std::vector<int>& pages = print_pages_params_->pages;
+  const PrintMsg_Print_Params& print_params = print_pages_params()->params;
+  const std::vector<int>& pages = print_pages_params()->pages;
 
   if (!print_preview_context_.CreatePreviewDocument(prep_frame_view_.release(),
                                                     pages)) {
     return false;
   }
 
   PageSizeMargins default_page_layout;
   ComputePageLayoutInPointsForCss(print_preview_context_.prepared_frame(), 0,
                                   print_params, ignore_css_margins_, NULL,
                                   &default_page_layout);
@@ skipping 59 matching lines @@
   DCHECK(!is_print_ready_metafile_sent_);
   print_preview_context_.FinalizePrintReadyDocument();
 
   // Get the size of the resulting metafile.
   PreviewMetafile* metafile = print_preview_context_.metafile();
   uint32 buf_size = metafile->GetDataSize();
   DCHECK_GT(buf_size, 0u);
 
   PrintHostMsg_DidPreviewDocument_Params preview_params;
   preview_params.data_size = buf_size;
-  preview_params.document_cookie = print_pages_params_->params.document_cookie;
+  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;
+      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";
     print_preview_context_.set_error(PREVIEW_ERROR_METAFILE_COPY_FAILED);
     return false;
   }
   is_print_ready_metafile_sent_ = true;
 
@@ skipping 96 matching lines @@
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
   switch (result) {
     case OK:
       break;
 
     case FAIL_PRINT_INIT:
       DCHECK(!notify_browser_of_print_failure_);
       break;
 
     case FAIL_PRINT:
-      if (notify_browser_of_print_failure_ && print_pages_params_) {
-        int cookie = print_pages_params_->params.document_cookie;
+      if (notify_browser_of_print_failure_ && print_pages_params()) {
+        int cookie = print_pages_params()->params.document_cookie;
         Send(new PrintHostMsg_PrintingFailed(routing_id(), cookie));
       }
       break;
 
     case FAIL_PREVIEW:
       DCHECK(is_preview_enabled_);
-      int cookie = print_pages_params_ ?
-          print_pages_params_->params.document_cookie : 0;
+      int cookie = print_pages_params()
+                       ? print_pages_params()->params.document_cookie
+                       : 0;
       if (notify_browser_of_print_failure_) {
         LOG(ERROR) << "CreatePreviewDocument failed";
         Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
       } else {
         Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
       }
       print_preview_context_.Failed(notify_browser_of_print_failure_);
       break;
   }
   prep_frame_view_.reset();
@@ skipping 10 matching lines @@
   if (!prep_frame_view_)  // Printing is already canceled or failed.
     return;
   prep_frame_view_->StartPrinting();
 
   int page_count = prep_frame_view_->GetExpectedPageCount();
   if (!page_count) {
     LOG(ERROR) << "Can't print 0 pages.";
     return DidFinishPrinting(FAIL_PRINT);
   }
 
-  const PrintMsg_PrintPages_Params& params = *print_pages_params_;
+  const PrintMsg_PrintPages_Params& params = *print_pages_params();
   const PrintMsg_Print_Params& print_params = params.params;
 
 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
   // 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  // !defined(OS_CHROMEOS)
 
@@ skipping 18 matching lines @@
 
 void PrintWebViewHelper::FinishFramePrinting() {
   prep_frame_view_.reset();
 }
 
 #if defined(OS_MACOSX) || \
     (defined(OS_WIN) && !defined(WIN_PDF_METAFILE_FOR_PRINTING))
 bool PrintWebViewHelper::PrintPagesNative(blink::WebFrame* frame,
                                           int page_count,
                                           const gfx::Size& canvas_size) {
-  const PrintMsg_PrintPages_Params& params = *print_pages_params_;
+  const PrintMsg_PrintPages_Params& params = *print_pages_params();
   const PrintMsg_Print_Params& print_params = params.params;
 
   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 {
@@ skipping 29 matching lines @@
   PrintMsg_PrintPages_Params settings;
   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
   // terminate.
   bool result = true;
   if (!PrintMsg_Print_Params_IsValid(settings.params))
     result = false;
 
-  if (result &&
-      (settings.params.dpi < kMinDpi || settings.params.document_cookie == 0)) {
-    // Invalid print page settings.
-    NOTREACHED();
-    result = false;
-  }
-
   // Reset to default values.
   ignore_css_margins_ = false;
   settings.pages.clear();
 
   settings.params.print_scaling_option =
       blink::WebPrintScalingOptionSourceSize;
   if (fit_to_paper_size) {
     settings.params.print_scaling_option =
         blink::WebPrintScalingOptionFitToPrintableArea;
   }
 
-  print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
+  SetPrintPagesParams(settings);
   return result;
 }
 
 bool PrintWebViewHelper::CalculateNumberOfPages(blink::WebLocalFrame* frame,
                                                 const blink::WebNode& node,
                                                 int* number_of_pages) {
   DCHECK(frame);
   bool fit_to_paper_size = !(PrintingNodeOrPdfFrame(frame, node));
   if (!InitPrintSettings(fit_to_paper_size)) {
     notify_browser_of_print_failure_ = false;
     Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
     return false;
   }
 
-  const PrintMsg_Print_Params& params = print_pages_params_->params;
+  const PrintMsg_Print_Params& params = print_pages_params()->params;
   PrepareFrameAndViewForPrint prepare(params, frame, node, ignore_css_margins_);
   prepare.StartPrinting();
 
-  Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
-                                             params.document_cookie));
   *number_of_pages = prepare.GetExpectedPageCount();
   return true;
 }
 
 void PrintWebViewHelper::SetOptionsFromDocument(
     PrintHostMsg_SetOptionsFromDocument_Params& params) {
   blink::WebLocalFrame* source_frame = print_preview_context_.source_frame();
   const blink::WebNode& source_node = print_preview_context_.source_node();
 
   params.is_scaling_disabled =
@@ skipping 24 matching lines @@
 
   if (print_for_preview_ || !source_is_html) {
     modified_job_settings.MergeDictionary(job_settings);
     modified_job_settings.SetBoolean(kSettingHeaderFooterEnabled, false);
     modified_job_settings.SetInteger(kSettingMarginsType, NO_MARGINS);
     job_settings = &modified_job_settings;
   }
 
   // Send the cookie so that UpdatePrintSettings can reuse PrinterQuery when
   // possible.
-  int cookie = print_pages_params_ ?
-      print_pages_params_->params.document_cookie : 0;
+  int cookie =
+      print_pages_params() ? print_pages_params()->params.document_cookie : 0;
   PrintMsg_PrintPages_Params settings;
-  Send(new PrintHostMsg_UpdatePrintSettings(routing_id(), cookie, *job_settings,
-                                            &settings));
-  print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
-
-  if (!PrintMsg_Print_Params_IsValid(settings.params)) {
-    if (!print_for_preview_)
-      print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
-    else
-      Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
-
+  bool canceled = false;
+  Send(new PrintHostMsg_UpdatePrintSettings(
+      routing_id(), cookie, *job_settings, &settings, &canceled));
+  if (canceled) {
+    notify_browser_of_print_failure_ = false;
     return false;
   }
 
-  if (settings.params.dpi < kMinDpi || !settings.params.document_cookie) {
-    print_preview_context_.set_error(PREVIEW_ERROR_UPDATING_PRINT_SETTINGS);
-    return false;
-  }
-
   if (!job_settings->GetInteger(kPreviewUIID, &settings.params.preview_ui_id)) {
     NOTREACHED();
     print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
     return false;
   }
 
   if (!print_for_preview_) {
     // Validate expected print preview settings.
     if (!job_settings->GetInteger(kPreviewRequestID,
                                   &settings.params.preview_request_id) ||
         !job_settings->GetBoolean(kIsFirstRequest,
                                   &settings.params.is_first_request)) {
       NOTREACHED();
       print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
       return false;
     }
+  }
 
+  if (!print_for_preview_) {

[Noam Samuel, 2014/08/20 00:04:17]

Why separate two of the same if?

[Vitaly Buka (NO REVIEWS), 2014/08/20 02:42:55]

Done.

     settings.params.print_to_pdf = IsPrintToPdfRequested(*job_settings);
     UpdateFrameMarginsCssInfo(*job_settings);
     settings.params.print_scaling_option = GetPrintScalingOption(
         frame, node, source_is_html, *job_settings, settings.params);
 
     // Header/Footer: Set |header_footer_info_|.
     if (settings.params.display_header_footer) {
       header_footer_info_.reset(new base::DictionaryValue());
       header_footer_info_->SetDouble(kSettingHeaderFooterDate,
                                      base::Time::Now().ToJsTime());
       header_footer_info_->SetString(kSettingHeaderFooterURL,
                                      settings.params.url);
       header_footer_info_->SetString(kSettingHeaderFooterTitle,
                                      settings.params.title);
     }
   }
 
-  print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
-  Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
-                                             settings.params.document_cookie));
+  SetPrintPagesParams(settings);
+
+  if (CheckForCancel())
+    return false;
+
+  if (!PrintMsg_Print_Params_IsValid(settings.params)) {
+    if (!print_for_preview_)
+      print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
+    else
+      Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
+
+    return false;
+  }
 
   return true;
 }
 
 bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebFrame* frame,
                                                   const blink::WebNode& node,
                                                   int expected_pages_count) {
   PrintHostMsg_ScriptedPrint_Params params;
   PrintMsg_PrintPages_Params print_settings;
 
-  params.cookie = print_pages_params_->params.document_cookie;
+  params.cookie = print_pages_params()->params.document_cookie;
   params.has_selection = frame->hasSelection();
   params.expected_pages_count = expected_pages_count;
   MarginType margin_type = DEFAULT_MARGINS;
   if (PrintingNodeOrPdfFrame(frame, node))
     margin_type = GetMarginsForPdf(frame, node);
   params.margin_type = margin_type;
 
   Send(new PrintHostMsg_DidShowPrintDialog(routing_id()));
 
   // PrintHostMsg_ScriptedPrint will reset print_scaling_option, so we save the
   // value before and restore it afterwards.
   blink::WebPrintScalingOption scaling_option =
-      print_pages_params_->params.print_scaling_option;
+      print_pages_params()->params.print_scaling_option;
 
   print_pages_params_.reset();
   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));
-
-  print_pages_params_->params.print_scaling_option = scaling_option;
+  print_settings.params.print_scaling_option = scaling_option;
+  SetPrintPagesParams(print_settings);
   return (print_settings.params.dpi && print_settings.params.document_cookie);
 }
 
 bool PrintWebViewHelper::RenderPagesForPrint(blink::WebLocalFrame* frame,
                                              const blink::WebNode& node) {
   if (!frame || prep_frame_view_)
     return false;
-  const PrintMsg_PrintPages_Params& params = *print_pages_params_;
+  const PrintMsg_PrintPages_Params& params = *print_pages_params();
   const PrintMsg_Print_Params& print_params = params.params;
   prep_frame_view_.reset(new PrepareFrameAndViewForPrint(
       print_params, frame, node, ignore_css_margins_));
-  DCHECK(!print_pages_params_->params.selection_only ||
-         print_pages_params_->pages.empty());
+  DCHECK(!print_pages_params()->params.selection_only ||
+         print_pages_params()->pages.empty());
   prep_frame_view_->CopySelectionIfNeeded(
       render_view()->GetWebkitPreferences(),
       base::Bind(&PrintWebViewHelper::OnFramePreparedForPrintPages,
                  base::Unretained(this)));
   return true;
 }
 
 #if defined(OS_POSIX)
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     Metafile* metafile,
@@ skipping 138 matching lines @@
     }
     default: {
       NOTREACHED();
       return;
     }
   }
   Send(new PrintHostMsg_RequestPrintPreview(routing_id(), params));
 }
 
 bool PrintWebViewHelper::CheckForCancel() {
-  const PrintMsg_Print_Params& print_params = print_pages_params_->params;
+  const PrintMsg_Print_Params& print_params = print_pages_params()->params;
   bool cancel = false;
   Send(new PrintHostMsg_CheckForCancel(routing_id(),
                                        print_params.preview_ui_id,
                                        print_params.preview_request_id,
                                        &cancel));
   if (cancel)
     notify_browser_of_print_failure_ = false;
   return cancel;
 }
 
@@ skipping 23 matching lines @@
   DCHECK_GT(buf_size, 0u);
   if (!CopyMetafileDataToSharedMem(
       metafile, &(preview_page_params.metafile_data_handle))) {
     LOG(ERROR) << "CopyMetafileDataToSharedMem failed";
     print_preview_context_.set_error(PREVIEW_ERROR_METAFILE_COPY_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;
+      print_pages_params()->params.preview_request_id;
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
   return true;
 }
 
 PrintWebViewHelper::PrintPreviewContext::PrintPreviewContext()
     : total_page_count_(0),
       current_page_index_(0),
       generate_draft_pages_(true),
       print_ready_metafile_page_count_(0),
@@ skipping 227 matching lines @@
   return prep_frame_view_->GetPrintCanvasSize();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
+void PrintWebViewHelper::SetPrintPagesParams(
+    const PrintMsg_PrintPages_Params& settings) {
+  print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
+  Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
+                                             settings.params.document_cookie));
+}
+
 }  // namespace printing