Remove webkit::ppapi::Resource.

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/resource_tracker.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 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) {
-  ppp_videodecoder_ =
-      static_cast<const PPP_VideoDecoder_Dev*>(instance->module()->
-          GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
+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(PluginInstance* instance,
+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;
 
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
@@ skipping 13 matching lines @@
   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;
-  platform_video_decoder_ = instance()->delegate()->CreateVideoDecoder(
+
+
+  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();
   return platform_video_decoder_->Initialize(copied);
 }
 
 int32_t PPB_VideoDecoder_Impl::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
@@ skipping 80 matching lines @@
   platform_video_decoder_ = NULL;
   ppp_videodecoder_ = NULL;
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
     uint32 requested_num_of_buffers, const gfx::Size& dimensions) {
   if (!ppp_videodecoder_)
     return;
 
   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);
+  ppp_videodecoder_->ProvidePictureBuffers(pp_instance(), pp_resource(),
+                                           requested_num_of_buffers, out_dim);
 }
 
 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
   if (!ppp_videodecoder_)
     return;
 
   PP_Picture_Dev output;
   output.picture_buffer_id = picture.picture_buffer_id();
   output.bitstream_buffer_id = picture.bitstream_buffer_id();
-  ScopedResourceId resource(this);
-  ppp_videodecoder_->PictureReady(
-      instance()->pp_instance(), resource.id, output);
+  ppp_videodecoder_->PictureReady(pp_instance(), pp_resource(), 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);
+  ppp_videodecoder_->DismissPictureBuffer(pp_instance(), pp_resource(),
+                                          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(pp_instance(), pp_resource());
 }
 
 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,
+  ppp_videodecoder_->NotifyError(pp_instance(), pp_resource(),
                                  static_cast<PP_VideoDecodeError_Dev>(error));
 }
 
 void PPB_VideoDecoder_Impl::NotifyResetDone() {
   RunResetCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   RunBitstreamBufferCallback(bitstream_buffer_id, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   RunFlushCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
   NOTREACHED() << "PlatformVideoDecoder::Initialize() is synchronous!";
 }
 
 }  // namespace ppapi
 }  // namespace webkit