Move the Pepper implementation from webkit/glue/plugins/pepper_* to...

webkit/plugins/ppapi/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 "webkit/plugins/ppapi/plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
-#if defined(OS_MACOSX)
-#include "base/mac_util.h"
-#include "base/mac/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 "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
@@ skipping 10 matching lines @@
 #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 "third_party/WebKit/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebView.h"
-#include "webkit/glue/plugins/pepper_buffer.h"
-#include "webkit/glue/plugins/pepper_common.h"
-#include "webkit/glue/plugins/pepper_graphics_2d.h"
-#include "webkit/glue/plugins/pepper_graphics_3d.h"
-#include "webkit/glue/plugins/pepper_event_conversion.h"
-#include "webkit/glue/plugins/pepper_fullscreen_container.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"
-#include "webkit/glue/plugins/ppp_private.h"
+#include "webkit/plugins/ppapi/common.h"
+#include "webkit/plugins/ppapi/event_conversion.h"
+#include "webkit/plugins/ppapi/fullscreen_container.h"
+#include "webkit/plugins/ppapi/plugin_delegate.h"
+#include "webkit/plugins/ppapi/plugin_module.h"
+#include "webkit/plugins/ppapi/ppb_buffer_impl.h"
+#include "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
+#include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
+#include "webkit/plugins/ppapi/ppb_image_data_impl.h"
+#include "webkit/plugins/ppapi/ppb_url_loader_impl.h"
+#include "webkit/plugins/ppapi/ppp_pdf.h"
+#include "webkit/plugins/ppapi/string.h"
+#include "webkit/plugins/ppapi/var.h"
+
+#if defined(OS_MACOSX)
+#include "base/mac_util.h"
+#include "base/mac/scoped_cftyperef.h"
+#endif
+
+#if defined(OS_WIN)
+#include "gfx/codec/jpeg_codec.h"
+#include "gfx/gdi_util.h"
+#endif
 
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebPluginContainer;
 using WebKit::WebString;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
 
-namespace pepper {
+namespace webkit {
+namespace plugins {
+namespace ppapi {
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*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)
 
@@ skipping 205 matching lines @@
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(NULL),
       full_frame_(false),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
-      plugin_private_interface_(NULL),
+      plugin_pdf_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_zoom_interface_(NULL),
 #if defined (OS_LINUX)
       num_pages_(0),
       pdf_output_done_(false),
 #endif  // defined (OS_LINUX)
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
       fullscreen_container_(NULL) {
@@ skipping 117 matching lines @@
       } else if (bound_graphics_.get()) {
         bound_graphics_3d()->SetSwapBuffersCallback(NULL);
         bound_graphics_3d()->BindToInstance(NULL);
       }
       InvalidateRect(gfx::Rect());
     }
     bound_graphics_ = NULL;
     return true;
   }
 
-  scoped_refptr<Graphics2D> graphics_2d =
-      Resource::GetAs<Graphics2D>(graphics_id);
-  scoped_refptr<Graphics3D> graphics_3d =
-      Resource::GetAs<Graphics3D>(graphics_id);
+  scoped_refptr<PPB_Graphics2D_Impl> graphics_2d =
+      Resource::GetAs<PPB_Graphics2D_Impl>(graphics_id);
+  scoped_refptr<PPB_Graphics3D_Impl> graphics_3d =
+      Resource::GetAs<PPB_Graphics3D_Impl>(graphics_id);
 
   if (graphics_2d) {
     if (!graphics_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 (bound_graphics_2d()) {
       // Start the new image with the content of the old image until the plugin
       // repaints.
@@ skipping 93 matching lines @@
     argv[argc] = arg_values[i].c_str();
     argc++;
   }
 
   return PPBoolToBool(instance_interface_->DidCreate(pp_instance(),
                                                      argc,
                                                      argn.get(),
                                                      argv.get()));
 }
 
-bool PluginInstance::HandleDocumentLoad(URLLoader* loader) {
+bool PluginInstance::HandleDocumentLoad(PPB_URLLoader_Impl* loader) {
   Resource::ScopedResourceId resource(loader);
   return PPBoolToBool(instance_interface_->HandleDocumentLoad(pp_instance(),
                                                               resource.id));
 }
 
 bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
                                       WebCursorInfo* cursor_info) {
   std::vector<PP_InputEvent> pp_events;
   CreatePPEvent(event, &pp_events);
 
@@ skipping 82 matching lines @@
     gfx::Rect* location,
     gfx::Rect* clip) {
   if (!always_on_top_)
     return false;
   if (!bound_graphics_2d() || !bound_graphics_2d()->is_always_opaque())
     return false;
 
   // We specifically want to compare against the area covered by the backing
   // store when seeing if we cover the given paint bounds, since the backing
   // store could be smaller than the declared plugin area.
-  ImageData* image_data = bound_graphics_2d()->image_data();
+  PPB_ImageData_Impl* image_data = bound_graphics_2d()->image_data();
   gfx::Rect plugin_backing_store_rect(position_.origin(),
                                       gfx::Size(image_data->width(),
                                                 image_data->height()));
   gfx::Rect clip_page(clip_);
   clip_page.Offset(position_.origin());
   gfx::Rect plugin_paint_rect = plugin_backing_store_rect.Intersect(clip_page);
   if (!plugin_paint_rect.Contains(paint_bounds))
     return false;
 
   *dib = image_data->platform_image()->GetTransportDIB();
   *location = plugin_backing_store_rect;
   *clip = clip_page;
   return true;
 }
 
 string16 PluginInstance::GetSelectedText(bool html) {
   if (!LoadSelectionInterface())
     return string16();
 
   PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(),
                                                            BoolToPPBool(html));
   scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
   Var::PluginReleasePPVar(rv);  // Release the ref the plugin transfered to us.
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
 string16 PluginInstance::GetLinkAtPosition(const gfx::Point& point) {
-  if (!LoadPrivateInterface())
+  if (!LoadPdfInterface())
     return string16();
 
   PP_Point p;
   p.x = point.x();
   p.y = point.y();
-  PP_Var rv = plugin_private_interface_->GetLinkAtPosition(pp_instance(), p);
+  PP_Var rv = plugin_pdf_interface_->GetLinkAtPosition(pp_instance(), p);
   scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
   Var::PluginReleasePPVar(rv);  // Release the ref the plugin transfered to us.
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
 void PluginInstance::Zoom(double factor, bool text_only) {
   if (!LoadZoomInterface())
     return;
@@ skipping 29 matching lines @@
 bool PluginInstance::LoadFindInterface() {
   if (!plugin_find_interface_) {
     plugin_find_interface_ =
         reinterpret_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
             PPP_FIND_DEV_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
-bool PluginInstance::LoadPrivateInterface() {
-  if (!plugin_private_interface_) {
-    plugin_private_interface_ =
-        reinterpret_cast<const PPP_Private*>(module_->GetPluginInterface(
-            PPP_PRIVATE_INTERFACE));
+bool PluginInstance::LoadPdfInterface() {
+  if (!plugin_pdf_interface_) {
+    plugin_pdf_interface_ =
+        reinterpret_cast<const PPP_Pdf*>(module_->GetPluginInterface(
+            PPP_PDF_INTERFACE));
   }
 
-  return !!plugin_private_interface_;
+  return !!plugin_pdf_interface_;
 }
 
 bool PluginInstance::LoadSelectionInterface() {
   if (!plugin_selection_interface_) {
     plugin_selection_interface_ =
         reinterpret_cast<const PPP_Selection_Dev*>(module_->GetPluginInterface(
             PPP_SELECTION_DEV_INTERFACE));
   }
 
   return !!plugin_selection_interface_;
@@ skipping 169 matching lines @@
   request.setHTTPMethod(WebString::fromUTF8("GET"));
   request.setFirstPartyForCookies(document.firstPartyForCookies());
 
   WebString target_str = WebString::fromUTF8(target);
   container_->loadFrameRequest(request, target_str, false, NULL);
   return true;
 }
 
 bool PluginInstance::PrintPDFOutput(PP_Resource print_output,
                                     WebKit::WebCanvas* canvas) {
-  scoped_refptr<Buffer> buffer(Resource::GetAs<Buffer>(print_output));
+  scoped_refptr<PPB_Buffer_Impl> buffer(
+      Resource::GetAs<PPB_Buffer_Impl>(print_output));
   if (!buffer.get() || !buffer->is_mapped() || !buffer->size()) {
     NOTREACHED();
     return false;
   }
 #if defined(OS_WIN)
   // For Windows, we need the PDF DLL to render the output PDF to a DC.
   HMODULE pdf_module = GetModuleHandle(L"pdf.dll");
   if (!pdf_module)
     return false;
   RenderPDFPageToDCProc render_proc =
@@ skipping 63 matching lines @@
                     current_print_settings_.dpi, current_print_settings_.dpi,
                     0, 0, size_in_pixels.width(),
                     size_in_pixels.height(), true, false, true, true);
 #endif  // defined(OS_WIN)
 
   return ret;
 }
 
 bool PluginInstance::PrintRasterOutput(PP_Resource print_output,
                                        WebKit::WebCanvas* canvas) {
-  scoped_refptr<ImageData> image(Resource::GetAs<ImageData>(print_output));
+  scoped_refptr<PPB_ImageData_Impl> image(
+      Resource::GetAs<PPB_ImageData_Impl>(print_output));
   if (!image.get() || !image->is_mapped())
     return false;
 
   const SkBitmap* bitmap = image->GetMappedBitmap();
   if (!bitmap)
     return false;
 
   // Draw the printed image into the supplied canvas.
   SkIRect src_rect;
   src_rect.set(0, 0, bitmap->width(), bitmap->height());
@@ skipping 118 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)
 
-Graphics2D* PluginInstance::bound_graphics_2d() const {
+PPB_Graphics2D_Impl* PluginInstance::bound_graphics_2d() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
-  return bound_graphics_->Cast<Graphics2D>();
+  return bound_graphics_->Cast<PPB_Graphics2D_Impl>();
 }
 
-Graphics3D* PluginInstance::bound_graphics_3d() const {
+PPB_Graphics3D_Impl* PluginInstance::bound_graphics_3d() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
-  return bound_graphics_->Cast<Graphics3D>();
+  return bound_graphics_->Cast<PPB_Graphics3D_Impl>();
 }
 
-}  // namespace pepper
+}  // namespace ppapi
+}  // namespace plugins
+}  // namespace webkit
+