VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

webkit/plugins/ppapi/ppb_video_decoder_impl.cc

 // Copyright (c) 2012 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 98 matching lines @@
   InitCommon(graphics_context, gles2_impl);
 
   int command_buffer_route_id = 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_)
+  platform_video_decoder_.reset(plugin_delegate->CreateVideoDecoder(
+      this, command_buffer_route_id));
+  if (!platform_video_decoder_.get())
     return false;
 
   FlushCommandBuffer();
   return platform_video_decoder_->Initialize(PPToMediaProfile(profile));
 }
 
 int32_t PPB_VideoDecoder_Impl::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
     scoped_refptr<TrackedCallback> callback) {
-  if (!platform_video_decoder_)
+  if (!platform_video_decoder_.get())
     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>(bitstream_buffer->size));
   if (!SetBitstreamBufferCallback(bitstream_buffer->id, callback))
     return PP_ERROR_BADARGUMENT;
 
   FlushCommandBuffer();
   platform_video_decoder_->Decode(decode_buffer);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_VideoDecoder_Impl::AssignPictureBuffers(
     uint32_t no_of_buffers,
     const PP_PictureBuffer_Dev* buffers) {
-  if (!platform_video_decoder_)
+  if (!platform_video_decoder_.get())
     return;
 
   std::vector<media::PictureBuffer> wrapped_buffers;
   for (uint32 i = 0; i < no_of_buffers; i++) {
     PP_PictureBuffer_Dev in_buf = buffers[i];
     media::PictureBuffer buffer(
         in_buf.id,
         gfx::Size(in_buf.size.width, in_buf.size.height),
         in_buf.texture_id);
     wrapped_buffers.push_back(buffer);
   }
 
   FlushCommandBuffer();
   platform_video_decoder_->AssignPictureBuffers(wrapped_buffers);
 }
 
 void PPB_VideoDecoder_Impl::ReusePictureBuffer(int32_t picture_buffer_id) {
-  if (!platform_video_decoder_)
+  if (!platform_video_decoder_.get())
     return;
 
   FlushCommandBuffer();
   platform_video_decoder_->ReusePictureBuffer(picture_buffer_id);
 }
 
 int32_t PPB_VideoDecoder_Impl::Flush(scoped_refptr<TrackedCallback> callback) {
-  if (!platform_video_decoder_)
+  if (!platform_video_decoder_.get())
     return PP_ERROR_BADRESOURCE;
 
   if (!SetFlushCallback(callback))
     return PP_ERROR_INPROGRESS;
 
   FlushCommandBuffer();
   platform_video_decoder_->Flush();
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_VideoDecoder_Impl::Reset(scoped_refptr<TrackedCallback> callback) {
-  if (!platform_video_decoder_)
+  if (!platform_video_decoder_.get())
     return PP_ERROR_BADRESOURCE;
 
   if (!SetResetCallback(callback))
     return PP_ERROR_INPROGRESS;
 
   FlushCommandBuffer();
   platform_video_decoder_->Reset();
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_VideoDecoder_Impl::Destroy() {
-  if (!platform_video_decoder_)
+  if (!platform_video_decoder_.get())
     return;
 
   FlushCommandBuffer();
-  platform_video_decoder_->Destroy();
+  platform_video_decoder_.release()->Destroy();
   ::ppapi::PPB_VideoDecoder_Shared::Destroy();
-  platform_video_decoder_ = NULL;
   ppp_videodecoder_ = NULL;
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
   if (!ppp_videodecoder_)
     return;
 
@@ skipping 44 matching lines @@
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   RunFlushCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
   NOTREACHED() << "PlatformVideoDecoder::Initialize() is synchronous!";
 }
 
 }  // namespace ppapi
 }  // namespace webkit