Added support for vector printing for Pepper v1 plugins for Windows. Mac and ...

chrome/renderer/webplugin_delegate_pepper.cc

 // Copyright (c) 2010 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.
 
 #define PEPPER_APIS_ENABLED 1
 
 #include "chrome/renderer/webplugin_delegate_pepper.h"
 
 #include <string>
 #include <vector>
 
 #if defined(OS_LINUX)
 #include <unistd.h>
 #endif
 
 #include "base/file_util.h"
 #include "base/keyboard_codes.h"
 #if defined(OS_MACOSX)
 #include "base/mac_util.h"
 #endif
 #include "base/md5.h"
 #include "base/message_loop.h"
+#include "base/path_service.h"
 #include "base/process_util.h"
 #if defined(OS_MACOSX)
 #include "base/scoped_cftyperef.h"
 #endif
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/time.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/pepper_widget.h"
 #include "chrome/renderer/render_thread.h"
 #if defined(OS_LINUX)
 #include "chrome/renderer/renderer_sandbox_support_linux.h"
 #endif
 #include "chrome/renderer/webplugin_delegate_proxy.h"
 #include "gfx/blit.h"
 #if defined(OS_WIN)
 #include "gfx/codec/jpeg_codec.h"
 #include "gfx/gdi_util.h"
+#include "printing/units.h"
 #include "skia/ext/vector_platform_device.h"
 #endif
 #include "third_party/npapi/bindings/npapi_extensions.h"
 #include "third_party/npapi/bindings/npapi_extensions_private.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_instance.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/plugins/plugin_list.h"
+#include "webkit/glue/plugins/plugin_host.h"
 #include "webkit/glue/plugins/plugin_stream_url.h"
 #include "webkit/glue/webkit_glue.h"
 
 #if defined(ENABLE_GPU)
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #endif
 
 using gpu::Buffer;
 using webkit_glue::WebPlugin;
 using webkit_glue::WebPluginDelegate;
@@ skipping 13 matching lines @@
 
 struct Device3DImpl {
   gpu::CommandBuffer* command_buffer;
   bool dynamically_created;
 };
 
 const int32 kDefaultCommandBufferSize = 1024 * 1024;
 
 }  // namespace
 
+static const float kPointsPerInch = 72.0;
+
+#if defined(OS_WIN)
+// Exported by pdf.dll
+typedef bool (__stdcall *RenderPDFPageToDCProc)(
+    const unsigned char* pdf_buffer, int buffer_size, int page_number, HDC dc,
+    int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y,
+    int bounds_width, int bounds_height, bool fit_to_bounds,
+    bool stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds);
+#endif  // defined(OS_WIN)
+
 WebPluginDelegatePepper* WebPluginDelegatePepper::Create(
     const FilePath& filename,
     const std::string& mime_type,
     const base::WeakPtr<RenderView>& render_view) {
   scoped_refptr<NPAPI::PluginLib> plugin_lib =
       NPAPI::PluginLib::CreatePluginLib(filename);
   if (plugin_lib.get() == NULL)
     return NULL;
 
   NPError err = plugin_lib->NP_Initialize();
@@ skipping 1011 matching lines @@
     NPRect np_printable_area = {0};
     np_printable_area.left = printable_area.x();
     np_printable_area.top = printable_area.y();
     np_printable_area.right = np_printable_area.left + printable_area.width();
     np_printable_area.bottom = np_printable_area.top + printable_area.height();
     if (NPERR_NO_ERROR == print_extensions->printBegin(instance()->npp(),
                                                        &np_printable_area,
                                                        printer_dpi,
                                                        &num_pages)) {
       current_printable_area_ = printable_area;
+      current_printer_dpi_ = printer_dpi;
     }
   }
   return num_pages;
 }
 
+bool WebPluginDelegatePepper::VectorPrintPage(int page_number,
+                                              WebKit::WebCanvas* canvas) {
+#if !defined(OS_WIN)
+  // TODO(sanjeevr): Add vector print support for Mac and Linux.
+  return false;
+#endif  // !defined(OS_WIN)
+  NPPPrintExtensions* print_extensions = GetPrintExtensions();
+  if (!print_extensions)
+    return false;
+#if defined(OS_WIN)
+  // For Windows, we need the PDF DLL to render the output PDF to a DC.
+  FilePath pdf_path;
+  PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_path);
+  HMODULE pdf_module = GetModuleHandle(pdf_path.value().c_str());
+  if (!pdf_module)
+    return false;
+  RenderPDFPageToDCProc render_proc =
+      reinterpret_cast<RenderPDFPageToDCProc>(
+          GetProcAddress(pdf_module, "RenderPDFPageToDC"));
+  if (!render_proc)
+    return false;
+#endif  // defined(OS_WIN)
+
+  unsigned char* pdf_output = NULL;
+  int32 output_size = 0;
+  NPError err = print_extensions->printPageAsPDF(instance()->npp(), page_number,
+                                                 &pdf_output, &output_size);
+  if (err != NPERR_NO_ERROR)
+    return false;
+
+  bool ret = false;
+#if defined(OS_WIN)
+  // On Windows, we now need to render the PDF to the DC that backs the
+  // supplied canvas.
+  skia::VectorPlatformDevice& device =
+      static_cast<skia::VectorPlatformDevice&>(
+          canvas->getTopPlatformDevice());
+  HDC dc = device.getBitmapDC();
+  gfx::Size size_in_pixels;
+  size_in_pixels.set_width(
+      printing::ConvertUnit(current_printable_area_.width(),
+                            static_cast<int>(kPointsPerInch),
+                            current_printer_dpi_));
+  size_in_pixels.set_height(
+      printing::ConvertUnit(current_printable_area_.height(),
+                            static_cast<int>(kPointsPerInch),
+                            current_printer_dpi_));
+  // We need to render using the actual printer DPI (rendering to a smaller
+  // set of pixels leads to a blurry output). However, we need to counter the
+  // scaling up that will happen in the browser.
+  XFORM xform = {0};
+  xform.eM11 = xform.eM22 = kPointsPerInch / current_printer_dpi_;
+  ModifyWorldTransform(dc, &xform, MWT_LEFTMULTIPLY);
+
+  ret = render_proc(pdf_output, output_size, 0, dc, current_printer_dpi_,
+                    current_printer_dpi_, 0, 0, size_in_pixels.width(),
+                    size_in_pixels.height(), true, false, true, true);
+#endif  // defined(OS_WIN)
+
+  NPAPI::PluginHost::Singleton()->host_functions()->memfree(pdf_output);
+  return ret;
+}
+
 bool WebPluginDelegatePepper::PrintPage(int page_number,
                                         WebKit::WebCanvas* canvas) {
   NPPPrintExtensions* print_extensions = GetPrintExtensions();
   if (!print_extensions)
     return false;
 
+  // First try and use vector print.
+  if (VectorPrintPage(page_number, canvas))
+    return true;
+
   DCHECK(!current_printable_area_.IsEmpty());
 
   // Calculate the width and height needed for the raster image.
   NPRect np_printable_area = {0};
   np_printable_area.left = current_printable_area_.x();
   np_printable_area.top = current_printable_area_.y();
   np_printable_area.right =
       current_printable_area_.x() + current_printable_area_.width();
   np_printable_area.bottom =
       current_printable_area_.y() + current_printable_area_.height();
@@ skipping 63 matching lines @@
     canvas->drawBitmapRect(committed, &src_rect, dest_rect);
 #endif  // defined(OS_MACOSX)
   return true;
 }
 
 void WebPluginDelegatePepper::PrintEnd() {
   NPPPrintExtensions* print_extensions = GetPrintExtensions();
   if (print_extensions)
     print_extensions->printEnd(instance()->npp());
   current_printable_area_ = gfx::Rect();
+  current_printer_dpi_ = -1;
 #if defined(OS_MACOSX)
   last_printed_page_ = SkBitmap();
 #endif  // defined(OS_MACOSX)
 }
 
 bool WebPluginDelegatePepper::SupportsFind() {
   return GetFindExtensions() != NULL;
 }
 
 
 WebPluginDelegatePepper::WebPluginDelegatePepper(
     const base::WeakPtr<RenderView>& render_view,
     NPAPI::PluginInstance *instance)
     : render_view_(render_view),
       plugin_(NULL),
       instance_(instance),
       nested_delegate_(NULL),
+      current_printer_dpi_(-1),
 #if defined(ENABLE_GPU)
       command_buffer_(NULL),
 #endif
       find_identifier_(-1),
       method_factory3d_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       current_choose_file_callback_(NULL),
       current_choose_file_user_data_(NULL) {
   // For now we keep a window struct, although it isn't used.
   memset(&window_, 0, sizeof(window_));
   // All Pepper plugins are windowless and transparent.
@@ skipping 374 matching lines @@
   bounds.origin.x = dest_rect.x();
   bounds.origin.y = canvas_height - dest_rect.y() - dest_rect.height();
   bounds.size.width = dest_rect.width();
   bounds.size.height = dest_rect.height();
 
   CGContextDrawImage(canvas, bounds, image);
   CGContextRestoreGState(canvas);
 }
 #endif  // defined(OS_MACOSX)