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

ppapi/proxy/ppb_flash_net_connector_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_flash_net_connector_proxy.h"
 
 #include <algorithm>
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_flash_net_connector.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/serialized_var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_flash_net_connector_api.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::PPB_Flash_NetConnector_API;
 using ppapi::thunk::ResourceCreationAPI;
 
 namespace pp {
 namespace proxy {
 
 std::string NetAddressToString(const PP_Flash_NetAddress& addr) {
   return std::string(addr.data, std::min(static_cast<size_t>(addr.size),
                                          sizeof(addr.data)));
@@ skipping 11 matching lines @@
 
   virtual void Run() {
     PP_RunCompletionCallback(&callback_, PP_ERROR_ABORTED);
   }
 
  private:
   PP_CompletionCallback callback_;
 };
 
 class FlashNetConnector : public PPB_Flash_NetConnector_API,
-                          public PluginResource {
+                          public Resource {
  public:
   explicit FlashNetConnector(const HostResource& resource);
   virtual ~FlashNetConnector();
 
-  // ResourceObjectBase overrides.
+  // Resource overrides.
   virtual PPB_Flash_NetConnector_API* AsPPB_Flash_NetConnector_API() OVERRIDE;
 
   // PPB_Flash_NetConnector_API implementation.
   virtual int32_t ConnectTcp(const char* host,
                              uint16_t port,
                              PP_FileHandle* socket_out,
                              PP_Flash_NetAddress* local_addr_out,
                              PP_Flash_NetAddress* remote_addr_out,
                              PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t ConnectTcpAddress(const PP_Flash_NetAddress* addr,
@@ skipping 16 matching lines @@
                              PP_Flash_NetAddress* remote_addr_out,
                              PP_CompletionCallback callback);
 
   PP_CompletionCallback callback_;
   PP_FileHandle* socket_out_;
   PP_Flash_NetAddress* local_addr_out_;
   PP_Flash_NetAddress* remote_addr_out_;
 };
 
 FlashNetConnector::FlashNetConnector(const HostResource& resource)
-    : PluginResource(resource),
+    : Resource(resource),
       callback_(PP_BlockUntilComplete()),
       local_addr_out_(NULL),
       remote_addr_out_(NULL) {
 }
 
 FlashNetConnector::~FlashNetConnector() {
   if (callback_.func) {
     MessageLoop::current()->PostTask(FROM_HERE,
                                      new AbortCallbackTask(callback_));
   }
@@ skipping 50 matching lines @@
     IPC::Message* msg,
     PP_FileHandle* socket_out,
     PP_Flash_NetAddress* local_addr_out,
     PP_Flash_NetAddress* remote_addr_out,
     PP_CompletionCallback callback) {
   scoped_ptr<IPC::Message> msg_deletor(msg);
   if (callback_.func != NULL)
     return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
   // Send the request, it will call us back via ConnectACK.
-  GetDispatcher()->Send(msg_deletor.release());
+  PluginDispatcher::GetForResource(this)->Send(msg_deletor.release());
 
   callback_ = callback;
   socket_out_ = socket_out;
   local_addr_out_ = local_addr_out;
   remote_addr_out_ = remote_addr_out;
   return PP_OK_COMPLETIONPENDING;
 }
 
 // Contains the data that the host interface will write to so we can send it
 // to the plugin. This is created when a request is initiated, and deleted in
@@ skipping 46 matching lines @@
     PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBFlashNetConnector_Create(
       INTERFACE_ID_PPB_FLASH_NETCONNECTOR, instance, &result));
   if (result.is_null())
     return 0;
-
-  return PluginResourceTracker::GetInstance()->AddResource(
-      new FlashNetConnector(result));
+  return (new FlashNetConnector(result))->GetReference();
 }
 
 bool PPB_Flash_NetConnector_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Flash_NetConnector_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlashNetConnector_Create,
                         OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlashNetConnector_ConnectTcp,
                         OnMsgConnectTcp)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlashNetConnector_ConnectTcpAddress,
@@ skipping 91 matching lines @@
   } else {
     dispatcher()->Send(new PpapiMsg_PPBFlashNetConnector_ConnectACK(
         INTERFACE_ID_PPB_FLASH_NETCONNECTOR,
         info->resource, result,
         IPC::InvalidPlatformFileForTransit(), std::string(), std::string()));
   }
 }
 
 }  // namespace proxy
 }  // namespace pp