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

ppapi/proxy/ppb_flash_tcp_socket_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_tcp_socket_proxy.h"
 
 #include <algorithm>
 #include <cstring>
 #include <map>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
-#include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/ppb_flash_tcp_socket_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::HostResource;
+using ppapi::Resource;
 using ppapi::thunk::PPB_Flash_TCPSocket_API;
 
 namespace pp {
 namespace proxy {
 
 const int32_t kFlashTCPSocketMaxReadSize = 1024 * 1024;
 const int32_t kFlashTCPSocketMaxWriteSize = 1024 * 1024;
 
 class FlashTCPSocket;
 
@@ skipping 17 matching lines @@
 };
 
 InterfaceProxy* CreateFlashTCPSocketProxy(Dispatcher* dispatcher,
                                           const void* target_interface) {
   return new PPB_Flash_TCPSocket_Proxy(dispatcher, target_interface);
 }
 
 }  // namespace
 
 class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
-                       public PluginResource {
+                       public Resource {
  public:
   FlashTCPSocket(const HostResource& resource, uint32 socket_id);
   virtual ~FlashTCPSocket();
 
-  // ResourceObjectBase overrides.
+  // Resource overrides.
   virtual PPB_Flash_TCPSocket_API* AsPPB_Flash_TCPSocket_API() OVERRIDE;
 
   // PPB_Flash_TCPSocket_API implementation.
   virtual int32_t Connect(const char* host,
                           uint16_t port,
                           PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t ConnectWithNetAddress(
       const PP_Flash_NetAddress* addr,
       PP_CompletionCallback callback) OVERRIDE;
   virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) OVERRIDE;
@@ skipping 17 matching lines @@
 
  private:
   enum ConnectionState {
     // Before a connection is successfully established (including a connect
     // request is pending or a previous connect request failed).
     BEFORE_CONNECT,
     CONNECTED,
     DISCONNECTED
   };
 
+  PluginDispatcher* GetDispatcher() const {
+    return PluginDispatcher::GetForResource(this);
+  }

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

optional nit: You didn't do this anywhere else...  you just used GetForResource
or GetForInstance explicitly. Might make sense to just do the same thing here as
everywhere else?

[brettw, 2011/08/17 17:16:25]

I did this in a few places where we used GetDispatcher() a lot so the code is
overall shorter having a helper function.

+
   // Backend for both Connect() and ConnectWithNetAddress(). To keep things
   // generic, the message is passed in (on error, it's deleted).
   int32_t ConnectWithMessage(IPC::Message* msg,
                              PP_CompletionCallback callback);
 
   void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback);
 
   uint32 socket_id_;
   ConnectionState connection_state_;
 
   PP_CompletionCallback connect_callback_;
   PP_CompletionCallback read_callback_;
   PP_CompletionCallback write_callback_;
 
   char* read_buffer_;
   int32_t bytes_to_read_;
 
   PP_Flash_NetAddress local_addr_;
   PP_Flash_NetAddress remote_addr_;
 
   DISALLOW_COPY_AND_ASSIGN(FlashTCPSocket);
 };
 
 FlashTCPSocket::FlashTCPSocket(const HostResource& resource, uint32 socket_id)
-    : PluginResource(resource),
+    : Resource(resource),
       socket_id_(socket_id),
       connection_state_(BEFORE_CONNECT),
       connect_callback_(PP_BlockUntilComplete()),
       read_callback_(PP_BlockUntilComplete()),
       write_callback_(PP_BlockUntilComplete()),
       read_buffer_(NULL),
       bytes_to_read_(-1) {
   DCHECK(socket_id != 0);
 
   local_addr_.size = 0;
@@ skipping 228 matching lines @@
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   uint32 socket_id = 0;
   dispatcher->SendToBrowser(new PpapiHostMsg_PPBFlashTCPSocket_Create(
       INTERFACE_ID_PPB_FLASH_TCPSOCKET, dispatcher->plugin_dispatcher_id(),
       &socket_id));
   if (socket_id == 0)
     return 0;
-
-  return PluginResourceTracker::GetInstance()->AddResource(
-      new FlashTCPSocket(HostResource::MakeInstanceOnly(instance), socket_id));
+  return (new FlashTCPSocket(HostResource::MakeInstanceOnly(instance),
+                             socket_id))->GetReference();
 }
 
 bool PPB_Flash_TCPSocket_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Flash_TCPSocket_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ConnectACK, OnMsgConnectACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ReadACK, OnMsgReadACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_WriteACK, OnMsgWriteACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 39 matching lines @@
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnWriteCompleted(succeeded, bytes_written);
 }
 
 }  // namespace proxy
 }  // namespace pp