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

ppapi/proxy/ppb_broker_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_broker_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/trusted/ppb_broker_trusted.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/thunk/ppb_broker_api.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::HostResource;
+using ppapi::Resource;
 using ppapi::thunk::PPB_Broker_API;
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 base::PlatformFile IntToPlatformFile(int32_t handle) {
 #if defined(OS_WIN)
   return reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
@@ skipping 14 matching lines @@
 #endif
 }
 
 InterfaceProxy* CreateBrokerProxy(Dispatcher* dispatcher,
                                   const void* target_interface) {
   return new PPB_Broker_Proxy(dispatcher, target_interface);
 }
 
 }  // namespace
 
-class Broker : public PPB_Broker_API, public PluginResource {
+class Broker : public PPB_Broker_API, public Resource {
  public:
   explicit Broker(const HostResource& resource);
   virtual ~Broker();
 
-  // ResourceObjectBase overries.
+  // Resource overries.
   virtual PPB_Broker_API* AsPPB_Broker_API() OVERRIDE;
 
   // PPB_Broker_API implementation.
   virtual int32_t Connect(PP_CompletionCallback connect_callback) OVERRIDE;
   virtual int32_t GetHandle(int32_t* handle) OVERRIDE;
 
   // Called by the proxy when the host side has completed the request.
   void ConnectComplete(IPC::PlatformFileForTransit socket_handle,
                        int32_t result);
 
  private:
   bool called_connect_;
   PP_CompletionCallback current_connect_callback_;
 
   // The plugin module owns the handle.
   // The host side transfers ownership of the handle to the plugin side when it
   // sends the IPC. This member holds the handle value for the plugin module
   // to read, but the plugin side of the proxy never takes ownership.
   base::SyncSocket::Handle socket_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(Broker);
 };
 
-Broker::Broker(const HostResource& resource)
-    : PluginResource(resource),
+Broker::Broker(const HostResource& resource) : Resource(resource),
       called_connect_(false),
       current_connect_callback_(PP_MakeCompletionCallback(NULL, NULL)),
       socket_handle_(base::kInvalidPlatformFileValue) {
 }
 
 Broker::~Broker() {
   // Ensure the callback is always fired.
   if (current_connect_callback_.func) {
     // TODO(brettw) the callbacks at this level should be refactored with a
     // more automatic tracking system like we have in the renderer.
@@ skipping 16 matching lines @@
   }
 
   if (current_connect_callback_.func)
     return PP_ERROR_INPROGRESS;
   else if (called_connect_)
     return PP_ERROR_FAILED;
 
   current_connect_callback_ = connect_callback;
   called_connect_ = true;
 
-  bool success = GetDispatcher()->Send(new PpapiHostMsg_PPBBroker_Connect(
-      INTERFACE_ID_PPB_BROKER, host_resource()));
+  bool success = PluginDispatcher::GetForResource(this)->Send(

[dmichael (off chromium), 2011/08/17 16:28:07]

optional nit: Most places I've seen so far, you're using GetForInstance instead,
even when you have the resource. Is there any reason for the inconsistency? Not
a big deal, but it would seem preferable to always use one or the other in
similar contexts, and maybe remove one of them if possible.

+      new PpapiHostMsg_PPBBroker_Connect(
+          INTERFACE_ID_PPB_BROKER, host_resource()));
   return success ?  PP_OK_COMPLETIONPENDING : PP_ERROR_FAILED;
 }
 
 int32_t Broker::GetHandle(int32_t* handle) {
   if (socket_handle_ == base::kInvalidPlatformFileValue)
     return PP_ERROR_FAILED;
   *handle = PlatformFileToInt(socket_handle_);
   return PP_OK;
 }
 
@@ skipping 43 matching lines @@
 PP_Resource PPB_Broker_Proxy::CreateProxyResource(PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBBroker_Create(
       INTERFACE_ID_PPB_BROKER, instance, &result));
   if (result.is_null())
     return 0;
-
-  return PluginResourceTracker::GetInstance()->AddResource(new Broker(result));
+  return (new Broker(result))->GetReference();
 }
 
 bool PPB_Broker_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Broker_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBBroker_Create, OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBBroker_Connect, OnMsgConnect)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBBroker_ConnectComplete,
                         OnMsgConnectComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 74 matching lines @@
       // The easiest way to clean it up is to just put it in an object
       // and then close it. This failure case is not performance critical.
       // The handle could still leak if Send succeeded but the IPC later failed.
       base::SyncSocket temp_socket(
           IPC::PlatformFileForTransitToPlatformFile(foreign_socket_handle));
   }
 }
 
 }  // namespace proxy
 }  // namespace pp