Enable fire-and-forget Destroy of HW video decoder, and misc other improvements.

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"
@@ skipping 18 matching lines @@
 using ppapi::thunk::PPB_Context3D_API;
 using ppapi::thunk::PPB_VideoDecoder_API;
 
 namespace webkit {
 namespace ppapi {
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PluginInstance* instance)
     : Resource(instance),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       context3d_id_(0),
-      destroy_callback_(PP_BlockUntilComplete()),
       flush_callback_(PP_BlockUntilComplete()),
       reset_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_);
@@ skipping 19 matching lines @@
   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, context3d->gles2_impl()->helper()));
+  platform_video_decoder_ = instance()->delegate()->CreateVideoDecoder(
+      this, command_buffer_route_id, context3d->gles2_impl()->helper());
 
-  if (!platform_video_decoder_.get())
+  if (!platform_video_decoder_)
     return PP_ERROR_FAILED;
 
   std::vector<uint32> copied;
   // TODO(fischman,vrk): this is completely broken in that it fails to account
   // for the semantic distinction between keys and values; it is certainly
   // possible for a value to show up as 0, and that shouldn't terminate the
   // config vector.  Only a *key* of 0 should do so.
   // TODO(vrk): This is assuming PP_VideoAttributeDictionary and
   // VideoAttributeKey have identical enum values. There is no compiler
   // assert to guarantee this. We either need to add such asserts or
   // merge PP_VideoAttributeDictionary and VideoAttributeKey.
   for (const PP_VideoConfigElement* current = decoder_config;
        *current != PP_VIDEOATTR_DICTIONARY_TERMINATOR; ++current) {
     copied.push_back(static_cast<uint32>(*current));
   }
 
   if (platform_video_decoder_->Initialize(copied)) {
     initialization_callback_ = callback;
     return PP_OK_COMPLETIONPENDING;
   } else {
     return PP_ERROR_FAILED;
   }
 }
 
 int32_t PPB_VideoDecoder_Impl::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
     PP_CompletionCallback callback) {
-  if (!platform_video_decoder_.get())
+  if (!platform_video_decoder_)
     return PP_ERROR_BADRESOURCE;
 
   EnterResourceNoLock<PPB_Buffer_API> enter(bitstream_buffer->data, true);
   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);
 
   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())
+  if (!platform_video_decoder_)
     return;
 
   std::vector<media::GLESBuffer> wrapped_buffers;
   for (uint32 i = 0; i < no_of_buffers; i++) {
     PP_GLESBuffer_Dev in_buf = buffers[i];
     media::GLESBuffer buffer(
         in_buf.info.id,
         gfx::Size(in_buf.info.size.width, in_buf.info.size.height),
         in_buf.texture_id);
     wrapped_buffers.push_back(buffer);
   }
   platform_video_decoder_->AssignGLESBuffers(wrapped_buffers);
 }
 
 void PPB_VideoDecoder_Impl::ReusePictureBuffer(int32_t picture_buffer_id) {
-  if (!platform_video_decoder_.get())
+  if (!platform_video_decoder_)
     return;
   platform_video_decoder_->ReusePictureBuffer(picture_buffer_id);
 }
 
 int32_t PPB_VideoDecoder_Impl::Flush(PP_CompletionCallback callback) {
-  if (!platform_video_decoder_.get())
+  if (!platform_video_decoder_)
     return PP_ERROR_BADRESOURCE;
 
   // Store the callback to be called when Flush() is done.
   // TODO(fischman,vrk): consider implications of already-outstanding callback.
   flush_callback_ = callback;
 
   platform_video_decoder_->Flush();
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_VideoDecoder_Impl::Reset(PP_CompletionCallback callback) {
-  if (!platform_video_decoder_.get())
+  if (!platform_video_decoder_)
     return PP_ERROR_BADRESOURCE;
 
   // Store the callback to be called when Reset() is done.
   // TODO(fischman,vrk): consider implications of already-outstanding callback.
   reset_callback_ = callback;
 
   platform_video_decoder_->Reset();
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t PPB_VideoDecoder_Impl::Destroy(PP_CompletionCallback callback) {
-  if (!platform_video_decoder_.get())
-    return PP_ERROR_BADRESOURCE;
-
-  // Store the callback to be called when Destroy() is done.
-  // TODO(fischman,vrk): consider implications of already-outstanding callback.
-  destroy_callback_ = callback;
-
+void PPB_VideoDecoder_Impl::Destroy() {
+  if (!platform_video_decoder_)
+    return;
   platform_video_decoder_->Destroy();
-  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
   // a blind cast.
   PP_PictureBufferType_Dev out_type =
       static_cast<PP_PictureBufferType_Dev>(type);
   PP_Size out_dim = PP_MakeSize(dimensions.width(), dimensions.height());
-  ScopedResourceId resource(this);
   ppp_videodecoder_->ProvidePictureBuffers(
-      instance()->pp_instance(), resource.id, requested_num_of_buffers,
-      out_dim, out_type);
+      instance()->pp_instance(), requested_num_of_buffers, out_dim, out_type);
 }
 
 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
   if (!ppp_videodecoder_)
     return;
 
-  ScopedResourceId resource(this);
   PP_Picture_Dev output;
   output.picture_buffer_id = picture.picture_buffer_id();
   output.bitstream_buffer_id = picture.bitstream_buffer_id();
   output.visible_size = PP_MakeSize(picture.visible_size().width(),
                                     picture.visible_size().height());
   output.decoded_size = PP_MakeSize(picture.decoded_size().width(),
                                     picture.decoded_size().height());
-  ppp_videodecoder_->PictureReady(
-      instance()->pp_instance(), resource.id, output);
+  ppp_videodecoder_->PictureReady(instance()->pp_instance(), output);
 }
 
 void PPB_VideoDecoder_Impl::DismissPictureBuffer(int32 picture_buffer_id) {
   if (!ppp_videodecoder_)
     return;
 
-  ScopedResourceId resource(this);
   ppp_videodecoder_->DismissPictureBuffer(
-      instance()->pp_instance(), resource.id, picture_buffer_id);
+      instance()->pp_instance(), picture_buffer_id);
 }
 
 void PPB_VideoDecoder_Impl::NotifyEndOfStream() {
   if (!ppp_videodecoder_)
     return;
 
-  ScopedResourceId resource(this);
-  ppp_videodecoder_->EndOfStream(instance()->pp_instance(), resource.id);
+  ppp_videodecoder_->EndOfStream(instance()->pp_instance());
 }
 
 void PPB_VideoDecoder_Impl::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   if (!ppp_videodecoder_)
     return;
 
-  ScopedResourceId resource(this);
   // TODO(vrk): This is assuming VideoDecodeAccelerator::Error and
   // PP_VideoDecodeError_Dev have identical enum values. There is no compiler
   // assert to guarantee this. We either need to add such asserts or
   // merge these two enums.
-  ppp_videodecoder_->NotifyError(instance()->pp_instance(), resource.id,
-      static_cast<PP_VideoDecodeError_Dev>(error));
+  ppp_videodecoder_->NotifyError(instance()->pp_instance(),
+                                 static_cast<PP_VideoDecodeError_Dev>(error));
 }
 
 void PPB_VideoDecoder_Impl::NotifyResetDone() {
   if (reset_callback_.func == NULL)
     return;
 
   // Call the callback that was stored to be called when Reset is done.
   PP_RunAndClearCompletionCallback(&reset_callback_, PP_OK);
 }
 
-void PPB_VideoDecoder_Impl::NotifyDestroyDone() {
-  if (destroy_callback_.func == NULL)
-    return;
-
-  // Call the callback that was stored to be called when Destroy is done.
-  PP_RunAndClearCompletionCallback(&destroy_callback_, PP_OK);
-}
-
 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   CallbackById::iterator it =
       bitstream_buffer_callbacks_.find(bitstream_buffer_id);
   DCHECK(it != bitstream_buffer_callbacks_.end());
   PP_CompletionCallback cc = it->second;
   bitstream_buffer_callbacks_.erase(it);
   PP_RunCompletionCallback(&cc, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   if (flush_callback_.func == NULL)
     return;
 
   // Call the callback that was stored to be called when Flush is done.
   PP_RunAndClearCompletionCallback(&flush_callback_, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
   if (initialization_callback_.func == NULL)
     return;
 
   PP_RunAndClearCompletionCallback(&initialization_callback_, PP_OK);
 }
 
 }  // namespace ppapi
 }  // namespace webkit