Allow both Context3D and Graphics3D with the video decoder

webkit/plugins/ppapi/ppb_video_decoder_impl.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/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "media/video/picture.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/dev/ppb_video_decoder_dev.h"
 #include "ppapi/c/dev/ppp_video_decoder_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 #include "ppapi/thunk/enter.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/ppb_context_3d_impl.h"
+#include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Context3D_API;
+using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_VideoDecoder_API;
 
 namespace webkit {
 namespace ppapi {
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PP_Instance instance)
     : Resource(instance),
       ppp_videodecoder_(NULL) {
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (plugin_module) {
     ppp_videodecoder_ = static_cast<const PPP_VideoDecoder_Dev*>(
         plugin_module->GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
   }
 }
 
 PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() {
 }
 
 PPB_VideoDecoder_API* PPB_VideoDecoder_Impl::AsPPB_VideoDecoder_API() {
   return this;
 }
 
 // static
 PP_Resource PPB_VideoDecoder_Impl::Create(PP_Instance instance,
                                           PP_Resource context3d_id,
                                           const PP_VideoConfigElement* config) {
-  if (!context3d_id)
-    return 0;
-
-  EnterResourceNoLock<PPB_Context3D_API> enter_context(context3d_id, true);
-  if (enter_context.failed())
-    return 0;
+  PluginDelegate::PlatformContext3D* platform_context = NULL;
+  gpu::gles2::GLES2Implementation* gles2_impl = NULL;
+  EnterResourceNoLock<PPB_Context3D_API> enter_context(context3d_id, false);
+  if (enter_context.succeeded()) {
+    PPB_Context3D_Impl* context3d_impl =
+        static_cast<PPB_Context3D_Impl*>(enter_context.object());
+    platform_context = context3d_impl->platform_context();
+    gles2_impl = context3d_impl->gles2_impl();
+  } else {
+    EnterResourceNoLock<PPB_Graphics3D_API> enter_context(context3d_id, true);
+    if (enter_context.failed())
+      return 0;
+    PPB_Graphics3D_Impl* graphics3d_impl =
+        static_cast<PPB_Graphics3D_Impl*>(enter_context.object());
+    platform_context = graphics3d_impl->platform_context();
+    gles2_impl = graphics3d_impl->gles2_impl();
+  }
 
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       new PPB_VideoDecoder_Impl(instance));
-  if (decoder->Init(context3d_id, enter_context.object(), config))
+  if (decoder->Init(context3d_id, platform_context, gles2_impl, config))
     return decoder->GetReference();
   return 0;
 }
 
-bool PPB_VideoDecoder_Impl::Init(PP_Resource context3d_id,
-                                 PPB_Context3D_API* context3d,
-                                 const PP_VideoConfigElement* config) {
-  if (!::ppapi::VideoDecoderImpl::Init(context3d_id, context3d, config))
+bool PPB_VideoDecoder_Impl::Init(
+    PP_Resource context3d_id,
+    PluginDelegate::PlatformContext3D* context,
+    gpu::gles2::GLES2Implementation* gles2_impl,
+    const PP_VideoConfigElement* config) {
+  InitCommon(context3d_id, gles2_impl);
+
+  int command_buffer_route_id = context->GetCommandBufferRouteId();
+  if (command_buffer_route_id == 0)
     return false;
 
   std::vector<int32> copied;
   if (!CopyConfigsToVector(config, &copied))
     return false;
 
-  PPB_Context3D_Impl* context3d_impl =
-      static_cast<PPB_Context3D_Impl*>(context3d);
-
-  int command_buffer_route_id =
-      context3d_impl->platform_context()->GetCommandBufferRouteId();
-  if (command_buffer_route_id == 0)
-    return false;
-
-
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return false;
 
   platform_video_decoder_ = plugin_delegate->CreateVideoDecoder(
       this, command_buffer_route_id);
   if (!platform_video_decoder_)
     return false;
 
   FlushCommandBuffer();
@@ skipping 144 matching lines @@
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   RunFlushCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
   NOTREACHED() << "PlatformVideoDecoder::Initialize() is synchronous!";
 }
 
 }  // namespace ppapi
 }  // namespace webkit