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 212 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 (bound_graphics_3d())
+    return bound_graphics_3d()->GetBackingTextureId();
+  else if (bound_surface_3d())
+    return bound_surface_3d()->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 @@
   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())
+  else if (bound_graphics_3d())
     bound_graphics_3d()->ViewInitiatedPaint();
+  else if (bound_surface_3d())
+    bound_surface_3d()->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())
+  else if (bound_graphics_3d())
     bound_graphics_3d()->ViewFlushedPaint();
+  else if (bound_surface_3d())
+    bound_surface_3d()->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())
@@ skipping 690 matching lines @@
 
 PPB_Graphics2D_Impl* PluginInstance::bound_graphics_2d() 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::bound_graphics_3d() 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::bound_surface_3d() 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 59 matching lines @@
   return this;
 }
 
 PP_Bool PluginInstance::BindGraphics(PP_Instance instance,
                                      PP_Resource device) {
   if (!device) {
     // Special-case clearing the current device.
     if (bound_graphics_.get()) {
       if (bound_graphics_2d()) {
         bound_graphics_2d()->BindToInstance(NULL);
-      } else if (bound_graphics_.get()) {
+      } else if (bound_graphics_3d()) {
+        bound_graphics_3d()->BindToInstance(false);
+      } else if (bound_surface_3d()) {
         bound_graphics_3d()->BindToInstance(false);
       }
       setBackingTextureId(0);
       InvalidateRect(gfx::Rect());
     }
     bound_graphics_ = NULL;
     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