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"
+// TODO(sgurun) copied from chrome/renderer. Remove after crbug.com/322276
+
+#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"
 
+// This code is copied from chrome/renderer/printing. Code is slightly
+// modified to run it with webview, and the modifications are marked
+// using OS_ANDROID.
+// TODO(sgurun): remove the code as part of componentization of printing.
+
 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,
 };
 
 const double kMinDpi = 1.0;
 
+#if 0
+// TODO(sgurun) android_webview hack
 const char kPageLoadScriptFormat[] =
     "document.open(); document.write(%s); document.close();";
 
 const char kPageSetupScriptFormat[] = "setup(%s);";
 
 void ExecuteScript(blink::WebFrame* frame,
                    const char* script_format,
                    const base::Value& parameters) {
   std::string json;
   base::JSONWriter::Write(&parameters, &json);
   std::string script = base::StringPrintf(script_format, json.c_str());
   frame->executeScript(blink::WebString(UTF8ToUTF16(script)));
 }
+#endif
 
 int GetDPI(const PrintMsg_Print_Params* print_params) {
 #if defined(OS_MACOSX)
   // On the Mac, the printable area is in points, don't do any scaling based
   // on dpi.
   return kPointsPerInch;
 #else
   return static_cast<int>(print_params->dpi);
 #endif  // defined(OS_MACOSX)
 }
@@ skipping 269 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 blink::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(
     blink::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);
 
   blink::WebSize page_size(page_layout.margin_left + page_layout.margin_right +
                             page_layout.content_width,
                             page_layout.margin_top + page_layout.margin_bottom +
@@ skipping 17 matching lines @@
   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);
 
   blink::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(blink::WebFrame* frame,
                                             int page_number,
                                             const gfx::Rect& canvas_area,
                                             const gfx::Rect& content_area,
                                             double scale_factor,
                                             blink::WebCanvas* canvas) {
   SkAutoCanvasRestore auto_restore(canvas, true);
@@ skipping 242 matching lines @@
       is_print_ready_metafile_sent_(false),
       ignore_css_margins_(false),
       user_cancelled_scripted_print_count_(0),
       is_scripted_printing_blocked_(false),
       notify_browser_of_print_failure_(true),
       print_for_preview_(false),
       print_node_in_progress_(false),
       is_loading_(false),
       is_scripted_preview_delayed_(false),
       weak_ptr_factory_(this) {
+  // TODO(sgurun) enable window.print() for webview crbug.com/322303
+  SetScriptedPrintBlocked(true);
 }
 
 PrintWebViewHelper::~PrintWebViewHelper() {}
 
 bool PrintWebViewHelper::IsScriptInitiatedPrintAllowed(
     blink::WebFrame* frame, bool user_initiated) {
 #if defined(OS_ANDROID)
   return false;
 #endif  // defined(OS_ANDROID)
   if (is_scripted_printing_blocked_)
@@ skipping 16 matching lines @@
 void PrintWebViewHelper::DidStopLoading() {
   is_loading_ = false;
   ShowScriptedPrintPreview();
 }
 
 // Prints |frame| which called window.print().
 void PrintWebViewHelper::PrintPage(blink::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, blink::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(blink::WebFrame* 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;
+#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
       blink::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();
@@ skipping 332 matching lines @@
 }
 
 void PrintWebViewHelper::PrintPreviewContext::ClearContext() {
   prep_frame_view_.reset();
   metafile_.reset();
   pages_to_render_.clear();
   error_ = PREVIEW_ERROR_NONE;
 }
 
 }  // namespace printing