Remove webkit::ppapi::Resource.

webkit/plugins/ppapi/ppb_graphics_3d_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_graphics_3d_impl.h"
 
 #include "base/message_loop.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/resource_helper.h"
 
 using ppapi::thunk::PPB_Graphics3D_API;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 const int32 kCommandBufferSize = 1024 * 1024;
 const int32 kTransferBufferSize = 1024 * 1024;
 
@@ skipping 21 matching lines @@
       s.get_offset,
       s.put_offset,
       s.token,
       static_cast<PPB_Graphics3DTrustedError>(s.error),
       s.generation
   };
   return state;
 }
 }  // namespace.
 
-PPB_Graphics3D_Impl::PPB_Graphics3D_Impl(PluginInstance* instance)
+PPB_Graphics3D_Impl::PPB_Graphics3D_Impl(PP_Instance instance)
     : Resource(instance),
       bound_to_instance_(false),
       commit_pending_(false),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Graphics3D_Impl::~PPB_Graphics3D_Impl() {
   DestroyGLES2Impl();
 }
 
 // static
-PP_Resource PPB_Graphics3D_Impl::Create(PluginInstance* instance,
+PP_Resource PPB_Graphics3D_Impl::Create(PP_Instance instance,
                                         PP_Resource share_context,
                                         const int32_t* attrib_list) {
   scoped_refptr<PPB_Graphics3D_Impl> graphics_3d(
       new PPB_Graphics3D_Impl(instance));
   if (!graphics_3d->Init(share_context, attrib_list))
     return 0;
   return graphics_3d->GetReference();
 }
 
-PP_Resource PPB_Graphics3D_Impl::CreateRaw(PluginInstance* instance,
+PP_Resource PPB_Graphics3D_Impl::CreateRaw(PP_Instance instance,
                                            PP_Resource share_context,
                                            const int32_t* attrib_list) {
   scoped_refptr<PPB_Graphics3D_Impl> graphics_3d(
       new PPB_Graphics3D_Impl(instance));
   if (!graphics_3d->InitRaw(share_context, attrib_list))
     return 0;
   return graphics_3d->GetReference();
 }
 
 PPB_Graphics3D_API* PPB_Graphics3D_Impl::AsPPB_Graphics3D_API() {
@@ skipping 88 matching lines @@
 
   gpu::CommandBuffer* command_buffer = GetCommandBuffer();
   if (!command_buffer->Initialize(kCommandBufferSize))
     return false;
 
   return CreateGLES2Impl(kCommandBufferSize, kTransferBufferSize);
 }
 
 bool PPB_Graphics3D_Impl::InitRaw(PP_Resource share_context,
                                   const int32_t* attrib_list) {
+  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  if (!plugin_instance)
+    return false;
+
   // TODO(alokp): Support shared context.
   DCHECK_EQ(0, share_context);
   if (share_context != 0)
-    return 0;
+    return false;
 
-  platform_context_.reset(instance()->CreateContext3D());
+  platform_context_.reset(plugin_instance->CreateContext3D());
   if (!platform_context_.get())
     return false;
 
   if (!platform_context_->Init(attrib_list))
     return false;
 
   platform_context_->SetContextLostCallback(
       callback_factory_.NewCallback(&PPB_Graphics3D_Impl::OnContextLost));
   platform_context_->SetSwapBuffersCallback(
       callback_factory_.NewCallback(&PPB_Graphics3D_Impl::OnSwapBuffers));
   return true;
 }
 
 void PPB_Graphics3D_Impl::OnSwapBuffers() {
   if (bound_to_instance_) {
     // If we are bound to the instance, we need to ask the compositor
     // to commit our backing texture so that the graphics appears on the page.
     // When the backing texture will be committed we get notified via
     // ViewFlushedPaint().
-    instance()->CommitBackingTexture();
+    //
+    // Don't need to check for NULL from GetPluginInstance since when we're
+    // bound, we know our instance is valid.
+    ResourceHelper::GetPluginInstance(this)->CommitBackingTexture();
     commit_pending_ = true;
   } else if (HasPendingSwap()) {
     // If we're off-screen, no need to trigger and wait for compositing.
     // Just send the swap-buffers ACK to the plugin immediately.
     commit_pending_ = false;
     SwapBuffersACK(PP_OK);
   }
 }
 
 void PPB_Graphics3D_Impl::OnContextLost() {
+  // Don't need to check for NULL from GetPluginInstance since when we're
+  // bound, we know our instance is valid.
   if (bound_to_instance_)
-    instance()->BindGraphics(instance()->pp_instance(), 0);
+    ResourceHelper::GetPluginInstance(this)->BindGraphics(pp_instance(), 0);
 
   // Send context lost to plugin. This may have been caused by a PPAPI call, so
   // avoid re-entering.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &PPB_Graphics3D_Impl::SendContextLost));
 }
 
 void PPB_Graphics3D_Impl::SendContextLost() {
   // By the time we run this, the instance may have been deleted, or in the
   // process of being deleted. Even in the latter case, we don't want to send a
   // callback after DidDestroy.
-  if (!instance() || !instance()->container())
+  PluginInstance* instance = ResourceHelper::GetPluginInstance(this);
+  if (!instance || !instance->container())
     return;
 
   const PPP_Graphics3D_Dev* ppp_graphics_3d =
       static_cast<const PPP_Graphics3D_Dev*>(
-          instance()->module()->GetPluginInterface(
+          instance->module()->GetPluginInterface(
               PPP_GRAPHICS_3D_DEV_INTERFACE));
   if (ppp_graphics_3d)
-    ppp_graphics_3d->Graphics3DContextLost(instance()->pp_instance());
+    ppp_graphics_3d->Graphics3DContextLost(pp_instance());
 }
 
 }  // namespace ppapi
 }  // namespace webkit