PPAPI: Make GetProxiedInterface not re-enter the plugin

content/renderer/pepper/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 "content/renderer/pepper/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 77 matching lines @@
       return PP_VIDEODECODERERROR_ILLEGAL_STATE;
   }
 }
 
 }  // namespace
 
 namespace content {
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PP_Instance instance)
     : PPB_VideoDecoder_Shared(instance), ppp_videodecoder_(NULL) {
-  PluginModule* plugin_module =
-      HostGlobals::Get()->GetInstance(pp_instance())->module();
-  if (plugin_module) {
-    ppp_videodecoder_ = static_cast<const PPP_VideoDecoder_Dev*>(
-        plugin_module->GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
-  }
 }
 
 PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() { Destroy(); }
 
 // static
 PP_Resource PPB_VideoDecoder_Impl::Create(PP_Instance instance,
                                           PP_Resource graphics_context,
                                           PP_VideoDecoder_Profile profile) {
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       new PPB_VideoDecoder_Impl(instance));
@@ skipping 19 matching lines @@
   FlushCommandBuffer();
 
   // This is not synchronous, but subsequent IPC messages will be buffered, so
   // it is okay to immediately send IPC messages through the returned channel.
   GpuChannelHost* channel = graphics_3d->channel();
   DCHECK(channel);
   decoder_ = channel->CreateVideoDecoder(command_buffer_route_id);
   return (decoder_ && decoder_->Initialize(PPToMediaProfile(profile), this));
 }
 
+const PPP_VideoDecoder_Dev* PPB_VideoDecoder_Impl::GetPPP() {
+  if (!ppp_videodecoder_) {
+    PluginModule* plugin_module =
+        HostGlobals::Get()->GetInstance(pp_instance())->module();
+    if (plugin_module) {
+      ppp_videodecoder_ = static_cast<const PPP_VideoDecoder_Dev*>(
+          plugin_module->GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
+    }
+  }
+  return ppp_videodecoder_;
+}
+
 int32_t PPB_VideoDecoder_Impl::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
     scoped_refptr<TrackedCallback> callback) {
   if (!decoder_)
     return PP_ERROR_BADRESOURCE;
 
   EnterResourceNoLock<PPB_Buffer_API> enter(bitstream_buffer->data, true);
   if (enter.failed())
     return PP_ERROR_FAILED;
 
@@ skipping 74 matching lines @@
   ppp_videodecoder_ = NULL;
 
   ::ppapi::PPB_VideoDecoder_Shared::Destroy();
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
   DCHECK(RenderThreadImpl::current());
-  if (!ppp_videodecoder_)
+  if (!GetPPP())
     return;
 
   PP_Size out_dim = PP_MakeSize(dimensions.width(), dimensions.height());
-  ppp_videodecoder_->ProvidePictureBuffers(pp_instance(),
-                                           pp_resource(),
-                                           requested_num_of_buffers,
-                                           &out_dim,
-                                           texture_target);
+  GetPPP()->ProvidePictureBuffers(pp_instance(), pp_resource(),
+                                  requested_num_of_buffers, &out_dim,
+                                  texture_target);
 }
 
 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
   // So far picture.visible_rect is not used. If used, visible_rect should
   // be validated since it comes from GPU process and may not be trustworthy.
   DCHECK(RenderThreadImpl::current());
-  if (!ppp_videodecoder_)
+  if (!GetPPP())
     return;
 
   PP_Picture_Dev output;
   output.picture_buffer_id = picture.picture_buffer_id();
   output.bitstream_buffer_id = picture.bitstream_buffer_id();
-  ppp_videodecoder_->PictureReady(pp_instance(), pp_resource(), &output);
+  GetPPP()->PictureReady(pp_instance(), pp_resource(), &output);
 }
 
 void PPB_VideoDecoder_Impl::DismissPictureBuffer(int32 picture_buffer_id) {
   DCHECK(RenderThreadImpl::current());
-  if (!ppp_videodecoder_)
+  if (!GetPPP())
     return;
-  ppp_videodecoder_->DismissPictureBuffer(
-      pp_instance(), pp_resource(), picture_buffer_id);
+  GetPPP()->DismissPictureBuffer(pp_instance(), pp_resource(),
+                                 picture_buffer_id);
 }
 
 void PPB_VideoDecoder_Impl::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   DCHECK(RenderThreadImpl::current());
-  if (!ppp_videodecoder_)
+  if (!GetPPP())
     return;
 
   PP_VideoDecodeError_Dev pp_error = MediaToPPError(error);
-  ppp_videodecoder_->NotifyError(pp_instance(), pp_resource(), pp_error);
+  GetPPP()->NotifyError(pp_instance(), pp_resource(), pp_error);
   UMA_HISTOGRAM_ENUMERATION("Media.PepperVideoDecoderError",
                             error,
                             media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
 }
 
 void PPB_VideoDecoder_Impl::NotifyResetDone() {
   DCHECK(RenderThreadImpl::current());
   RunResetCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   DCHECK(RenderThreadImpl::current());
   RunBitstreamBufferCallback(bitstream_buffer_id, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   DCHECK(RenderThreadImpl::current());
   RunFlushCallback(PP_OK);
 }
 
 }  // namespace content