Experimetal copy of https://codereview.chromium.org/2512783002/

content/renderer/pepper/pepper_plugin_instance_impl.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 "content/renderer/pepper/pepper_plugin_instance_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
@@ skipping 75 matching lines @@
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/url_request_info_data.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
-#include "printing/features/features.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
 #include "third_party/WebKit/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/public/platform/WebGamepads.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
@@ skipping 1660 matching lines @@
 }
 
 bool PepperPluginInstanceImpl::IsPrintScalingDisabled() {
   DCHECK(plugin_print_interface_);
   if (!plugin_print_interface_)
     return false;
   return plugin_print_interface_->IsScalingDisabled(pp_instance()) == PP_TRUE;
 }
 
 int PepperPluginInstanceImpl::PrintBegin(const WebPrintParams& print_params) {
+#if BUILDFLAG(ENABLE_PRINTING)
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   PP_PrintOutputFormat_Dev format;
   if (!GetPreferredPrintOutputFormat(&format)) {
     // PrintBegin should not have been called since SupportsPrintInterface
     // would have returned false;
     NOTREACHED();
     return 0;
   }
   int num_pages = 0;
   PP_PrintSettings_Dev print_settings;
   print_settings.printable_area = PP_FromGfxRect(print_params.printableArea);
   print_settings.content_area = PP_FromGfxRect(print_params.printContentArea);
   print_settings.paper_size = PP_FromGfxSize(print_params.paperSize);
   print_settings.dpi = print_params.printerDPI;
   print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
   print_settings.grayscale = PP_FALSE;
   print_settings.print_scaling_option =
       static_cast<PP_PrintScalingOption_Dev>(print_params.printScalingOption);
   print_settings.format = format;
   num_pages = plugin_print_interface_->Begin(pp_instance(), &print_settings);
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
-  canvas_ = nullptr;
+  metafile_wrapper_.reset();
   ranges_.clear();
   return num_pages;
+#else
+  NOTREACHED();
+  return 0;
+#endif  // BUILDFLAG(ENABLE_PRINTING)
 }
 
 void PepperPluginInstanceImpl::PrintPage(int page_number,
                                          blink::WebCanvas* canvas) {
 #if BUILDFLAG(ENABLE_PRINTING)
   DCHECK(plugin_print_interface_);
   PP_PrintPageNumberRange_Dev page_range;
   page_range.first_page_number = page_range.last_page_number = page_number;
   // The canvas only has a metafile on it for print preview.
-  bool save_for_later =
-      (printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas) != NULL);
+  sk_sp<printing::MetafileSkiaWrapper> wrapper =
+      printing::MetafileSkiaWrapper::RefFromCanvas(*canvas);
+  bool save_for_later = wrapper && wrapper->metafile();
 #if defined(OS_MACOSX)
   save_for_later = save_for_later && skia::IsPreviewMetafile(*canvas);
 #endif  // defined(OS_MACOSX)
+
   if (save_for_later) {
     ranges_.push_back(page_range);
-    canvas_ = canvas;
+    metafile_wrapper_ = wrapper;
   } else {
-    PrintPageHelper(&page_range, 1, canvas);
+    PrintPageHelper(&page_range, 1, wrapper.get());
   }
-#endif
+#endif  // BUILDFLAG(ENABLE_PRINTING)
 }
 
+#if BUILDFLAG(ENABLE_PRINTING)
 void PepperPluginInstanceImpl::PrintPageHelper(
     PP_PrintPageNumberRange_Dev* page_ranges,
     int num_ranges,
-    blink::WebCanvas* canvas) {
+    printing::MetafileSkiaWrapper* wrapper) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   DCHECK(plugin_print_interface_);
   if (!plugin_print_interface_)
     return;
   PP_Resource print_output = plugin_print_interface_->PrintPages(
       pp_instance(), page_ranges, num_ranges);
   if (!print_output)
     return;
 
   if (current_print_settings_.format == PP_PRINTOUTPUTFORMAT_PDF)
-    PrintPDFOutput(print_output, canvas);
+    PrintPDFOutput(print_output, wrapper);
 
   // Now we need to release the print output resource.
   PluginModule::GetCore()->ReleaseResource(print_output);
 }
+#endif  // BUILDFLAG(ENABLE_PRINTING)
 
 void PepperPluginInstanceImpl::PrintEnd() {
+#if BUILDFLAG(ENABLE_PRINTING)
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
-  if (!ranges_.empty())
-    PrintPageHelper(&(ranges_.front()), ranges_.size(), canvas_);
-  canvas_ = nullptr;
+  if (!ranges_.empty()) {
+    PrintPageHelper(&(ranges_.front()), ranges_.size(),
+                    metafile_wrapper_.get());
+  }
+  metafile_wrapper_.reset();
   ranges_.clear();
 
   DCHECK(plugin_print_interface_);
   if (plugin_print_interface_)
     plugin_print_interface_->End(pp_instance());
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
 #if defined(OS_MACOSX)
   last_printed_page_ = NULL;
 #endif  // defined(OS_MACOSX)
+#else
+  NOTREACHED();
+#endif  // BUILDFLAG(ENABLE_PRINTING)
 }
 
 bool PepperPluginInstanceImpl::GetPrintPresetOptionsFromDocument(
     blink::WebPrintPresetOptions* preset_options) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   if (!LoadPdfInterface())
     return false;
 
   PP_PdfPrintPresetOptions_Dev options;
@@ skipping 136 matching lines @@
   WebLocalFrame* frame = document.frame();
   if (!frame)
     return false;
   WebView* view = frame->view();
   if (!view)
     return false;
 
   return view->isAcceleratedCompositingActive();
 }
 
-bool PepperPluginInstanceImpl::PrintPDFOutput(PP_Resource print_output,
-                                              blink::WebCanvas* canvas) {
+bool PepperPluginInstanceImpl::PrintPDFOutput(
+    PP_Resource print_output,
+    printing::MetafileSkiaWrapper* wrapper) {
 #if BUILDFLAG(ENABLE_PRINTING)
   ppapi::thunk::EnterResourceNoLock<PPB_Buffer_API> enter(print_output, true);
   if (enter.failed())
     return false;
 
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size()) {
     NOTREACHED();
     return false;
   }
 
-  printing::PdfMetafileSkia* metafile =
-      printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
-  if (metafile)
-    return metafile->InitFromData(mapper.data(), mapper.size());
+  if (wrapper && wrapper->metafile())
+    return wrapper->metafile()->InitFromData(mapper.data(), mapper.size());
 
   NOTREACHED();
-#endif  // ENABLE_PRINTING
+#endif  // BUILDFLAG(ENABLE_PRINTING)
   return false;
 }
 
 void PepperPluginInstanceImpl::UpdateLayer(bool force_creation) {
   if (!container_)
     return;
 
   bool want_3d_layer = !!bound_graphics_3d_.get();
   bool want_2d_layer = !!bound_graphics_2d_platform_;
   bool want_texture_layer = want_3d_layer || want_2d_layer;
@@ skipping 1386 matching lines @@
     const cc::TextureMailbox& mailbox) const {
   auto it =
       std::find_if(texture_ref_counts_.begin(), texture_ref_counts_.end(),
                    [&mailbox](const TextureMailboxRefCount& ref_count) {
                      return ref_count.first.mailbox() == mailbox.mailbox();
                    });
   return it != texture_ref_counts_.end();
 }
 
 }  // namespace content