Add a unified resource tracker shared between the proxy and the impl.

ppapi/proxy/ppb_context_3d_proxy.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 "ppapi/proxy/ppb_context_3d_proxy.h"
 
 #include "base/hash_tables.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/dev/ppb_context_3d_dev.h"
 #include "ppapi/c/dev/ppb_context_3d_trusted_dev.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
-#include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_surface_3d_proxy.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::HostResource;
+using ppapi::Resource;
 using ppapi::thunk::EnterFunctionNoLock;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Context3D_API;
 using ppapi::thunk::PPB_Surface3D_API;
 using ppapi::thunk::ResourceCreationAPI;
 
 namespace pp {
 namespace proxy {
 
 namespace {
@@ skipping 299 matching lines @@
 void PepperCommandBuffer::UpdateState(const gpu::CommandBuffer::State& state) {
   // Handle wraparound. It works as long as we don't have more than 2B state
   // updates in flight across which reordering occurs.
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
 // Context3D -------------------------------------------------------------------
 
 Context3D::Context3D(const HostResource& resource)
-    : PluginResource(resource),
+    : Resource(resource),
       draw_(NULL),
       read_(NULL),
       transfer_buffer_id_(0) {
 }
 
 Context3D::~Context3D() {
   if (draw_)
     draw_->set_context(NULL);
 }
 
 PPB_Context3D_API* Context3D::AsPPB_Context3D_API() {
   return this;
 }
 
 bool Context3D::CreateImplementation() {
-  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance());
+  PluginDispatcher* dispatcher =
+      PluginDispatcher::GetForInstance(pp_instance());
   if (!dispatcher)
     return false;
 
   command_buffer_.reset(new PepperCommandBuffer(host_resource(), dispatcher));
 
   if (!command_buffer_->Initialize(kCommandBufferSize))
     return false;
 
   helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!helper_->Initialize(kCommandBufferSize))
@@ skipping 40 matching lines @@
   if (pp_draw && !draw_surface)
     return PP_ERROR_BADRESOURCE;
   if (pp_read && !read_surface)
     return PP_ERROR_BADRESOURCE;
   HostResource host_draw =
       draw_surface ? draw_surface->host_resource() : HostResource();
   HostResource host_read =
       read_surface ? read_surface->host_resource() : HostResource();
 
   int32_t result;
-  GetDispatcher()->Send(new PpapiHostMsg_PPBContext3D_BindSurfaces(
-      INTERFACE_ID_PPB_CONTEXT_3D,
-      host_resource(), host_draw, host_read, &result));
+  PluginDispatcher::GetForResource(this)->Send(
+      new PpapiHostMsg_PPBContext3D_BindSurfaces(
+          INTERFACE_ID_PPB_CONTEXT_3D,
+          host_resource(), host_draw, host_read, &result));
   if (result != PP_OK)
     return result;
 
   if (draw_surface != draw_) {
     if (draw_)
       draw_->set_context(NULL);
     if (draw_surface) {
       draw_surface->set_context(this);
       // Resize the backing texture to the size of the instance when it is
       // bound.
       // TODO(alokp): This should be the responsibility of plugins.
-      InstanceData* data = GetDispatcher()->GetInstanceData(instance());
+      InstanceData* data =
+          PluginDispatcher::GetForResource(this)->GetInstanceData(
+              pp_instance());
       gles2_impl()->ResizeCHROMIUM(data->position.size.width,
                                    data->position.size.height);
     }
     draw_ = draw_surface;
   }
   read_ = read_surface;
   return PP_OK;
 }
 
 int32_t Context3D::GetBoundSurfaces(PP_Resource* draw, PP_Resource* read) {
-  *draw = draw_ ? draw_->resource() : 0;
-  *read = read_ ? read_->resource() : 0;
+  *draw = draw_ ? draw_->pp_resource() : 0;
+  *read = read_ ? read_->pp_resource() : 0;
   return PP_OK;
 }
 
 PP_Bool Context3D::InitializeTrusted(int32_t size) {
   // Trusted interface not implemented in the proxy.
   return PP_FALSE;
 }
 
 PP_Bool Context3D::GetRingBuffer(int* shm_handle,
                                  uint32_t* shm_size) {
@@ skipping 118 matching lines @@
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBContext3D_Create(
       INTERFACE_ID_PPB_CONTEXT_3D, instance, config, attribs, &result));
 
   if (result.is_null())
     return 0;
   scoped_refptr<Context3D> context_3d(new Context3D(result));
   if (!context_3d->CreateImplementation())
     return 0;
-  return PluginResourceTracker::GetInstance()->AddResource(context_3d);
+  return context_3d->GetReference();
 }
 
 bool PPB_Context3D_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Context3D_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBContext3D_Create,
                         OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBContext3D_BindSurfaces,
                         OnMsgBindSurfaces)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBContext3D_Initialize,
@@ skipping 124 matching lines @@
   uint32_t shm_size = 0;
   if (enter.succeeded() &&
       enter.object()->GetTransferBuffer(id, &shm_handle, &shm_size)) {
     *transfer_buffer = TransportSHMHandleFromInt(dispatcher(), shm_handle);
     *size = shm_size;
   }
 }
 
 }  // namespace proxy
 }  // namespace pp