Upstream printing changes.

android_webview/renderer/print_web_view_helper.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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 "android_webview/renderer/print_web_view_helper.h"
 
 #include <string>
 
+#include "android_webview/common/print_messages.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/print_messages.h"
-#include "chrome/common/render_messages.h"
-#include "chrome/renderer/prerender/prerender_helper.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/web_preferences.h"
-#include "grit/browser_resources.h"
-#include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "printing/metafile.h"
 #include "printing/metafile_impl.h"
 #include "printing/units.h"
 #include "skia/ext/vector_platform_device_skia.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebPlugin.h"
 #include "third_party/WebKit/public/web/WebPluginDocument.h"
 #include "third_party/WebKit/public/web/WebPrintParams.h"
 #include "third_party/WebKit/public/web/WebPrintScalingOption.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebViewClient.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/common/webpreferences.h"
 

[joth, 2013/11/04 20:30:38]

should we put a comment here about where this was copied from, that OS_ANDROID
is used in most places as a marker of the differences from that source, and TODO
/ bug link for the componentization work needed to converge the two copies?

[sgurun-gerrit only, 2013/11/21 18:25:43]

Done.

 namespace printing {
 
 namespace {
 
 enum PrintPreviewHelperEvents {
   PREVIEW_EVENT_REQUESTED,
   PREVIEW_EVENT_CACHE_HIT,  // Unused
   PREVIEW_EVENT_CREATE_DOCUMENT,
   PREVIEW_EVENT_NEW_SETTINGS,  // Unused
   PREVIEW_EVENT_MAX,
@@ skipping 211 matching lines @@
   webkit_print_params->paperSize.width =
       ConvertUnit(print_params.page_size.width(), dpi,
                   print_params.desired_dpi);
   webkit_print_params->paperSize.height =
       ConvertUnit(print_params.page_size.height(), dpi,
                   print_params.desired_dpi);
 }
 
 WebKit::WebPlugin* GetPlugin(const WebKit::WebFrame* frame) {
   return frame->document().isPluginDocument() ?
          frame->document().to<WebKit::WebPluginDocument>().plugin() : NULL;

[joth, 2013/11/04 20:30:38]

this will always return NULL for webview. Is this update just to make it look
more consistent with the //chrome version?

[sgurun-gerrit only, 2013/11/21 18:25:43]

yep

 }
 
 bool PrintingNodeOrPdfFrame(const WebKit::WebFrame* frame,
                             const WebKit::WebNode& node) {
   if (!node.isNull())
     return true;
   WebKit::WebPlugin* plugin = GetPlugin(frame);
   return plugin && plugin->supportsPaginatedPrint();
 }
 
@@ skipping 64 matching lines @@
 
   if (fit_to_page) {
     double factor = FitPrintParamsToPage(params, &result_params);
     if (scale_factor)
       *scale_factor = factor;
   }
   return result_params;
 }
 
 bool IsPrintPreviewEnabled() {
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kRendererPrintPreview);
+  return false;
 }
 
 bool IsPrintThrottlingDisabled() {
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableScriptedPrintThrottling);
+  return true;
 }
 
 }  // namespace
 
 FrameReference::FrameReference(const WebKit::WebFrame* frame) {
   Reset(frame);
 }
 
 FrameReference::FrameReference() {
   Reset(NULL);
@@ skipping 22 matching lines @@
 
 // static - Not anonymous so that platform implementations can use it.
 void PrintWebViewHelper::PrintHeaderAndFooter(
     WebKit::WebCanvas* canvas,
     int page_number,
     int total_pages,
     float webkit_scale_factor,
     const PageSizeMargins& page_layout,
     const base::DictionaryValue& header_footer_info,
     const PrintMsg_Print_Params& params) {
+#if 0
+  // TODO(sgurun) android_webview hack
   skia::VectorPlatformDeviceSkia* device =
       static_cast<skia::VectorPlatformDeviceSkia*>(canvas->getTopDevice());
   device->setDrawingArea(SkPDFDevice::kMargin_DrawingArea);
 
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->scale(1 / webkit_scale_factor, 1 / webkit_scale_factor);
 
   WebKit::WebSize page_size(page_layout.margin_left + page_layout.margin_right +
                             page_layout.content_width,
                             page_layout.margin_top + page_layout.margin_bottom +
                             page_layout.content_height);
 
   WebKit::WebView* web_view = WebKit::WebView::create(NULL);
   web_view->settings()->setJavaScriptEnabled(true);
   web_view->initializeMainFrame(NULL);
 
   WebKit::WebFrame* frame = web_view->mainFrame();
-
   base::StringValue html(
       ResourceBundle::GetSharedInstance().GetLocalizedString(
           IDR_PRINT_PREVIEW_PAGE));
   // Load page with script to avoid async operations.
   ExecuteScript(frame, kPageLoadScriptFormat, html);
 
   scoped_ptr<base::DictionaryValue> options(header_footer_info.DeepCopy());
   options->SetDouble("width", page_size.width);
   options->SetDouble("height", page_size.height);
   options->SetDouble("topMargin", page_layout.margin_top);
   options->SetDouble("bottomMargin", page_layout.margin_bottom);
   options->SetString("pageNumber",
                      base::StringPrintf("%d/%d", page_number, total_pages));
 
   ExecuteScript(frame, kPageSetupScriptFormat, *options);
 
   WebKit::WebPrintParams webkit_params(page_size);
   webkit_params.printerDPI = GetDPI(&params);
 
-  frame->printBegin(webkit_params);
+  frame->printBegin(webkit_params, WebKit::WebNode(), NULL);
   frame->printPage(0, canvas);
   frame->printEnd();
 
   web_view->close();
 
   device->setDrawingArea(SkPDFDevice::kContent_DrawingArea);
+#endif
 }
 
 // static - Not anonymous so that platform implementations can use it.
 float PrintWebViewHelper::RenderPageContent(WebKit::WebFrame* frame,
                                             int page_number,
                                             const gfx::Rect& canvas_area,
                                             const gfx::Rect& content_area,
                                             double scale_factor,
                                             WebKit::WebCanvas* canvas) {
   SkAutoCanvasRestore auto_restore(canvas, true);
@@ skipping 278 matching lines @@
 void PrintWebViewHelper::DidStopLoading() {
   is_loading_ = false;
   ShowScriptedPrintPreview();
 }
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(WebKit::WebFrame* frame,
                                    bool user_initiated) {
   DCHECK(frame);
 
+#if !defined(OS_ANDROID)
+  // TODO(sgurun) android_webview hack
   // Allow Prerendering to cancel this print request if necessary.
   if (prerender::PrerenderHelper::IsPrerendering(render_view())) {
     Send(new ChromeViewHostMsg_CancelPrerenderForPrinting(routing_id()));
     return;
   }
+#endif  // !defined(OS_ANDROID)
 
   if (!IsScriptInitiatedPrintAllowed(frame, user_initiated))
     return;
   IncrementScriptedPrintCount();
 
   if (is_preview_enabled_) {
     print_preview_context_.InitWithFrame(frame);
     RequestPrintPreview(PRINT_PREVIEW_SCRIPTED);
   } else {
     Print(frame, WebKit::WebNode());
@@ skipping 417 matching lines @@
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
 
   // Some full screen plugins can say they don't want to print.
   if (!expected_page_count) {
     DidFinishPrinting(FAIL_PRINT);
     return;
   }
 
+#if !defined(OS_ANDROID)
+  // TODO(sgurun) android_webview hack
   // Ask the browser to show UI to retrieve the final print settings.
   if (!GetPrintSettingsFromUser(frame_ref.GetFrame(), node,
                                 expected_page_count)) {
     DidFinishPrinting(OK);  // Release resources and fail silently.
     return;
   }
+#endif  // !defined(OS_ANDROID)
 
   // Render Pages for printing.
   if (!RenderPagesForPrint(frame_ref.GetFrame(), node)) {
     LOG(ERROR) << "RenderPagesForPrint failed";
     DidFinishPrinting(FAIL_PRINT);
   }
   ResetScriptedPrintCount();
 }
 
 void PrintWebViewHelper::DidFinishPrinting(PrintingResult result) {
@@ skipping 18 matching lines @@
           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();
   print_pages_params_.reset();
   notify_browser_of_print_failure_ = true;
 }
 
 void PrintWebViewHelper::OnFramePreparedForPrintPages() {
   PrintPages();
   FinishFramePrinting();
 }
 
@@ skipping 118 matching lines @@
   return result;
 }
 
 bool PrintWebViewHelper::CalculateNumberOfPages(WebKit::WebFrame* frame,
                                                 const WebKit::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;
+#if !defined(OS_ANDROID)
+    // TODO(sgurun) android_webview hack
     render_view()->RunModalAlertDialog(
         frame,
         l10n_util::GetStringUTF16(IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
+#endif  //  !defined(OS_ANDROID)
     return false;
   }
 
   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();
@@ skipping 35 matching lines @@
       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 {
+#if !defined(OS_ANDROID)
+      // TODO(sgurun) android_webview hack
       // PrintForPrintPreview
       WebKit::WebFrame* print_frame = NULL;
       // This may not be the right frame, but the alert will be modal,
       // therefore it works well enough.
       GetPrintFrame(&print_frame);
       if (print_frame) {
         render_view()->RunModalAlertDialog(
             print_frame,
             l10n_util::GetStringUTF16(
                 IDS_PRINT_PREVIEW_INVALID_PRINTER_SETTINGS));
       }
+#endif  // !defined(OS_ANDROID)
     }
     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)) {
@@ skipping 149 matching lines @@
 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::ShowScriptedPrintPreview() {
   if (is_scripted_preview_delayed_) {
     is_scripted_preview_delayed_ = false;
     Send(new PrintHostMsg_ShowScriptedPrintPreview(routing_id(),
             print_preview_context_.IsModifiable()));
   }
 }
 
 void PrintWebViewHelper::RequestPrintPreview(PrintPreviewRequestType type) {
   const bool is_modifiable = print_preview_context_.IsModifiable();
   const bool has_selection = print_preview_context_.HasSelection();
   PrintHostMsg_RequestPrintPreview_Params params;
   params.is_modifiable = is_modifiable;
   params.has_selection = has_selection;
   switch (type) {
     case PRINT_PREVIEW_SCRIPTED: {
-      // Shows scripted print preview in two stages.
+    // Shows scripted print preview in two stages.
       // 1. PrintHostMsg_SetupScriptedPrintPreview blocks this call and JS by
       //    pumping messages here.
       // 2. PrintHostMsg_ShowScriptedPrintPreview shows preview once the
       //    document has been loaded.
       is_scripted_preview_delayed_ = true;
       if (is_loading_ && GetPlugin(print_preview_context_.source_frame())) {
         // Wait for DidStopLoading. Plugins may not know the correct
         // |is_modifiable| value until they are fully loaded, which occurs when
         // DidStopLoading() is called. Defer showing the preview until then.
       } else {
@@ skipping 25 matching lines @@
       NOTREACHED();
       return;
     }
   }
   Send(new PrintHostMsg_RequestPrintPreview(routing_id(), params));
 }
 
 bool PrintWebViewHelper::CheckForCancel() {
   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;
 }
 
 bool PrintWebViewHelper::PreviewPageRendered(int page_number,
@@ skipping 270 matching lines @@
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
 }  // namespace printing