First pass at making the proxy handle multiple renderers. This associates the...

ppapi/proxy/ppb_url_loader_proxy.cc

 // Copyright (c) 2010 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 <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 10 matching lines @@
 
 #if defined(OS_LINUX)
 #include <sys/shm.h>
 #endif
 
 namespace pp {
 namespace proxy {
 
 class URLLoader : public PluginResource {
  public:
-  URLLoader();
+  URLLoader(PP_Instance instance);
   virtual ~URLLoader();
 
   // Resource overrides.
   virtual URLLoader* AsURLLoader() { return 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_;
   char* current_read_buffer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(URLLoader);
 };
 
-URLLoader::URLLoader()
-    : bytes_sent_(-1),
+URLLoader::URLLoader(PP_Instance instance)
+    : PluginResource(instance),
+      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) {
 }
 
 URLLoader::~URLLoader() {
 }
 
 namespace {
 
+// Converts the given loader ID to the dispatcher associated with it, or NULL
+// if it couldn't be found.
+PluginDispatcher* DispatcherFromURLLoader(PP_Resource loader_id) {
+  URLLoader* object = PluginResource::GetAs<URLLoader>(loader_id);
+  if (!object)
+    return NULL;
+  return PluginDispatcher::GetForInstance(object->instance());
+}
+
 // Plugin PPB_URLLoader implmentation ------------------------------------------
 
 PP_Resource Create(PP_Instance instance_id) {
-  PluginDispatcher* dispatcher = PluginDispatcher::Get();
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
+  if (!dispatcher)
+    return 0;
+
   PP_Resource result = 0;
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Create(
       INTERFACE_ID_PPB_URL_LOADER, instance_id, &result));
   if (result)
-    PPB_URLLoader_Proxy::TrackPluginResource(result);
+    PPB_URLLoader_Proxy::TrackPluginResource(instance_id, result);
   return result;
 }
 
 PP_Bool IsURLLoader(PP_Resource resource) {
   URLLoader* object = PluginResource::GetAs<URLLoader>(resource);
   return BoolToPPBool(!!object);
 }
 
 int32_t Open(PP_Resource loader_id,
              PP_Resource request_id,
              PP_CompletionCallback callback) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  PluginDispatcher* dispatcher = DispatcherFromURLLoader(loader_id);
+  if (!dispatcher)
+    return PP_ERROR_BADRESOURCE;
+
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Open(
       INTERFACE_ID_PPB_URL_LOADER, loader_id, request_id,
       dispatcher->callback_tracker().SendCallback(callback)));
   return PP_ERROR_WOULDBLOCK;
 }
 
 int32_t FollowRedirect(PP_Resource loader_id,
                        PP_CompletionCallback callback) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  PluginDispatcher* dispatcher = DispatcherFromURLLoader(loader_id);
+  if (!dispatcher)
+    return PP_ERROR_BADRESOURCE;
+
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_FollowRedirect(
       INTERFACE_ID_PPB_URL_LOADER, loader_id,
       dispatcher->callback_tracker().SendCallback(callback)));
   return PP_ERROR_WOULDBLOCK;
 }
 
 PP_Bool GetUploadProgress(PP_Resource loader_id,
                           int64_t* bytes_sent,
                           int64_t* total_bytes_to_be_sent) {
   URLLoader* object = PluginResource::GetAs<URLLoader>(loader_id);
@@ skipping 15 matching lines @@
     *bytes_received = 0;
     *total_bytes_to_be_received = 0;
     return PP_FALSE;
   }
   *bytes_received = object->bytes_received_;
   *total_bytes_to_be_received = object->total_bytes_to_be_received_;
   return PP_TRUE;
 }
 
 PP_Resource GetResponseInfo(PP_Resource loader_id) {
+  URLLoader* object = PluginResource::GetAs<URLLoader>(loader_id);
+  if (!object)
+    return 0;
+
   // If we find that plugins are frequently requesting the response info, we
   // can improve performance by caching the PP_Resource in the URLLoader
   // object. This way we only have to do IPC for the first request. However,
   // it seems that most plugins will only call this once so there's no use
   // optimizing this case.
 
   PP_Resource result;
-  PluginDispatcher* dispatcher = PluginDispatcher::Get();
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(
+      object->instance());
+  if (!dispatcher)
+    return PP_ERROR_BADRESOURCE;
+
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_GetResponseInfo(
       INTERFACE_ID_PPB_URL_LOADER, loader_id, &result));
-  if (dispatcher->plugin_resource_tracker()->PreparePreviouslyTrackedResource(
-      result))
+  if (PluginResourceTracker::GetInstance()->
+          PreparePreviouslyTrackedResource(result))
     return result;
 
   // Tell the response info to create a tracking object and add it to the
   // resource tracker.
-  PPB_URLResponseInfo_Proxy::TrackPluginResource(result);
+  PPB_URLResponseInfo_Proxy::TrackPluginResource(object->instance(), result);
   return result;
 }
 
 int32_t ReadResponseBody(PP_Resource loader_id,
                          char* buffer,
                          int32_t bytes_to_read,
                          PP_CompletionCallback callback) {
   URLLoader* object = PluginResource::GetAs<URLLoader>(loader_id);
   if (!object)
     return PP_ERROR_BADRESOURCE;
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(
+      object->instance());
+  if (!dispatcher)
+    return PP_ERROR_BADRESOURCE;
 
   if (!buffer)
     return PP_ERROR_BADARGUMENT;  // Must specify an output buffer.
   if (object->current_read_callback_.func)
     return PP_ERROR_INPROGRESS;  // Can only have one request pending.
 
   // Currently we don't support sync calls to read. We'll need to revisit
   // how this works when we allow blocking calls (from background threads).
   if (!callback.func)
     return PP_ERROR_BADARGUMENT;
 
   object->current_read_callback_ = callback;
   object->current_read_buffer_ = buffer;
 
-  PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBURLLoader_ReadResponseBody(
+  dispatcher->Send(new PpapiHostMsg_PPBURLLoader_ReadResponseBody(
       INTERFACE_ID_PPB_URL_LOADER, loader_id, bytes_to_read));
   return PP_ERROR_WOULDBLOCK;
 }
 
 int32_t FinishStreamingToFile(PP_Resource loader_id,
                               PP_CompletionCallback callback) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  PluginDispatcher* dispatcher = DispatcherFromURLLoader(loader_id);
+  if (!dispatcher)
+    return PP_ERROR_BADRESOURCE;
+
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_FinishStreamingToFile(
       INTERFACE_ID_PPB_URL_LOADER, loader_id,
       dispatcher->callback_tracker().SendCallback(callback)));
   return PP_ERROR_WOULDBLOCK;
 }
 
 void Close(PP_Resource loader_id) {
-  PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBURLLoader_Close(
+  PluginDispatcher* dispatcher = DispatcherFromURLLoader(loader_id);
+  if (!dispatcher)
+    return;
+
+  dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Close(
       INTERFACE_ID_PPB_URL_LOADER, loader_id));
 }
 
 const PPB_URLLoader ppb_urlloader = {
   &Create,
   &IsURLLoader,
   &Open,
   &FollowRedirect,
   &GetUploadProgress,
   &GetDownloadProgress,
@@ skipping 28 matching lines @@
 PPB_URLLoader_Proxy::PPB_URLLoader_Proxy(Dispatcher* dispatcher,
                                          const void* target_interface)
     : InterfaceProxy(dispatcher, target_interface),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_URLLoader_Proxy::~PPB_URLLoader_Proxy() {
 }
 
 // static
-void PPB_URLLoader_Proxy::TrackPluginResource(PP_Resource url_loader_resource) {
-  linked_ptr<URLLoader> object(new URLLoader);
-  PluginDispatcher::Get()->plugin_resource_tracker()->AddResource(
-      url_loader_resource, object);
+void PPB_URLLoader_Proxy::TrackPluginResource(PP_Instance instance,
+                                              PP_Resource url_loader_resource) {
+  linked_ptr<URLLoader> object(new URLLoader(instance));
+  PluginResourceTracker::GetInstance()->AddResource(url_loader_resource,
+                                                    object);
 }
 
 const void* PPB_URLLoader_Proxy::GetSourceInterface() const {
   return &ppb_urlloader;
 }
 
 InterfaceID PPB_URLLoader_Proxy::GetInterfaceId() const {
   return INTERFACE_ID_PPB_URL_LOADER;
 }
 
@@ skipping 189 matching lines @@
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_URLLoaderTrusted_Proxy::OnMsgGrantUniversalAccess(PP_Resource loader) {
   ppb_url_loader_trusted_target()->GrantUniversalAccess(loader);
 }
 
 }  // namespace proxy
 }  // namespace pp