Implement proper synchronization between HW video decode IPC and CommandBuffer.

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 "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"
@@ skipping 37 matching lines @@
     output->push_back(static_cast<uint32>(*configs));
     current++;
   }
 }
 
 }  // namespace
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PluginInstance* instance)
     : Resource(instance),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      context3d_id_(0),
       abort_callback_(PP_BlockUntilComplete()),
       flush_callback_(PP_BlockUntilComplete()) {
   ppp_videodecoder_ =
       static_cast<const PPP_VideoDecoder_Dev*>(instance->module()->
           GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
 }
 
 PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() {
+  if (context3d_id_)
+    ResourceTracker::Get()->UnrefResource(context3d_id_);
 }
 
 PPB_VideoDecoder_API* PPB_VideoDecoder_Impl::AsPPB_VideoDecoder_API() {
   return this;
 }
 
 PP_Bool PPB_VideoDecoder_Impl::GetConfigs(
     const PP_VideoConfigElement* requested_configs,
     PP_VideoConfigElement* matching_configs,
     uint32_t matching_configs_size,
@@ skipping 27 matching lines @@
 
   if (!instance())
     return PP_ERROR_FAILED;
 
   EnterResourceNoLock<PPB_Context3D_API> enter(context_id, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
   PPB_Context3D_Impl* context3d =
       static_cast<PPB_Context3D_Impl*>(enter.object());
 
+  context3d_id_ = context_id;
+  ResourceTracker::Get()->AddRefResource(context3d_id_);
   int command_buffer_route_id =
       context3d->platform_context()->GetCommandBufferRouteId();
   if (command_buffer_route_id == 0)
     return PP_ERROR_FAILED;
 
   platform_video_decoder_.reset(
       instance()->delegate()->CreateVideoDecoder(
-          this, command_buffer_route_id));
+          this, command_buffer_route_id, context3d->gles2_impl()->helper()));
 
   if (!platform_video_decoder_.get())
     return PP_ERROR_FAILED;
 
   std::vector<uint32> copied;
   // TODO(vrk): Validate configs before copy.
   CopyToConfigList(decoder_config, &copied);
   if (platform_video_decoder_->Initialize(copied)) {
     initialization_callback_ = callback;
     return PP_OK_COMPLETIONPENDING;
@@ skipping 12 matching lines @@
   if (enter.failed())
     return PP_ERROR_FAILED;
 
   PPB_Buffer_Impl* buffer = static_cast<PPB_Buffer_Impl*>(enter.object());
   media::BitstreamBuffer decode_buffer(bitstream_buffer->id,
                                        buffer->shared_memory()->handle(),
                                        static_cast<size_t>(buffer->size()));
   CHECK(bitstream_buffer_callbacks_.insert(std::make_pair(
       bitstream_buffer->id, callback)).second);
 
-  if (platform_video_decoder_->Decode(decode_buffer))
-    return PP_OK_COMPLETIONPENDING;
-  else
-    return PP_ERROR_FAILED;
+  platform_video_decoder_->Decode(decode_buffer);
+  return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_VideoDecoder_Impl::AssignGLESBuffers(
     uint32_t no_of_buffers,
     const PP_GLESBuffer_Dev* buffers) {
   if (!platform_video_decoder_.get())
     return;
 
   std::vector<media::GLESBuffer> wrapped_buffers;
   for (uint32 i = 0; i < no_of_buffers; i++) {
@@ skipping 39 matching lines @@
 }
 
 int32_t PPB_VideoDecoder_Impl::Flush(PP_CompletionCallback callback) {
   if (!platform_video_decoder_.get())
     return PP_ERROR_BADRESOURCE;
 
   // Store the callback to be called when Flush() is done.
   // TODO(vmr): Check for current flush/abort operations.
   flush_callback_ = callback;
 
-  if (platform_video_decoder_->Flush())
-    return PP_OK_COMPLETIONPENDING;
-  else
-    return PP_ERROR_FAILED;
+  platform_video_decoder_->Flush();
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_VideoDecoder_Impl::Abort(PP_CompletionCallback callback) {
   if (!platform_video_decoder_.get())
     return PP_ERROR_BADRESOURCE;
 
   // Store the callback to be called when Abort() is done.
   // TODO(vmr): Check for current flush/abort operations.
   abort_callback_ = callback;
 
-  if (platform_video_decoder_->Abort())
-    return PP_OK_COMPLETIONPENDING;
-  else
-    return PP_ERROR_FAILED;
+  platform_video_decoder_->Abort();
+  return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     media::VideoDecodeAccelerator::MemoryType type) {
   if (!ppp_videodecoder_)
     return;
 
   // TODO(vrk): Compiler assert or use switch statement instead of making
@@ skipping 77 matching lines @@
 
 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
   if (initialization_callback_.func == NULL)
     return;
 
   PP_RunAndClearCompletionCallback(&initialization_callback_, PP_OK);
 }
 
 }  // namespace ppapi
 }  // namespace webkit