Pull new PPAPI, rename non-P0 interfaces to Dev, rename DeviceContext2D to Gr...

webkit/glue/plugins/pepper_plugin_instance.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.
 
 #include "webkit/glue/plugins/pepper_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/histogram.h"
 #if defined(OS_MACOSX)
 #include "base/mac_util.h"
 #include "base/scoped_cftyperef.h"
 #endif
 #include "base/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/rect.h"
 #if defined(OS_WIN)
 #include "gfx/codec/jpeg_codec.h"
 #include "gfx/gdi_util.h"
 #endif
 #include "gfx/skia_util.h"
 #include "printing/native_metafile.h"
 #include "printing/units.h"
 #include "skia/ext/vector_platform_device.h"
 #include "skia/ext/platform_canvas.h"
+#include "third_party/ppapi/c/dev/ppb_find_dev.h"
+#include "third_party/ppapi/c/dev/ppp_find_dev.h"
+#include "third_party/ppapi/c/dev/ppp_zoom_dev.h"
+#include "third_party/ppapi/c/pp_event.h"
 #include "third_party/ppapi/c/pp_instance.h"
-#include "third_party/ppapi/c/pp_event.h"
 #include "third_party/ppapi/c/pp_rect.h"
 #include "third_party/ppapi/c/pp_resource.h"
 #include "third_party/ppapi/c/pp_var.h"
 #include "third_party/ppapi/c/ppb_core.h"
-#include "third_party/ppapi/c/ppb_find.h"
 #include "third_party/ppapi/c/ppb_instance.h"
-#include "third_party/ppapi/c/ppp_find.h"
 #include "third_party/ppapi/c/ppp_instance.h"
-#include "third_party/ppapi/c/ppp_zoom.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebRect.h"
 #include "webkit/glue/plugins/pepper_buffer.h"
-#include "webkit/glue/plugins/pepper_device_context_2d.h"
+#include "webkit/glue/plugins/pepper_graphics_2d.h"
 #include "webkit/glue/plugins/pepper_event_conversion.h"
 #include "webkit/glue/plugins/pepper_image_data.h"
 #include "webkit/glue/plugins/pepper_plugin_delegate.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/pepper_string.h"
 #include "webkit/glue/plugins/pepper_url_loader.h"
 #include "webkit/glue/plugins/pepper_var.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
@@ skipping 84 matching lines @@
   return instance->GetWindowObject();
 }
 
 PP_Var GetOwnerElementObject(PP_Instance instance_id) {
   PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
   if (!instance)
     return PP_MakeVoid();
   return instance->GetOwnerElementObject();
 }
 
-bool BindGraphicsDeviceContext(PP_Instance instance_id, PP_Resource device_id) {
+bool BindGraphics(PP_Instance instance_id, PP_Resource device_id) {
   PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
   if (!instance)
     return false;
-  return instance->BindGraphicsDeviceContext(device_id);
+  return instance->BindGraphics(device_id);
 }
 
 bool IsFullFrame(PP_Instance instance_id) {
   PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
   if (!instance)
     return false;
   return instance->full_frame();
 }
 
 const PPB_Instance ppb_instance = {
   &GetWindowObject,
   &GetOwnerElementObject,
-  &BindGraphicsDeviceContext,
+  &BindGraphics,
   &IsFullFrame,
 };
 
 void NumberOfFindResultsChanged(PP_Instance instance_id,
                                 int32_t total,
                                 bool final_result) {
   PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
   if (!instance)
     return;
 
   DCHECK_NE(instance->find_identifier(), -1);
   instance->delegate()->DidChangeNumberOfFindResults(
       instance->find_identifier(), total, final_result);
 }
 
 void SelectedFindResultChanged(PP_Instance instance_id,
                                int32_t index) {
   PluginInstance* instance = PluginInstance::FromPPInstance(instance_id);
   if (!instance)
     return;
 
   DCHECK_NE(instance->find_identifier(), -1);
   instance->delegate()->DidChangeSelectedFindResult(
       instance->find_identifier(), index);
 }
 
-const PPB_Find ppb_find = {
+const PPB_Find_Dev ppb_find = {
   &NumberOfFindResultsChanged,
   &SelectedFindResultChanged,
 };
 
 }  // namespace
 
 PluginInstance::PluginInstance(PluginDelegate* delegate,
                                PluginModule* module,
                                const PPP_Instance* instance_interface)
     : delegate_(delegate),
@@ skipping 25 matching lines @@
 const PPB_Instance* PluginInstance::GetInterface() {
   return &ppb_instance;
 }
 
 // static
 PluginInstance* PluginInstance::FromPPInstance(PP_Instance instance) {
   return reinterpret_cast<PluginInstance*>(instance);
 }
 
 // static
-const PPB_Find* PluginInstance::GetFindInterface() {
+const PPB_Find_Dev* PluginInstance::GetFindInterface() {
   return &ppb_find;
 }
 
 PP_Instance PluginInstance::GetPPInstance() {
   return reinterpret_cast<intptr_t>(this);
 }
 
 void PluginInstance::Paint(WebCanvas* canvas,
                            const gfx::Rect& plugin_rect,
                            const gfx::Rect& paint_rect) {
-  if (device_context_2d_)
-    device_context_2d_->Paint(canvas, plugin_rect, paint_rect);
+  if (bound_graphics_2d_)
+    bound_graphics_2d_->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PluginInstance::InvalidateRect(const gfx::Rect& rect) {
   if (!container_ || position_.IsEmpty())
     return;  // Nothing to do.
   if (rect.IsEmpty())
     container_->invalidate();
   else
     container_->invalidateRect(rect);
 }
 
 PP_Var PluginInstance::GetWindowObject() {
   if (!container_)
     return PP_MakeVoid();
 
   WebFrame* frame = container_->element().document().frame();
   if (!frame)
     return PP_MakeVoid();
 
   return NPObjectToPPVar(frame->windowObject());
 }
 
 PP_Var PluginInstance::GetOwnerElementObject() {
   if (!container_)
     return PP_MakeVoid();
 
   return NPObjectToPPVar(container_->scriptableObjectForElement());
 }
 
-bool PluginInstance::BindGraphicsDeviceContext(PP_Resource device_id) {
+bool PluginInstance::BindGraphics(PP_Resource device_id) {
   if (!device_id) {
     // Special-case clearing the current device.
-    if (device_context_2d_) {
-      device_context_2d_->BindToInstance(NULL);
-      device_context_2d_ = NULL;
+    if (bound_graphics_2d_) {
+      bound_graphics_2d_->BindToInstance(NULL);
+      bound_graphics_2d_ = NULL;
       InvalidateRect(gfx::Rect());
     }
     return true;
   }
 
-  scoped_refptr<DeviceContext2D> device_2d =
-      Resource::GetAs<DeviceContext2D>(device_id);
+  scoped_refptr<Graphics2D> device_2d = Resource::GetAs<Graphics2D>(device_id);
 
   if (device_2d) {
     if (!device_2d->BindToInstance(this))
       return false;  // Can't bind to more than one instance.
 
     // See http://crbug.com/49403: this can be further optimized by keeping the
     // old device around and painting from it.
-    if (device_context_2d_.get()) {
+    if (bound_graphics_2d_.get()) {
       // Start the new image with the content of the old image until the plugin
       // repaints.
       const SkBitmap* old_backing_bitmap =
-          device_context_2d_->image_data()->GetMappedBitmap();
+          bound_graphics_2d_->image_data()->GetMappedBitmap();
       SkRect old_size = SkRect::MakeWH(
           SkScalar(static_cast<float>(old_backing_bitmap->width())),
           SkScalar(static_cast<float>(old_backing_bitmap->height())));
 
       SkCanvas canvas(*device_2d->image_data()->GetMappedBitmap());
       canvas.drawBitmap(*old_backing_bitmap, 0, 0);
 
       // Fill in any extra space with white.
       canvas.clipRect(old_size, SkRegion::kDifference_Op);
       canvas.drawARGB(255, 255, 255, 255);
     }
 
-    device_context_2d_ = device_2d;
+    bound_graphics_2d_ = device_2d;
     // BindToInstance will have invalidated the plugin if necessary.
   }
 
   return true;
 }
 
 bool PluginInstance::SetCursor(PP_CursorType_Dev type) {
   cursor_.reset(new WebCursorInfo(static_cast<WebCursorInfo::Type>(type)));
   return true;
 }
@@ skipping 61 matching lines @@
     clip_ = clip;
   }
 
   PP_Rect pp_position, pp_clip;
   RectToPPRect(position_, &pp_position);
   RectToPPRect(clip_, &pp_clip);
   instance_interface_->ViewChanged(GetPPInstance(), &pp_position, &pp_clip);
 }
 
 void PluginInstance::ViewInitiatedPaint() {
-  if (device_context_2d_)
-    device_context_2d_->ViewInitiatedPaint();
+  if (bound_graphics_2d_)
+    bound_graphics_2d_->ViewInitiatedPaint();
 }
 
 void PluginInstance::ViewFlushedPaint() {
-  if (device_context_2d_)
-    device_context_2d_->ViewFlushedPaint();
+  if (bound_graphics_2d_)
+    bound_graphics_2d_->ViewFlushedPaint();
 }
 
 string16 PluginInstance::GetSelectedText(bool html) {
   PP_Var rv = instance_interface_->GetSelectedText(GetPPInstance(), html);
   String* string = GetString(rv);
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
@@ skipping 23 matching lines @@
 void PluginInstance::StopFind() {
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(GetPPInstance());
 }
 
 bool PluginInstance::LoadFindInterface() {
   if (!plugin_find_interface_) {
     plugin_find_interface_ =
-        reinterpret_cast<const PPP_Find*>(module_->GetPluginInterface(
-            PPP_FIND_INTERFACE));
+        reinterpret_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
+            PPP_FIND_DEV_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
 bool PluginInstance::LoadZoomInterface() {
   if (!plugin_zoom_interface_) {
     plugin_zoom_interface_ =
-        reinterpret_cast<const PPP_Zoom*>(module_->GetPluginInterface(
-            PPP_ZOOM_INTERFACE));
+        reinterpret_cast<const PPP_Zoom_Dev*>(module_->GetPluginInterface(
+            PPP_ZOOM_DEV_INTERFACE));
   }
 
   return !!plugin_zoom_interface_;
 }
 
 bool PluginInstance::GetPreferredPrintOutputFormat(
-    PP_PrintOutputFormat* format) {
+    PP_PrintOutputFormat_Dev* format) {
   if (!plugin_print_interface_) {
     plugin_print_interface_ =
-        reinterpret_cast<const PPP_Printing*>(module_->GetPluginInterface(
-            PPP_PRINTING_INTERFACE));
+        reinterpret_cast<const PPP_Printing_Dev*>(module_->GetPluginInterface(
+            PPP_PRINTING_DEV_INTERFACE));
   }
   if (!plugin_print_interface_)
     return false;
   uint32_t format_count = 0;
-  PP_PrintOutputFormat* supported_formats =
+  PP_PrintOutputFormat_Dev* supported_formats =
       plugin_print_interface_->QuerySupportedFormats(GetPPInstance(),
                                                      &format_count);
   if (!supported_formats)
     return false;
 
   bool found_supported_format = false;
   for (uint32_t index = 0; index < format_count; index++) {
     if (supported_formats[index] == PP_PRINTOUTPUTFORMAT_PDF) {
       // If we found PDF, we are done.
       found_supported_format = true;
       *format = PP_PRINTOUTPUTFORMAT_PDF;
       break;
     } else if (supported_formats[index] == PP_PRINTOUTPUTFORMAT_RASTER) {
       // We found raster. Keep looking.
       found_supported_format = true;
       *format = PP_PRINTOUTPUTFORMAT_RASTER;
     }
   }
   PluginModule::GetCore()->MemFree(supported_formats);
   return found_supported_format;
 }
 
 bool PluginInstance::SupportsPrintInterface() {
-  PP_PrintOutputFormat format;
+  PP_PrintOutputFormat_Dev format;
   return GetPreferredPrintOutputFormat(&format);
 }
 
 int PluginInstance::PrintBegin(const gfx::Rect& printable_area,
                                int printer_dpi) {
-  PP_PrintOutputFormat format;
+  PP_PrintOutputFormat_Dev format;
   if (!GetPreferredPrintOutputFormat(&format)) {
     // PrintBegin should not have been called since SupportsPrintInterface
     // would have returned false;
     NOTREACHED();
     return 0;
   }
 
-  PP_PrintSettings print_settings;
+  PP_PrintSettings_Dev print_settings;
   RectToPPRect(printable_area, &print_settings.printable_area);
   print_settings.dpi = printer_dpi;
   print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
   print_settings.grayscale = false;
   print_settings.format = format;
   int num_pages = plugin_print_interface_->Begin(GetPPInstance(),
                                                  &print_settings);
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
 #if defined (OS_LINUX)
   num_pages_ = num_pages;
   pdf_output_done_ = false;
 #endif  // (OS_LINUX)
   return num_pages;
 }
 
 bool PluginInstance::PrintPage(int page_number, WebKit::WebCanvas* canvas) {
   DCHECK(plugin_print_interface_);
-  PP_PrintPageNumberRange page_range;
+  PP_PrintPageNumberRange_Dev page_range;
 #if defined(OS_LINUX)
   if (current_print_settings_.format == PP_PRINTOUTPUTFORMAT_PDF) {
     // On Linux we will try and output all pages as PDF in the first call to
     // PrintPage. This is a temporary hack.
     // TODO(sanjeevr): Remove this hack and fix this by changing the print
     // interfaces for WebFrame and WebPlugin.
     if (page_number != 0)
       return pdf_output_done_;
     page_range.first_page_number = 0;
     page_range.last_page_number = num_pages_ - 1;
@@ skipping 30 matching lines @@
   last_printed_page_ = NULL;
 #elif defined(OS_LINUX)
   num_pages_ = 0;
   pdf_output_done_ = false;
 #endif  // defined(OS_LINUX)
 }
 
 void PluginInstance::Graphics3DContextLost() {
   if (!plugin_graphics_3d_interface_) {
     plugin_graphics_3d_interface_ =
-        reinterpret_cast<const PPP_Graphics3D*>(module_->GetPluginInterface(
-            PPP_GRAPHICS_3D_INTERFACE));
+        reinterpret_cast<const PPP_Graphics3D_Dev*>(module_->GetPluginInterface(
+            PPP_GRAPHICS_3D_DEV_INTERFACE));
   }
   if (plugin_graphics_3d_interface_)
     plugin_graphics_3d_interface_->Graphics3DContextLost(GetPPInstance());
 }
 
 bool PluginInstance::PrintPDFOutput(PP_Resource print_output,
                                     WebKit::WebCanvas* canvas) {
   scoped_refptr<Buffer> buffer(Resource::GetAs<Buffer>(print_output));
   if (!buffer.get() || !buffer->is_mapped() || !buffer->size()) {
     NOTREACHED();
@@ skipping 212 matching lines @@
   bounds.size.width = dest_rect.width();
   bounds.size.height = dest_rect.height();
 
   CGContextDrawImage(canvas, bounds, image);
   CGContextRestoreGState(canvas);
 }
 #endif  // defined(OS_MACOSX)
 
 
 }  // namespace pepper