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

ppapi/proxy/ppb_audio_config_proxy.cc

-// 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.
 
 #include "ppapi/proxy/ppb_audio_config_proxy.h"
 
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace pp {
 namespace proxy {
 
 class AudioConfig : public PluginResource {
  public:
   AudioConfig(PP_Instance instance,
+              SerializedResource resource,
               PP_AudioSampleRate sample_rate,
               uint32_t sample_frame_count)
-      : PluginResource(instance),
+      : PluginResource(instance, resource),
         sample_rate_(sample_rate),
         sample_frame_count_(sample_frame_count) {
   }
   virtual ~AudioConfig() {}
 
   // Resource overrides.
   virtual AudioConfig* AsAudioConfig() { return this; }
 
   PP_AudioSampleRate sample_rate() const { return sample_rate_; }
   uint32_t sample_frame_count() const { return sample_frame_count_; }
 
  private:
   PP_AudioSampleRate sample_rate_;
   uint32_t sample_frame_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioConfig);
 };
 
 namespace {
 
 PP_Resource CreateStereo16bit(PP_Instance instance,
                               PP_AudioSampleRate sample_rate,
                               uint32_t sample_frame_count) {
-  PP_Resource result = 0;
+  SerializedResource resource;
   PluginDispatcher::GetForInstance(instance)->Send(
       new PpapiHostMsg_PPBAudioConfig_Create(
           INTERFACE_ID_PPB_AUDIO_CONFIG, instance,
           static_cast<int32_t>(sample_rate), sample_frame_count,
-          &result));
-  if (!result)
+          &resource));
+  if (!resource.is_null())
     return 0;
 
   linked_ptr<AudioConfig> object(
-      new AudioConfig(instance, sample_rate, sample_frame_count));
-  PluginResourceTracker::GetInstance()->AddResource(result, object);
-  return result;
+      new AudioConfig(instance, resource, sample_rate, sample_frame_count));
+  return PluginResourceTracker::GetInstance()->AddResource(object);
 }
 
 uint32_t RecommendSampleFrameCount(PP_AudioSampleRate sample_rate,
                                    uint32_t requested_sample_frame_count) {
   // TODO(brettw) Currently we don't actually query to get a value from the
   // hardware, so we always return the input for in-range values.
   //
   // Danger: this code is duplicated in the audio config implementation.
   if (requested_sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
     return PP_AUDIOMINSAMPLEFRAMECOUNT;
@@ skipping 55 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioConfig_RecommendSampleFrameCount,
                         OnMsgRecommendSampleFrameCount)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PPB_AudioConfig_Proxy::OnMsgCreateStereo16Bit(PP_Instance instance,
                                                    int32_t sample_rate,
                                                    uint32_t sample_frame_count,
-                                                   PP_Resource* result) {
-  *result = ppb_audio_config_target()->CreateStereo16Bit(
+                                                   SerializedResource* result) {
+  result->set_host_resource(ppb_audio_config_target()->CreateStereo16Bit(
       instance, static_cast<PP_AudioSampleRate>(sample_rate),
-      sample_frame_count);
+      sample_frame_count));
 }
 
 void PPB_AudioConfig_Proxy::OnMsgRecommendSampleFrameCount(
     int32_t sample_rate,
     uint32_t requested_sample_frame_count,
     uint32_t* result) {
   *result = ppb_audio_config_target()->RecommendSampleFrameCount(
       static_cast<PP_AudioSampleRate>(sample_rate),
       requested_sample_frame_count);
 }
 
 }  // namespace proxy
 }  // namespace pp