Fix print preview workflow to reflect settings of selected printer.

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 549 matching lines @@
 
   WebDocument document = main_frame->document();
   // <object> with id="pdf-viewer" is created in
   // chrome/browser/resources/print_preview/print_preview.js
   WebElement pdf_element = document.getElementById("pdf-viewer");
   if (pdf_element.isNull()) {
     NOTREACHED();
     return;
   }
 
-  WebFrame* pdf_frame = pdf_element.document().frame();
-  scoped_ptr<PrepareFrameAndViewForPrint> prepare;
-  if (!InitPrintSettingsAndPrepareFrame(pdf_frame, &pdf_element, &prepare)) {
-    LOG(ERROR) << "Failed to initialize print page settings";
-    return;
-  }
-
   if (!UpdatePrintSettings(job_settings, false)) {
     LOG(ERROR) << "UpdatePrintSettings failed";
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
+  WebFrame* pdf_frame = pdf_element.document().frame();
+  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())) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
 }
 
 bool PrintWebViewHelper::GetPrintFrame(WebKit::WebFrame** frame) {
   DCHECK(frame);
   DCHECK(render_view()->webview());
@@ skipping 29 matching lines @@
     // copy when the print preview tab closes.
     WebNode duplicate_node(*node);
     Print(frame, &duplicate_node);
   }
 }
 
 void PrintWebViewHelper::OnPrintPreview(const DictionaryValue& settings) {
   DCHECK(is_preview_);
   print_preview_context_.OnPrintPreview();
 
-  if (!InitPrintSettings(print_preview_context_.frame(),
-                         print_preview_context_.node(),
-                         true)) {
-    Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
-         routing_id(),
-         print_pages_params_->params.document_cookie));
-    return;
-  }
-
   if (!UpdatePrintSettings(settings, true)) {
-    LOG(ERROR) << "UpdatePrintSettings failed";
+    if (print_preview_context_.last_error() != PREVIEW_ERROR_BAD_SETTING) {
+      Send(new PrintHostMsg_PrintPreviewInvalidPrinterSettings(
+          routing_id(), print_pages_params_->params.document_cookie));
+      notify_browser_of_print_failure_ = false;  // Already sent.
+    }
     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;
@@ skipping 144 matching lines @@
   }
 }
 
 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.
   scoped_ptr<PrepareFrameAndViewForPrint> prepare;
-  if (!InitPrintSettingsAndPrepareFrame(frame, node, &prepare))
+  if (!InitPrintSettingsAndPrepareFrame(frame, node, &prepare)) {
+    DidFinishPrinting(FAIL_PRINT);
     return;  // Failed to init print page settings.
+  }
 
   int expected_page_count = 0;
   bool use_browser_overlays = true;
 
   expected_page_count = prepare->GetExpectedPageCount();
   if (expected_page_count)
     use_browser_overlays = prepare->ShouldUseBrowserOverlays();
 
   // Release the prepare before going any further, since we are going to
   // show UI and wait for the user.
@@ skipping 25 matching lines @@
   if (result == FAIL_PRINT) {
     DisplayPrintJobError();
 
     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;
+    int cookie = print_pages_params_.get() ?
+                     print_pages_params_->params.document_cookie : 0;
     if (notify_browser_of_print_failure_)
       Send(new PrintHostMsg_PrintPreviewFailed(routing_id(), cookie));
     else
       Send(new PrintHostMsg_PrintPreviewCancelled(routing_id(), cookie));
     print_preview_context_.Failed(notify_browser_of_print_failure_);
   }
 
   if (print_web_view_) {
     print_web_view_->close();
     print_web_view_ = NULL;
@@ skipping 182 matching lines @@
           page_height_in_points, printing::kPointsPerInch, dpi)));
 
   params->margin_top = static_cast<int>(ConvertUnitDouble(
       page_layout_in_points.margin_top, printing::kPointsPerInch, dpi));
   params->margin_left = static_cast<int>(ConvertUnitDouble(
       page_layout_in_points.margin_left, printing::kPointsPerInch, dpi));
 
   prepare->UpdatePrintParams(*params);
 }
 
-bool PrintWebViewHelper::InitPrintSettings(WebKit::WebFrame* frame,
-                                           WebKit::WebNode* node,
-                                           bool is_preview) {
+bool PrintWebViewHelper::InitPrintSettings(WebKit::WebFrame* frame) {
   DCHECK(frame);
   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_IsEmpty(settings.params)) {
-    if (!is_preview) {
-      render_view()->runModalAlertDialog(
-          frame,
-          l10n_util::GetStringUTF16(
-              IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
-    }
+    render_view()->runModalAlertDialog(
+        frame,
+        l10n_util::GetStringUTF16(
+            IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
     result = false;
   }
 
   if (result &&
       (settings.params.dpi < kMinDpi || settings.params.document_cookie == 0)) {
     // Invalid print page settings.
     NOTREACHED();
     result = false;
   }
 
   settings.pages.clear();
   print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
   return result;
 }
 
 bool PrintWebViewHelper::InitPrintSettingsAndPrepareFrame(
     WebKit::WebFrame* frame, WebKit::WebNode* node,
     scoped_ptr<PrepareFrameAndViewForPrint>* prepare) {
-  if (!InitPrintSettings(frame, node, false))
+  if (!InitPrintSettings(frame))
     return false;
 
   DCHECK(!prepare->get());
   prepare->reset(new PrepareFrameAndViewForPrint(print_pages_params_->params,
                                                  frame, node));
   UpdatePrintableSizeInPrintParameters(frame, node, prepare->get(),
                                        &print_pages_params_->params);
   Send(new PrintHostMsg_DidGetDocumentCookie(
         routing_id(), print_pages_params_->params.document_cookie));
   return true;
 }
 
 bool PrintWebViewHelper::UpdatePrintSettings(
     const DictionaryValue& job_settings, bool is_preview) {
+  if (is_preview && job_settings.empty()) {

[kmadhusu, 2011/09/20 20:55:08]

As we discussed split this if condition.

[arthurhsu, 2011/09/20 21:39:48]

Done.

+    print_preview_context_.set_error(PREVIEW_ERROR_BAD_SETTING);
+    return false;
+  }
+
+  // Send the cookie so that UpdatePrintSettings can reuse PrintQuery when
+  // possible.
+  int cookie = print_pages_params_.get() ?
+                   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));
 
-  Send(new PrintHostMsg_UpdatePrintSettings(routing_id(),
-       print_pages_params_->params.document_cookie, job_settings, &settings));
+  if (PrintMsg_Print_Params_IsEmpty(settings.params)) {
+    if (!is_preview) {
+      WebKit::WebFrame* frame = print_preview_context_.frame();
+      if (!frame)
+        GetPrintFrame(&frame);
+      DCHECK(frame);
+      render_view()->runModalAlertDialog(
+          frame,
+          l10n_util::GetStringUTF16(
+              IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
+    } else {
+      print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
+    }
+    return false;
+  }
+
   if (settings.params.dpi < kMinDpi || !settings.params.document_cookie) {
     print_preview_context_.set_error(PREVIEW_ERROR_UPDATING_PRINT_SETTINGS);
     return false;
   }
 
   if (is_preview) {
     // Validate expected print preview settings.
     if (!job_settings.GetString(printing::kPreviewUIAddr,
                                 &(settings.params.preview_ui_addr)) ||
         !job_settings.GetInteger(printing::kPreviewRequestID,
@@ skipping 415 matching lines @@
 printing::PreviewMetafile*
 PrintWebViewHelper::PrintPreviewContext::metafile() const {
   return metafile_.get();
 }
 
 const PrintMsg_Print_Params&
 PrintWebViewHelper::PrintPreviewContext::print_params() const {
   return *print_params_;
 }
 
+int PrintWebViewHelper::PrintPreviewContext::last_error() const {
+  return error_;
+}
+
 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();
   error_ = PREVIEW_ERROR_NONE;
 }