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

ppapi/proxy/ppb_url_loader_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_url_loader_proxy.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.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/proxy/ppb_url_response_info_proxy.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_url_loader_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 #if defined(OS_LINUX)
 #include <sys/shm.h>
 #endif
 
 using ppapi::HostResource;
+using ppapi::Resource;
 using ppapi::thunk::EnterFunctionNoLock;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_URLLoader_API;
 using ppapi::thunk::ResourceCreationAPI;
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
@@ skipping 27 matching lines @@
 
 InterfaceProxy* CreateURLLoaderProxy(Dispatcher* dispatcher,
                                      const void* target_interface) {
   return new PPB_URLLoader_Proxy(dispatcher, target_interface);
 }
 
 }  // namespace
 
 // URLLoader -------------------------------------------------------------------
 
-class URLLoader : public PluginResource, public PPB_URLLoader_API {
+class URLLoader : public Resource, public PPB_URLLoader_API {
  public:
   URLLoader(const HostResource& resource);
   virtual ~URLLoader();
 
-  // ResourceObjectBase overrides.
+  // Resource overrides.
   virtual PPB_URLLoader_API* AsPPB_URLLoader_API() OVERRIDE;
 
   // PPB_URLLoader_API implementation.
   virtual int32_t Open(PP_Resource request_id,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t FollowRedirect(PP_CompletionCallback callback) OVERRIDE;
   virtual PP_Bool GetUploadProgress(int64_t* bytes_sent,
                                     int64_t* total_bytes_to_be_sent) OVERRIDE;
   virtual PP_Bool GetDownloadProgress(
       int64_t* bytes_received,
@@ skipping 15 matching lines @@
   // Called when the browser responds to our ReadResponseBody request.
   void ReadResponseBodyAck(int32 result, const std::string& data);
 
  private:
   // Reads the give bytes out of the buffer_, placing them in the given output
   // buffer, and removes the bytes from the buffer.
   //
   // The size must be not more than the current size of the buffer.
   void PopBuffer(void* output_buffer, int32_t output_size);
 
+  PluginDispatcher* GetDispatcher() const {
+    return PluginDispatcher::GetForResource(this);
+  }
+
   // Initialized to -1. Will be set to nonnegative values by the UpdateProgress
   // message when the values are known.
   int64_t bytes_sent_;
   int64_t total_bytes_to_be_sent_;
   int64_t bytes_received_;
   int64_t total_bytes_to_be_received_;
 
   // When an asynchronous read is pending, this will contain the callback and
   // the buffer to put the data.
   PP_CompletionCallback current_read_callback_;
   void* current_read_buffer_;
   int32_t current_read_buffer_size_;
 
   // A buffer of all the data that's been sent to us from the host that we
   // have yet to send out to the plugin.
   std::deque<char> buffer_;
 
   // Cached copy of the response info. When nonzero, we're holding a reference
   // to this resource.
   PP_Resource response_info_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(URLLoader);
 };
 
 URLLoader::URLLoader(const HostResource& resource)
-    : PluginResource(resource),
+    : Resource(resource),
       bytes_sent_(-1),
       total_bytes_to_be_sent_(-1),
       bytes_received_(-1),
       total_bytes_to_be_received_(-1),
       current_read_callback_(PP_MakeCompletionCallback(NULL, NULL)),
       current_read_buffer_(NULL),
       current_read_buffer_size_(0),
       response_info_(0) {
 }
 
@@ skipping 10 matching lines @@
   if (response_info_)
     PluginResourceTracker::GetInstance()->ReleaseResource(response_info_);
 }
 
 PPB_URLLoader_API* URLLoader::AsPPB_URLLoader_API() {
   return this;
 }
 
 int32_t URLLoader::Open(PP_Resource request_id,
                         PP_CompletionCallback callback) {
-  PluginResource* request_object =
-      PluginResourceTracker::GetInstance()->GetResourceObject(request_id);
+  Resource* request_object =
+      PluginResourceTracker::GetInstance()->GetResource(request_id);
   if (!request_object)
     return PP_ERROR_BADARGUMENT;
 
   // TODO(brettw) http://crbug.com/86279: SendCallback doesn't ensure that
   // the proper callback semantics happen if the object is deleted.
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_Open(
       INTERFACE_ID_PPB_URL_LOADER, host_resource(),
       request_object->host_resource(),
       GetDispatcher()->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
@@ skipping 158 matching lines @@
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       host_urlloader_trusted_interface_(NULL) {
 }
 
 PPB_URLLoader_Proxy::~PPB_URLLoader_Proxy() {
 }
 
 // static
 PP_Resource PPB_URLLoader_Proxy::TrackPluginResource(
     const HostResource& url_loader_resource) {
-  return PluginResourceTracker::GetInstance()->AddResource(
-      new URLLoader(url_loader_resource));
+  return (new URLLoader(url_loader_resource))->GetReference();
 }
 
 // static
 const InterfaceProxy::Info* PPB_URLLoader_Proxy::GetInfo() {
   static const Info info = {
     ::ppapi::thunk::GetPPB_URLLoader_Thunk(),
     PPB_URLLOADER_INTERFACE,
     INTERFACE_ID_PPB_URL_LOADER,
     false,
     &CreateURLLoaderProxy,
@@ skipping 205 matching lines @@
   info->read_buffer.resize(bytes_read);
 
   dispatcher()->Send(new PpapiMsg_PPBURLLoader_ReadResponseBody_Ack(
       INTERFACE_ID_PPB_URL_LOADER, info->resource, result, info->read_buffer));
 
   delete info;
 }
 
 }  // namespace proxy
 }  // namespace pp