Introduce PPB_AudioInput_Dev v0.3 and refactor the device enumeration code:

ppapi/proxy/audio_input_resource.cc

 // Copyright (c) 2012 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/audio_input_resource.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/shared_memory_util.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_message_params.h"
 #include "ppapi/proxy/serialized_structs.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
-#include "ppapi/shared_impl/ppb_device_ref_shared.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_audio_config_api.h"
 
 namespace ppapi {
 namespace proxy {
 
 AudioInputResource::AudioInputResource(
     Connection connection,
     PP_Instance instance)
     : PluginResource(connection, instance),
       open_state_(BEFORE_OPEN),
       capturing_(false),
       shared_memory_size_(0),
       audio_input_callback_(NULL),
       user_data_(NULL),
-      pending_enumerate_devices_(false) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(enumeration_helper_(this)) {
   SendCreate(RENDERER, PpapiHostMsg_AudioInput_Create());
 }
 
 AudioInputResource::~AudioInputResource() {
   Close();
 }
 
 thunk::PPB_AudioInput_API* AudioInputResource::AsPPB_AudioInput_API() {
   return this;
 }
 
-int32_t AudioInputResource::EnumerateDevices(
+void AudioInputResource::OnReplyReceived(
+    const ResourceMessageReplyParams& params,
+    const IPC::Message& msg) {
+  if (!enumeration_helper_.HandleReply(params, msg))
+    PluginResource::OnReplyReceived(params, msg);
+}
+
+int32_t AudioInputResource::EnumerateDevices0_2(
     PP_Resource* devices,
     scoped_refptr<TrackedCallback> callback) {
-  if (pending_enumerate_devices_)
-    return PP_ERROR_INPROGRESS;
-  if (!devices)
-    return PP_ERROR_BADARGUMENT;
+  return enumeration_helper_.EnumerateDevices0_2(devices, callback);
+}
 
-  pending_enumerate_devices_ = true;
-  PpapiHostMsg_AudioInput_EnumerateDevices msg;
-  Call<PpapiPluginMsg_AudioInput_EnumerateDevicesReply>(
-      RENDERER, msg,
-      base::Bind(&AudioInputResource::OnPluginMsgEnumerateDevicesReply,
-                 base::Unretained(this), devices, callback));
-  return PP_OK_COMPLETIONPENDING;
+int32_t AudioInputResource::EnumerateDevices(
+    const PP_ArrayOutput& output,
+    scoped_refptr<TrackedCallback> callback) {
+  return enumeration_helper_.EnumerateDevices(output, callback);
+}
+
+int32_t AudioInputResource::MonitorDeviceChange(
+    PP_MonitorDeviceChangeCallback callback,
+    void* user_data) {
+  return enumeration_helper_.MonitorDeviceChange(callback, user_data);
 }
 
 int32_t AudioInputResource::Open(const std::string& device_id,
                                  PP_Resource config,
                                  PPB_AudioInput_Callback audio_input_callback,
                                  void* user_data,
                                  scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(open_callback_))
     return PP_ERROR_INPROGRESS;
   if (open_state_ != BEFORE_OPEN)
@@ skipping 74 matching lines @@
     return;
 
   open_state_ = CLOSED;
   Post(RENDERER, PpapiHostMsg_AudioInput_Close());
   StopThread();
 
   if (TrackedCallback::IsPending(open_callback_))
     open_callback_->PostAbort();
 }
 
-void AudioInputResource::OnPluginMsgEnumerateDevicesReply(
-    PP_Resource* devices_resource,
-    scoped_refptr<TrackedCallback> callback,
-    const ResourceMessageReplyParams& params,
-    const std::vector<DeviceRefData>& devices) {
-  pending_enumerate_devices_ = false;
-
-  // We shouldn't access |devices_resource| if the callback has been called,
-  // which is possible if the last plugin reference to this resource has gone
-  // away, and the callback has been aborted.
-  if (!TrackedCallback::IsPending(callback))
-    return;
-
-  if (params.result() == PP_OK) {
-    *devices_resource = PPB_DeviceRef_Shared::CreateResourceArray(
-        OBJECT_IS_PROXY, pp_instance(), devices);
-  }
-
-  callback->Run(params.result());
+void AudioInputResource::LastPluginRefWasDeleted() {
+  enumeration_helper_.LastPluginRefWasDeleted();
 }
 
 void AudioInputResource::OnPluginMsgOpenReply(
     const ResourceMessageReplyParams& params) {
   if (open_state_ == BEFORE_OPEN && params.result() == PP_OK) {
     IPC::PlatformFileForTransit socket_handle_for_transit =
         IPC::InvalidPlatformFileForTransit();
     params.TakeSocketHandleAtIndex(0, &socket_handle_for_transit);
     base::SyncSocket::Handle socket_handle =
         IPC::PlatformFileForTransitToPlatformFile(socket_handle_for_transit);
@@ skipping 81 matching lines @@
     // While closing the stream, we may receive buffers whose size is different
     // from |data_buffer_size|.
     CHECK_LE(buffer->params.size, data_buffer_size);
     if (buffer->params.size > 0)
       audio_input_callback_(&buffer->audio[0], buffer->params.size, user_data_);
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi