Use pdf compositor service for printing when OOPIF is enabled

components/printing/renderer/print_render_frame_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_render_frame_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 781 matching lines @@
 
   // Backup size and offset if it's a local frame.
   blink::WebView* web_view = frame_.view();
   if (blink::WebFrame* web_frame = web_view->MainFrame()) {
     // TODO(lukasza, weili): Support restoring scroll offset of a remote main
     // frame - https://crbug.com/734815.
     if (web_frame->IsWebLocalFrame())
       prev_scroll_offset_ = web_frame->ToWebLocalFrame()->GetScrollOffset();
   }
   prev_view_size_ = web_view->Size();
-
   web_view->Resize(print_layout_size);
 }
 
 void PrepareFrameAndViewForPrint::StartPrinting() {
   blink::WebView* web_view = frame_.view();
   web_view->GetSettings()->SetShouldPrintBackgrounds(should_print_backgrounds_);
   expected_pages_count_ =
       frame()->PrintBegin(web_print_params_, node_to_print_);
   ResizeForPrinting();
   is_printing_started_ = true;
@@ skipping 471 matching lines @@
 bool PrintRenderFrameHelper::CreatePreviewDocument() {
   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;
 
-  if (!print_preview_context_.CreatePreviewDocument(prep_frame_view_.release(),
-                                                    pages)) {
+  if (!print_preview_context_.CreatePreviewDocument(
+          prep_frame_view_.release(), pages, print_params.printed_doc_type)) {
     return false;
   }
 
   PageSizeMargins default_page_layout;
   double scale_factor =
       print_params.scale_factor >= kEpsilon ? print_params.scale_factor : 1.0f;
 
   ComputePageLayoutInPointsForCss(print_preview_context_.prepared_frame(), 0,
                                   print_params, ignore_css_margins_,
                                   &scale_factor, &default_page_layout);
@@ skipping 85 matching lines @@
   return true;
 }
 
 #if !defined(OS_MACOSX) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
 bool PrintRenderFrameHelper::RenderPreviewPage(
     int page_number,
     const PrintMsg_Print_Params& print_params) {
   std::unique_ptr<PdfMetafileSkia> draft_metafile;
   PdfMetafileSkia* initial_render_metafile = print_preview_context_.metafile();
   if (print_preview_context_.IsModifiable() && is_print_ready_metafile_sent_) {
-    draft_metafile = base::MakeUnique<PdfMetafileSkia>(PDF_SKIA_DOCUMENT_TYPE);
+    draft_metafile.reset(new PdfMetafileSkia(print_params.printed_doc_type));

[Lei Zhang, 2017/08/16 21:17:01]

Can't use MakeUnique anymore?

[Wei Li, 2017/08/25 23:39:37]

Done in another CL.

     initial_render_metafile = draft_metafile.get();
   }
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   PrintPageInternal(print_params, page_number,
                     print_preview_context_.total_page_count(),
                     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();
   } 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);
+            print_params.printed_doc_type);
   }
   return PreviewPageRendered(page_number, draft_metafile.get());
 }
 #endif  // !defined(OS_MACOSX) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 bool PrintRenderFrameHelper::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)) {
     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();
@@ skipping 679 matching lines @@
   }
 
   if (!metafile) {
     NOTREACHED();
     print_preview_context_.set_error(
         PREVIEW_ERROR_PAGE_RENDERED_WITHOUT_METAFILE);
     return false;
   }
 
   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)) {
     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;
 
   Send(new PrintHostMsg_DidPreviewPage(routing_id(), preview_page_params));
   return true;
 }
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
@@ skipping 29 matching lines @@
   CalculateIsModifiable();
 }
 
 void PrintRenderFrameHelper::PrintPreviewContext::OnPrintPreview() {
   DCHECK_EQ(INITIALIZED, state_);
   ClearContext();
 }
 
 bool PrintRenderFrameHelper::PrintPreviewContext::CreatePreviewDocument(
     PrepareFrameAndViewForPrint* prepared_frame,
-    const std::vector<int>& pages) {
+    const std::vector<int>& pages,
+    SkiaDocumentType doc_type) {
   DCHECK_EQ(INITIALIZED, state_);
   state_ = RENDERING;
 
   // Need to make sure old object gets destroyed first.
   prep_frame_view_.reset(prepared_frame);
   prep_frame_view_->StartPrinting();
 
   total_page_count_ = prep_frame_view_->GetExpectedPageCount();
   if (total_page_count_ == 0) {
     LOG(ERROR) << "CreatePreviewDocument got 0 page count";
     set_error(PREVIEW_ERROR_ZERO_PAGES);
     return false;
   }
 
-  metafile_ = base::MakeUnique<PdfMetafileSkia>(PDF_SKIA_DOCUMENT_TYPE);
+  metafile_.reset(new PdfMetafileSkia(doc_type));
   CHECK(metafile_->Init());
 
   current_page_index_ = 0;
   pages_to_render_ = pages;
   // Sort and make unique.
   std::sort(pages_to_render_.begin(), pages_to_render_.end());
   pages_to_render_.resize(
       std::unique(pages_to_render_.begin(), pages_to_render_.end()) -
       pages_to_render_.begin());
   // Remove invalid pages.
@@ skipping 218 matching lines @@
       blink::WebConsoleMessage::kLevelWarning, message));
   return false;
 }
 
 void PrintRenderFrameHelper::ScriptingThrottler::Reset() {
   // Reset counter on successful print.
   count_ = 0;
 }
 
 }  // namespace printing