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

ppapi/proxy/ppb_audio_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_audio_proxy.h"
 
 #include "base/threading/simple_thread.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/trusted/ppb_audio_trusted.h"
 #include "ppapi/proxy/interface_id.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/audio_impl.h"
 
 namespace pp {
 namespace proxy {
 
 class Audio : public PluginResource, public pp::shared_impl::AudioImpl {
  public:
-  Audio(PP_Resource config_id, PPB_Audio_Callback callback, void* user_data)
-      : config_(config_id) {
+  Audio(PP_Instance instance,
+        PP_Resource config_id,
+        PPB_Audio_Callback callback,
+        void* user_data)
+      : PluginResource(instance),
+        config_(config_id) {
     SetCallback(callback, user_data);
-    PluginDispatcher::Get()->plugin_resource_tracker()->AddRefResource(
-        config_);
+    PluginResourceTracker::GetInstance()->AddRefResource(config_);
   }
   virtual ~Audio() {
-    PluginDispatcher::Get()->plugin_resource_tracker()->ReleaseResource(
-        config_);
+    PluginResourceTracker::GetInstance()->ReleaseResource(config_);
   }
 
   // Resource overrides.
   virtual Audio* AsAudio() { return this; }
 
   PP_Resource config() const { return config_; }
 
   void StartPlayback(PP_Resource resource) {
     if (playing())
       return;
     SetStartPlaybackState();
-    PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBAudio_StartOrStop(
-        INTERFACE_ID_PPB_AUDIO, resource, true));
+    PluginDispatcher::GetForInstance(instance())->Send(
+        new PpapiHostMsg_PPBAudio_StartOrStop(
+            INTERFACE_ID_PPB_AUDIO, resource, true));
   }
 
   void StopPlayback(PP_Resource resource) {
     if (!playing())
       return;
-    PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBAudio_StartOrStop(
-        INTERFACE_ID_PPB_AUDIO, resource, false));
+    PluginDispatcher::GetForInstance(instance())->Send(
+        new PpapiHostMsg_PPBAudio_StartOrStop(
+            INTERFACE_ID_PPB_AUDIO, resource, false));
     SetStopPlaybackState();
   }
 
  private:
   PP_Resource config_;
 
   DISALLOW_COPY_AND_ASSIGN(Audio);
 };
 
 namespace {
 
 PP_Resource Create(PP_Instance instance_id,
                    PP_Resource config_id,
                    PPB_Audio_Callback callback,
                    void* user_data) {
   PP_Resource result;
   PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBAudio_Create(
       INTERFACE_ID_PPB_AUDIO, instance_id, config_id, &result));
   if (!result)
     return 0;
 
-  linked_ptr<Audio> object(new Audio(config_id, callback, user_data));
-  PluginDispatcher::Get()->plugin_resource_tracker()->AddResource(
-      result, object);
+  linked_ptr<Audio> object(new Audio(instance_id, config_id,
+                                     callback, user_data));
+  PluginResourceTracker::GetInstance()->AddResource(result, object);
   return result;
 }
 
 PP_Bool IsAudio(PP_Resource resource) {
   Audio* object = PluginResource::GetAs<Audio>(resource);
   return BoolToPPBool(!!object);
 }
 
 PP_Resource GetCurrentConfiguration(PP_Resource audio_id) {
   Audio* object = PluginResource::GetAs<Audio>(audio_id);
   if (!object)
     return 0;
   PP_Resource result = object->config();
-  PluginDispatcher::Get()->plugin_resource_tracker()->AddRefResource(result);
+  PluginResourceTracker::GetInstance()->AddRefResource(result);
   return result;
 }
 
 PP_Bool StartPlayback(PP_Resource audio_id) {
   Audio* object = PluginResource::GetAs<Audio>(audio_id);
   if (!object)
     return PP_FALSE;
   object->StartPlayback(audio_id);
   return PP_TRUE;
 }
@@ skipping 179 matching lines @@
   // close the source handle.
   if (!shared_memory.GiveToProcess(dispatcher()->remote_process_handle(),
                                    foreign_shared_memory_handle))
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace pp