Binding Graphics3D with Instance and OpenGLES2 interface.

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // Copyright (c) 2011 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/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 37 matching lines @@
 #include "ui/gfx/skia_util.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/message_channel.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.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_input_event_impl.h"
 #include "webkit/plugins/ppapi/ppb_surface_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_loader_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_request_info_impl.h"
 #include "webkit/plugins/ppapi/ppp_pdf.h"
 #include "webkit/plugins/ppapi/string.h"
 #include "webkit/plugins/ppapi/var.h"
 #include "webkit/plugins/sad_plugin.h"
 
@@ skipping 14 matching lines @@
 #include "ui/gfx/gdi_util.h"
 #endif
 
 #if defined(OS_MACOSX) && defined(USE_SKIA)
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Graphics2D_API;
+using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::thunk::PPB_Instance_FunctionAPI;
 using ppapi::thunk::PPB_Surface3D_API;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebPluginContainer;
@@ skipping 177 matching lines @@
                            const gfx::Rect& paint_rect) {
   if (module()->is_crashed()) {
     // Crashed plugin painting.
     if (!sad_plugin_)  // Lazily initialize bitmap.
       sad_plugin_ = delegate_->GetSadPluginBitmap();
     if (sad_plugin_)
       webkit::PaintSadPlugin(canvas, plugin_rect, *sad_plugin_);
     return;
   }
 
-  if (bound_graphics_2d())
-    bound_graphics_2d()->Paint(canvas, plugin_rect, paint_rect);
+  if (GetBoundGraphics2D())
+    GetBoundGraphics2D()->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PluginInstance::InvalidateRect(const gfx::Rect& rect) {
   if (fullscreen_container_) {
     if (rect.IsEmpty())
       fullscreen_container_->Invalidate();
     else
       fullscreen_container_->InvalidateRect(rect);
   } else {
     if (!container_ || position_.IsEmpty())
@@ skipping 13 matching lines @@
       container_->scrollRect(dx, dy, rect);
     } else {
       // Can't do optimized scrolling since there could be other elements on top
       // of us.
       InvalidateRect(rect);
     }
   }
 }
 
 unsigned PluginInstance::GetBackingTextureId() {
-  if (!bound_graphics_3d())
-    return 0;
+  if (GetBoundGraphics3D())
+    return GetBoundGraphics3D()->GetBackingTextureId();
+  else if (GetBoundSurface3D())
+    return GetBoundSurface3D()->GetBackingTextureId();
 
-  return bound_graphics_3d()->GetBackingTextureId();
+  return 0;
 }
 
 void PluginInstance::CommitBackingTexture() {
   if (fullscreen_container_)
     fullscreen_container_->Invalidate();
   else
     container_->commitBackingTexture();
 }
 
 void PluginInstance::InstanceCrashed() {
@@ skipping 201 matching lines @@
 
   bool old_plugin_focus = PluginHasFocus();
   has_content_area_focus_ = has_focus;
   if (PluginHasFocus() != old_plugin_focus) {
     instance_interface_->DidChangeFocus(pp_instance(),
                                         BoolToPPBool(PluginHasFocus()));
   }
 }
 
 void PluginInstance::ViewInitiatedPaint() {
-  if (bound_graphics_2d())
-    bound_graphics_2d()->ViewInitiatedPaint();
-  if (bound_graphics_3d())
-    bound_graphics_3d()->ViewInitiatedPaint();
+  if (GetBoundGraphics2D())
+    GetBoundGraphics2D()->ViewInitiatedPaint();
+  else if (GetBoundGraphics3D())
+    GetBoundGraphics3D()->ViewInitiatedPaint();
+  else if (GetBoundSurface3D())
+    GetBoundSurface3D()->ViewInitiatedPaint();
 }
 
 void PluginInstance::ViewFlushedPaint() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
-  if (bound_graphics_2d())
-    bound_graphics_2d()->ViewFlushedPaint();
-  if (bound_graphics_3d())
-    bound_graphics_3d()->ViewFlushedPaint();
+  if (GetBoundGraphics2D())
+    GetBoundGraphics2D()->ViewFlushedPaint();
+  else if (GetBoundGraphics3D())
+    GetBoundGraphics3D()->ViewFlushedPaint();
+  else if (GetBoundSurface3D())
+    GetBoundSurface3D()->ViewFlushedPaint();
 }
 
 bool PluginInstance::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip) {
   if (!always_on_top_)
     return false;
-  if (!bound_graphics_2d() || !bound_graphics_2d()->is_always_opaque())
+  if (!GetBoundGraphics2D() || !GetBoundGraphics2D()->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.
-  PPB_ImageData_Impl* image_data = bound_graphics_2d()->image_data();
+  PPB_ImageData_Impl* image_data = GetBoundGraphics2D()->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();
@@ skipping 665 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) && !defined(USE_SKIA)
 
-PPB_Graphics2D_Impl* PluginInstance::bound_graphics_2d() const {
+PPB_Graphics2D_Impl* PluginInstance::GetBoundGraphics2D() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
   if (bound_graphics_->AsPPB_Graphics2D_API())
     return static_cast<PPB_Graphics2D_Impl*>(bound_graphics_.get());
   return NULL;
 }
 
-PPB_Surface3D_Impl* PluginInstance::bound_graphics_3d() const {
+PPB_Graphics3D_Impl* PluginInstance::GetBoundGraphics3D() const {
+  if (bound_graphics_.get() == NULL)
+    return NULL;
+
+  if (bound_graphics_->AsPPB_Graphics3D_API())
+    return static_cast<PPB_Graphics3D_Impl*>(bound_graphics_.get());
+  return NULL;
+}
+
+PPB_Surface3D_Impl* PluginInstance::GetBoundSurface3D() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
   if (bound_graphics_->AsPPB_Surface3D_API())
     return static_cast<PPB_Surface3D_Impl*>(bound_graphics_.get());
   return NULL;
 }
 
 void PluginInstance::setBackingTextureId(unsigned int id) {
   // If we have a full-screen container_ then the plugin is fullscreen,
@@ skipping 55 matching lines @@
   return frame->view()->mainFrame()->document().isPluginDocument();
 }
 
 PPB_Instance_FunctionAPI* PluginInstance::AsPPB_Instance_FunctionAPI() {
   return this;
 }
 
 PP_Bool PluginInstance::BindGraphics(PP_Instance instance,
                                      PP_Resource device) {
   if (bound_graphics_.get()) {
-    if (bound_graphics_2d()) {
-      bound_graphics_2d()->BindToInstance(NULL);
-    } else if (bound_graphics_.get()) {
-      bound_graphics_3d()->BindToInstance(false);
+    if (GetBoundGraphics2D()) {
+      GetBoundGraphics2D()->BindToInstance(NULL);
+    } else if (GetBoundGraphics3D()) {
+      GetBoundGraphics3D()->BindToInstance(false);
+    } else if (GetBoundSurface3D()) {
+      GetBoundSurface3D()->BindToInstance(false);
     }
-    // Special-case clearing the current device.
-    if (!device) {
-      setBackingTextureId(0);
-      InvalidateRect(gfx::Rect());
-    }
+    bound_graphics_ = NULL;
   }
-  bound_graphics_ = NULL;
 
-  if (!device)
+  // Special-case clearing the current device.
+  if (!device) {
+    setBackingTextureId(0);
+    InvalidateRect(gfx::Rect());
     return PP_TRUE;
+  }
+
+  // Refuse to bind if we're transitioning to fullscreen.
+  if (fullscreen_container_ && !fullscreen_)
+    return PP_FALSE;
 
   EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
   PPB_Graphics2D_Impl* graphics_2d = enter_2d.succeeded() ?
       static_cast<PPB_Graphics2D_Impl*>(enter_2d.object()) : NULL;
-  EnterResourceNoLock<PPB_Surface3D_API> enter_3d(device, false);
-  PPB_Surface3D_Impl* graphics_3d = enter_3d.succeeded() ?
-      static_cast<PPB_Surface3D_Impl*>(enter_3d.object()) : NULL;
+  EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
+  PPB_Graphics3D_Impl* graphics_3d = enter_3d.succeeded() ?
+      static_cast<PPB_Graphics3D_Impl*>(enter_3d.object()) : NULL;
+  EnterResourceNoLock<PPB_Surface3D_API> enter_surface_3d(device, false);
+  PPB_Surface3D_Impl* surface_3d = enter_surface_3d.succeeded() ?
+      static_cast<PPB_Surface3D_Impl*>(enter_surface_3d.object()) : NULL;
 
   if (graphics_2d) {
-    // Refuse to bind if we're transitioning to fullscreen.
-    if (fullscreen_container_ && !fullscreen_)
-      return PP_FALSE;
     if (graphics_2d->instance() != this)
       return PP_FALSE;  // Can't bind other instance's contexts.
     if (!graphics_2d->BindToInstance(this))
       return PP_FALSE;  // Can't bind to more than one instance.
 
     bound_graphics_ = graphics_2d;
     setBackingTextureId(0);
     // BindToInstance will have invalidated the plugin if necessary.
   } else if (graphics_3d) {
-    // Refuse to bind if we're transitioning to fullscreen.
-    if (fullscreen_container_ && !fullscreen_)
-      return PP_FALSE;
     // Make sure graphics can only be bound to the instance it is
     // associated with.
     if (graphics_3d->instance() != this)
       return PP_FALSE;
     if (!graphics_3d->BindToInstance(true))
       return PP_FALSE;
 
+    bound_graphics_ = graphics_3d;
     setBackingTextureId(graphics_3d->GetBackingTextureId());
-    bound_graphics_ = graphics_3d;
+  } else if (surface_3d) {
+    // Make sure graphics can only be bound to the instance it is
+    // associated with.
+    if (surface_3d->instance() != this)
+      return PP_FALSE;
+    if (!surface_3d->BindToInstance(true))
+      return PP_FALSE;
+
+    bound_graphics_ = surface_3d;
+    setBackingTextureId(surface_3d->GetBackingTextureId());
   } else {
     // The device is not a valid resource type.
     return PP_FALSE;
   }
 
   return PP_TRUE;
 }
 
 PP_Bool PluginInstance::IsFullFrame(PP_Instance instance) {
   return PP_FromBool(full_frame());
@@ skipping 135 matching lines @@
   }
   delegate()->ZoomLimitsChanged(minimum_factor, maximium_factor);
 }
 
 void PluginInstance::PostMessage(PP_Instance instance, PP_Var message) {
   message_channel_->PostMessageToJavaScript(message);
 }
 
 }  // namespace ppapi
 }  // namespace webkit