[Experimental] Supporting OOPIF printing

components/printing/renderer/print_web_view_helper.cc

 // 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 "components/printing/renderer/print_web_view_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 24 matching lines @@
 #include "printing/features/features.h"
 #include "printing/metafile_skia_wrapper.h"
 #include "printing/pdf_metafile_skia.h"
 #include "printing/units.h"
 #include "third_party/WebKit/public/platform/WebDoubleSize.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/WebFrameOwnerProperties.h"
 #include "third_party/WebKit/public/web/WebFrameWidget.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.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/WebPrintPresetOptions.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.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 "third_party/WebKit/Source/web/WebRemoteFrameImpl.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::WebPreferences;
 
 namespace printing {
 
 namespace {
 
 #define STATIC_ASSERT_ENUM(a, b)                            \
@@ skipping 661 matching lines @@
     double scale_factor = 1.0f;
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     if (print_params.scale_factor >= PrintWebViewHelper::kEpsilon)
       scale_factor = print_params.scale_factor;
 #endif
     print_params = CalculatePrintParamsForCss(
         frame, 0, print_params, ignore_css_margins, fit_to_page, &scale_factor);
     frame->printEnd();
   }
   ComputeWebKitPrintParamsInDesiredDpi(print_params, &web_print_params_);
+  web_print_params_.rootFrameRoutingId =
+      content::RenderFrame::FromWebFrame(frame)->GetRoutingID();
 }
 
 PrepareFrameAndViewForPrint::~PrepareFrameAndViewForPrint() {
   FinishPrinting();
 }
 
 void PrepareFrameAndViewForPrint::ResizeForPrinting() {
   // Layout page according to printer page size. Since WebKit shrinks the
   // size of the page automatically (from 133.3% to 200%) we trick it to
   // think the page is 133.3% larger so the size of the page is correct for
@@ skipping 11 matching lines @@
   if (!frame())
     return;
 
   // Backup size and offset if it's a local frame.
   blink::WebView* web_view = frame_.view();
   if (blink::WebFrame* web_frame = web_view->mainFrame()) {
     if (web_frame->isWebLocalFrame())
       prev_scroll_offset_ = web_frame->getScrollOffset();
   }
   prev_view_size_ = web_view->size();
-
   web_view->resize(print_layout_size);
 }
 
 void PrepareFrameAndViewForPrint::StartPrinting() {
   blink::WebView* web_view = frame_.view();
   web_view->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
   expected_pages_count_ =
       frame()->printBegin(web_print_params_, node_to_print_);
   ResizeForPrinting();
   is_printing_started_ = true;
@@ skipping 193 matching lines @@
 #endif
   } else {
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
     Print(web_frame, blink::WebNode(), true /* is_scripted? */);
 #endif
   }
   // WARNING: |this| may be gone at this point. Do not do any more work here and
   // just return.
 }
 
+void PrintWebViewHelper::PrintFrame(const gfx::Rect& rect, int src_id) {
+  if (ipc_nesting_level_ > 1)
+    return;
+
+  PrintMsg_PrintPages_Params settings;
+  settings.params.dpi = 300;
+  settings.params.desired_dpi = 300;
+  settings.params.selection_only = false;
+  settings.params.should_print_backgrounds = true;
+  settings.params.page_size = rect.size();
+  settings.params.content_size = rect.size();
+  settings.params.printable_area = rect;
+  settings.params.is_first_request = true;
+  settings.params.print_to_pdf = false;
+  settings.params.display_header_footer = false;
+  settings.params.document_cookie = -1;
+  settings.params.is_subframe = true;
+
+  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
+  FrameReference frame_ref(frame);
+
+  // If we are printing a PDF extension frame, find the plugin node and print
+  // that instead.
+  auto node = delegate_->GetPdfElement(frame);
+
+  // Handle settings.
+  ignore_css_margins_ = false;
+  print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
+
+  prep_frame_view_.reset(new PrepareFrameAndViewForPrint(
+      print_pages_params_->params, frame, node, ignore_css_margins_));
+  prep_frame_view_->StartPrinting();
+
+  int page_count = prep_frame_view_->GetExpectedPageCount();
+  if (!page_count) {
+    return DidFinishPrinting(FAIL_PRINT);
+  }
+
+  if (!PrintPagesNative(prep_frame_view_->frame(), page_count)) {
+    return DidFinishPrinting(FAIL_PRINT);
+  }
+
+  FinishFramePrinting();
+  scripting_throttler_.Reset();
+}
+
 bool PrintWebViewHelper::OnMessageReceived(const IPC::Message& message) {
   // The class is not designed to handle recursive messages. This is not
   // expected during regular flow. However, during rendering of content for
   // printing, lower level code may run nested message loop. E.g. PDF may has
   // script to show message box http://crbug.com/502562. In that moment browser
   // may receive updated printer capabilities and decide to restart print
   // preview generation. When this happened message handling function may
   // choose to ignore message or safely crash process.
   ++ipc_nesting_level_;
 
   auto self = weak_ptr_factory_.GetWeakPtr();
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintWebViewHelper, message)
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPages, OnPrintPages)
+    IPC_MESSAGE_HANDLER(PrintMsg_PrintPagesWithSettings,
+                        OnPrintPagesWithSettings)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForSystemDialog, OnPrintForSystemDialog)
 #endif  // BUILDFLAG(ENABLE_BASIC_PRINTING)
 #if BUILDFLAG(ENABLE_BASIC_PRINTING) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintForPrintPreview, OnPrintForPrintPreview)
 #endif
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
     IPC_MESSAGE_HANDLER(PrintMsg_InitiatePrintPreview, OnInitiatePrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintPreview, OnPrintPreview)
     IPC_MESSAGE_HANDLER(PrintMsg_PrintingDone, OnPrintingDone)
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
@@ skipping 19 matching lines @@
   blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
 
   // If we are printing a PDF extension frame, find the plugin node and print
   // that instead.
   auto plugin = delegate_->GetPdfElement(frame);
   Print(frame, plugin, false /* is_scripted? */);
   // WARNING: |this| may be gone at this point. Do not do any more work here and
   // just return.
 }
 
+void PrintWebViewHelper::OnPrintPagesWithSettings(const gfx::Rect& rect) {
+  if (ipc_nesting_level_ > 1)
+    return;
+
+  PrintMsg_PrintPages_Params settings;
+  settings.params.dpi = 300;
+  settings.params.desired_dpi = 300;
+  settings.params.selection_only = false;
+  settings.params.should_print_backgrounds = true;
+  // settings.params.page_size = rect.size();
+  settings.params.page_size = gfx::Size(500, 300);
+  // settings.params.content_size = rect.size();
+  settings.params.content_size = gfx::Size(500, 300);
+  // settings.params.printable_area = rect;
+  settings.params.printable_area = gfx::Rect(500, 300);
+  settings.params.is_first_request = true;
+  settings.params.print_to_pdf = false;
+  settings.params.display_header_footer = false;
+  settings.params.document_cookie = -1;
+  settings.params.is_subframe = true;
+
+  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
+  FrameReference frame_ref(frame);
+
+  // If we are printing a PDF extension frame, find the plugin node and print
+  // that instead.
+  auto node = delegate_->GetPdfElement(frame);
+
+  // Handle settings.
+  ignore_css_margins_ = false;
+  print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
+
+  prep_frame_view_.reset(new PrepareFrameAndViewForPrint(
+      print_pages_params_->params, frame, node, ignore_css_margins_));
+  prep_frame_view_->StartPrinting();
+
+  int page_count = prep_frame_view_->GetExpectedPageCount();
+  if (!page_count) {
+    return DidFinishPrinting(FAIL_PRINT);
+  }
+
+  if (!PrintPagesNative(prep_frame_view_->frame(), page_count)) {
+    return DidFinishPrinting(FAIL_PRINT);
+  }
+
+  FinishFramePrinting();
+  scripting_throttler_.Reset();
+}
+
 void PrintWebViewHelper::OnPrintForSystemDialog() {
   if (ipc_nesting_level_> 1)
     return;
   blink::WebLocalFrame* frame = print_preview_context_.source_frame();
   if (!frame) {
     NOTREACHED();
     return;
   }
   Print(frame, print_preview_context_.source_node(), false);
   // WARNING: |this| may be gone at this point. Do not do any more work here and
@@ skipping 284 matching lines @@
     draft_metafile.reset(new PdfMetafileSkia(PDF_SKIA_DOCUMENT_TYPE));
     initial_render_metafile = draft_metafile.get();
   }
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   PrintPageInternal(page_params, print_preview_context_.prepared_frame(),
                     initial_render_metafile, nullptr, nullptr, nullptr);
   print_preview_context_.RenderedPreviewPage(
       base::TimeTicks::Now() - begin_time);
   if (draft_metafile.get()) {
-    draft_metafile->FinishDocument();
+    draft_metafile->FinishAllPages();
   } else if (print_preview_context_.IsModifiable() &&
              print_preview_context_.generate_draft_pages()) {
     DCHECK(!draft_metafile.get());
     draft_metafile =
         print_preview_context_.metafile()->GetMetafileForCurrentPage(
             PDF_SKIA_DOCUMENT_TYPE);
   }
   return PreviewPageRendered(page_number, draft_metafile.get());
 }
 #endif  // !defined(OS_MACOSX) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 bool PrintWebViewHelper::FinalizePrintReadyDocument() {
   DCHECK(!is_print_ready_metafile_sent_);
   print_preview_context_.FinalizePrintReadyDocument();
 
   PdfMetafileSkia* metafile = print_preview_context_.metafile();
   PrintHostMsg_DidPreviewDocument_Params preview_params;
 
-  // Ask the browser to create the shared memory for us.
   if (!CopyMetafileDataToSharedMem(*metafile,
-                                   &(preview_params.metafile_data_handle))) {
+                                   &preview_params.metafile_data_handle,
+                                   &preview_params.data_size)) {
     LOG(ERROR) << "CopyMetafileDataToSharedMem failed";
     print_preview_context_.set_error(PREVIEW_ERROR_METAFILE_COPY_FAILED);
     return false;
   }
 
-  preview_params.data_size = metafile->GetDataSize();
   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;
+  preview_params.is_subframe = print_pages_params_->params.is_subframe;
 
   is_print_ready_metafile_sent_ = true;
 
   Send(new PrintHostMsg_MetafileReadyForPrinting(routing_id(), preview_params));
   return true;
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 void PrintWebViewHelper::OnPrintingDone(bool success) {
   if (ipc_nesting_level_ > 1)
@@ skipping 344 matching lines @@
     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;
   PrintMsg_PrintPages_Params settings;
+  // Initial frame should be the root frame.
+  settings.params.is_subframe = false;
   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 (!job_settings->GetInteger(kPreviewUIID, &settings.params.preview_ui_id)) {
     NOTREACHED();
@@ skipping 168 matching lines @@
   DCHECK_GT(webkit_scale_factor, 0.0f);
 
   // Done printing. Close the canvas to retrieve the compiled metafile.
   if (!metafile->FinishPage())
     NOTREACHED() << "metafile failed";
 }
 #endif  // !defined(OS_MACOSX)
 
 bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
     const PdfMetafileSkia& metafile,
-    base::SharedMemoryHandle* shared_mem_handle) {
-  uint32_t buf_size = metafile.GetDataSize();
-  if (buf_size == 0)
+    base::SharedMemoryHandle* shared_mem_handle,
+    uint32_t* size) {
+  std::string file_name = base::StringPrintf(
+      "C:\\src\\test_only\\chrome_test_dump\\org_%d.skp", routing_id());
+  SkFILEWStream file(file_name.c_str());
+  metafile.GetSkp(&file);
+  file.fsync();
+
+  // Test new utility logic.
+  size_t buf_size;
+  std::unique_ptr<char[]> buf = metafile.GetPageDataBuffer(&buf_size);
+  if (buf_size == 0) {
+    NOTREACHED() << "Page data is empty";
     return false;
+  }
 
   std::unique_ptr<base::SharedMemory> shared_buf(
       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(buf_size));
-  if (!shared_buf)
+  if (!shared_buf || !shared_buf->Map(buf_size)) {
+    NOTREACHED() << "Map data error";
+    print_preview_context_.set_error(PREVIEW_ERROR_METAFILE_COPY_FAILED);
     return false;
-
-  if (!shared_buf->Map(buf_size))
-    return false;
-
-  if (!metafile.GetData(shared_buf->memory(), buf_size))
-    return false;
+  }
+  memcpy(shared_buf->memory(), buf.get(), buf_size);
 
   *shared_mem_handle =
       base::SharedMemory::DuplicateHandle(shared_buf->handle());
+  *size = buf_size;
   return true;
 }
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
 void PrintWebViewHelper::ShowScriptedPrintPreview() {
   if (is_scripted_preview_delayed_) {
     is_scripted_preview_delayed_ = false;
     Send(new PrintHostMsg_ShowScriptedPrintPreview(
         routing_id(), print_preview_context_.IsModifiable()));
   }
@@ skipping 98 matching lines @@
     return true;
   }
 
   if (!metafile) {
     NOTREACHED();
     print_preview_context_.set_error(
         PREVIEW_ERROR_PAGE_RENDERED_WITHOUT_METAFILE);
     return false;
   }
 
+  // output the debug file.
+  std::string file_name = base::StringPrintf(
+      "C:\\src\\test_only\\chrome_test_dump\\org_%d.skp", page_number);
+  SkFILEWStream file(file_name.c_str());
+  metafile->GetSkp(&file);
+  file.fsync();
+
   PrintHostMsg_DidPreviewPage_Params preview_page_params;
-  // Get the size of the resulting metafile.
-  if (!CopyMetafileDataToSharedMem(
-          *metafile, &(preview_page_params.metafile_data_handle))) {
+  if (!CopyMetafileDataToSharedMem(*metafile,
+                                   &preview_page_params.metafile_data_handle,
+                                   &preview_page_params.data_size)) {
     LOG(ERROR) << "CopyMetafileDataToSharedMem failed";
     print_preview_context_.set_error(PREVIEW_ERROR_METAFILE_COPY_FAILED);
     return false;
   }
-  preview_page_params.data_size = metafile->GetDataSize();
+
   preview_page_params.page_number = page_number;
   preview_page_params.preview_request_id =
       print_pages_params_->params.preview_request_id;
+  preview_page_params.is_subframe = print_pages_params_->params.is_subframe;
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
   return true;
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 PrintWebViewHelper::PrintPreviewContext::PrintPreviewContext()
     : total_page_count_(0),
       current_page_index_(0),
       generate_draft_pages_(true),
@@ skipping 95 matching lines @@
 void PrintWebViewHelper::PrintPreviewContext::AllPagesRendered() {
   DCHECK_EQ(RENDERING, state_);
   state_ = DONE;
   prep_frame_view_->FinishPrinting();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::FinalizePrintReadyDocument() {
   DCHECK(IsRendering());
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
-  metafile_->FinishDocument();
+  metafile_->FinishAllPages();
 
   if (print_ready_metafile_page_count_ <= 0) {
     NOTREACHED();
     return;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("PrintPreview.RenderToPDFTime",
                              document_render_time_);
   base::TimeDelta total_time =
       (base::TimeTicks::Now() - begin_time) + document_render_time_;
@@ skipping 157 matching lines @@
       blink::WebConsoleMessage::LevelWarning, message));
   return false;
 }
 
 void PrintWebViewHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing