Refactor PPAPI proxy resource handling to maintain which host they came from,

and to map back to that host when calling functions on them. Adds a mapping
between resources generated by the hosts to a new list inside the plugin so
there can't be overlaps.

This means there are now two meanings for a PP_Resource, one in the plugin
process and one in the host process. This is potentially very confusing. I
introduced a new object called a HostResource that always represents a
"host" PP_Resource to try to prevent errors. In the plugin side of the proxy,
it only deals with PP_Resources valid in the plugin, and SerializedResources
valid in the host. It also encapsulates the associated instance, which
simplifies some code.

Each PluginResource object maintains its SerializedResource which the proxy
uses to send to the host for requests. This requires getting the PluginResource
object in more proxy calls.

This fixes a bug in var sending introduced in my previous patch. The var
releasing from EndSendPassRef used the host var rather than the plugin var. I
had to add more plumbing to get the dispatcher at this location and convert
to a plugin var.

I removed the separate file for ImageData and put it in ppb_image_data_proxy
like for the other resource types.

TEST=some unit tests included
BUG=none
Review URL: http://codereview.chromium.org/6334016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@72879 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 55 insertions, 41 deletions

diff --git a/ppapi/proxy/ppb_audio_proxy.cc b/ppapi/proxy/ppb_audio_proxy.cc
index 837637a..c1095cf 100644
--- a/ppapi/proxy/ppb_audio_proxy.cc
+++ b/ppapi/proxy/ppb_audio_proxy.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -19,11 +19,11 @@ namespace proxy {
 
 class Audio : public PluginResource, public pp::shared_impl::AudioImpl {
  public:
-  Audio(PP_Instance instance,
+  Audio(const HostResource& audio_id,
         PP_Resource config_id,
         PPB_Audio_Callback callback,
         void* user_data)
-      : PluginResource(instance),
+      : PluginResource(audio_id),
         config_(config_id) {
     SetCallback(callback, user_data);
     PluginResourceTracker::GetInstance()->AddRefResource(config_);
@@ -43,7 +43,7 @@ class Audio : public PluginResource, public pp::shared_impl::AudioImpl {
     SetStartPlaybackState();
     PluginDispatcher::GetForInstance(instance())->Send(
         new PpapiHostMsg_PPBAudio_StartOrStop(
-            INTERFACE_ID_PPB_AUDIO, resource, true));
+            INTERFACE_ID_PPB_AUDIO, host_resource(), true));
   }
 
   void StopPlayback(PP_Resource resource) {
@@ -51,7 +51,7 @@ class Audio : public PluginResource, public pp::shared_impl::AudioImpl {
       return;
     PluginDispatcher::GetForInstance(instance())->Send(
         new PpapiHostMsg_PPBAudio_StartOrStop(
-            INTERFACE_ID_PPB_AUDIO, resource, false));
+            INTERFACE_ID_PPB_AUDIO, host_resource(), false));
     SetStopPlaybackState();
   }
 
@@ -67,16 +67,19 @@ PP_Resource Create(PP_Instance instance_id,
                    PP_Resource config_id,
                    PPB_Audio_Callback callback,
                    void* user_data) {
-  PP_Resource result;
+  PluginResource* config = PluginResourceTracker::GetInstance()->
+      GetResourceObject(config_id);
+  if (!config)
+    return 0;
+
+  HostResource result;
   PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBAudio_Create(
-      INTERFACE_ID_PPB_AUDIO, instance_id, config_id, &result));
-  if (!result)
+      INTERFACE_ID_PPB_AUDIO, instance_id, config->host_resource(), &result));
+  if (result.is_null())
     return 0;
 
-  linked_ptr<Audio> object(new Audio(instance_id, config_id,
-                                     callback, user_data));
-  PluginResourceTracker::GetInstance()->AddResource(result, object);
-  return result;
+  linked_ptr<Audio> object(new Audio(result, config_id, callback, user_data));
+  return PluginResourceTracker::GetInstance()->AddResource(object);
 }
 
 PP_Bool IsAudio(PP_Resource resource) {
@@ -150,57 +153,61 @@ bool PPB_Audio_Proxy::OnMessageReceived(const IPC::Message& msg) {
 }
 
 void PPB_Audio_Proxy::OnMsgCreate(PP_Instance instance_id,
-                                  PP_Resource config_id,
-                                  PP_Resource* result) {
+                                  const HostResource& config_id,
+                                  HostResource* result) {
   const PPB_AudioTrusted* audio_trusted =
       reinterpret_cast<const PPB_AudioTrusted*>(
           dispatcher()->GetLocalInterface(PPB_AUDIO_TRUSTED_INTERFACE));
-  if (!audio_trusted) {
-    *result = 0;
+  if (!audio_trusted)
     return;
-  }
 
-  *result = audio_trusted->CreateTrusted(instance_id);
-  if (!result)
+  result->SetHostResource(instance_id,
+                          audio_trusted->CreateTrusted(instance_id));
+  if (result->is_null())
     return;
 
   CompletionCallback callback = callback_factory_.NewCallback(
       &PPB_Audio_Proxy::AudioChannelConnected, *result);
-  int32_t open_error = audio_trusted->Open(*result, config_id,
+  int32_t open_error = audio_trusted->Open(result->host_resource(),
+                                           config_id.host_resource(),
                                            callback.pp_completion_callback());
   if (open_error != PP_ERROR_WOULDBLOCK)
     callback.Run(open_error);
 }
 
-void PPB_Audio_Proxy::OnMsgStartOrStop(PP_Resource audio_id, bool play) {
+void PPB_Audio_Proxy::OnMsgStartOrStop(const HostResource& audio_id,
+                                       bool play) {
   if (play)
-    ppb_audio_target()->StartPlayback(audio_id);
+    ppb_audio_target()->StartPlayback(audio_id.host_resource());
   else
-    ppb_audio_target()->StopPlayback(audio_id);
+    ppb_audio_target()->StopPlayback(audio_id.host_resource());
 }
 
+// Processed in the plugin (message from host).
 void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
-    PP_Resource audio_id,
-    int32_t result_code,
-    IPC::PlatformFileForTransit socket_handle,
-    base::SharedMemoryHandle handle,
-    uint32_t length) {
-  Audio* object = PluginResource::GetAs<Audio>(audio_id);
-  if (!object || result_code != PP_OK) {
+    const PPBAudio_NotifyAudioStreamCreated_Params& params) {
+  PP_Resource plugin_resource =
+      PluginResourceTracker::GetInstance()->PluginResourceForHostResource(
+          params.audio_id);
+  Audio* object = plugin_resource ?
+      PluginResource::GetAs<Audio>(plugin_resource) : NULL;
+  if (!object || params.result_code != PP_OK) {
     // The caller may still have given us these handles in the failure case.
     // The easiest way to clean these up is to just put them in the objects
     // and then close them. This failure case is not performance critical.
     base::SyncSocket temp_socket(
-        IPC::PlatformFileForTransitToPlatformFile(socket_handle));
-    base::SharedMemory temp_mem(handle, false);
+        IPC::PlatformFileForTransitToPlatformFile(params.socket_handle));
+    base::SharedMemory temp_mem(params.handle, false);
     return;
   }
   object->SetStreamInfo(
-      handle, length, IPC::PlatformFileForTransitToPlatformFile(socket_handle));
+      params.handle, params.length,
+      IPC::PlatformFileForTransitToPlatformFile(params.socket_handle));
 }
 
-void PPB_Audio_Proxy::AudioChannelConnected(int32_t result,
-                                            PP_Resource resource) {
+void PPB_Audio_Proxy::AudioChannelConnected(
+    int32_t result,
+    const HostResource& resource) {
   IPC::PlatformFileForTransit socket_handle =
       IPC::InvalidPlatformFileForTransit();
 #if defined(OS_WIN)
@@ -224,13 +231,18 @@ void PPB_Audio_Proxy::AudioChannelConnected(int32_t result,
   // inconvenient to clean up. Our IPC code will automatically handle this for
   // us, as long as the remote side always closes the handles it receives
   // (in OnMsgNotifyAudioStreamCreated), even in the failure case.
+  PPBAudio_NotifyAudioStreamCreated_Params params;
+  params.audio_id = resource;
+  params.result_code = result;
+  params.socket_handle = socket_handle;
+  params.handle = shared_memory;
+  params.length = shared_memory_length;
   dispatcher()->Send(new PpapiMsg_PPBAudio_NotifyAudioStreamCreated(
-      INTERFACE_ID_PPB_AUDIO, resource, result_code, socket_handle,
-      shared_memory, shared_memory_length));
+      INTERFACE_ID_PPB_AUDIO, params));
 }
 
 int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
-    PP_Resource resource,
+    const HostResource& resource,
     IPC::PlatformFileForTransit* foreign_socket_handle,
     base::SharedMemoryHandle* foreign_shared_memory_handle,
     uint32_t* shared_memory_length) {
@@ -243,7 +255,8 @@ int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
 
   // Get the socket handle for signaling.
   int32_t socket_handle;
-  int32_t result = audio_trusted->GetSyncSocket(resource, &socket_handle);
+  int32_t result = audio_trusted->GetSyncSocket(resource.host_resource(),
+                                                &socket_handle);
   if (result != PP_OK)
     return result;
 
@@ -265,8 +278,9 @@ int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
   // Get the shared memory for the buffer.
   // TODO(brettw) remove the reinterpret cast when the interface is updated.
   int shared_memory_handle;
-  result = audio_trusted->GetSharedMemory(resource, &shared_memory_handle,
-      shared_memory_length);
+  result = audio_trusted->GetSharedMemory(resource.host_resource(),
+                                          &shared_memory_handle,
+                                          shared_memory_length);
   if (result != PP_OK)
     return result;