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

content/renderer/pepper/pepper_audio_input_host.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 "content/renderer/pepper/pepper_audio_input_host.h"
 
-#include "base/bind.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "ipc/ipc_message.h"
 #include "media/audio/shared_memory_util.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_structs.h"
-#include "ppapi/shared_impl/ppb_device_ref_shared.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 namespace content {
 
 namespace {
 
 base::PlatformFile ConvertSyncSocketHandle(const base::SyncSocket& socket) {
   return socket.handle();
 }
 
 base::PlatformFile ConvertSharedMemoryHandle(
     const base::SharedMemory& shared_memory) {
 #if defined(OS_POSIX)
   return shared_memory.handle().fd;
 #elif defined(OS_WIN)
   return shared_memory.handle();
 #else
 #error "Platform not supported."
 #endif
 }
 
 }  // namespace
 
 PepperAudioInputHost::PepperAudioInputHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
-      audio_input_(NULL) {
+      audio_input_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          enumeration_helper_(this, this, PP_DEVICETYPE_DEV_AUDIOCAPTURE)) {
 }
 
 PepperAudioInputHost::~PepperAudioInputHost() {
   Close();
 }
 
 int32_t PepperAudioInputHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
+  int32_t result = PP_ERROR_FAILED;
+  if (enumeration_helper_.HandleResourceMessage(msg, context, &result))
+    return result;
+
   IPC_BEGIN_MESSAGE_MAP(PepperAudioInputHost, msg)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
-        PpapiHostMsg_AudioInput_EnumerateDevices, OnMsgEnumerateDevices)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioInput_Open, OnMsgOpen)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioInput_StartOrStop,
                                       OnMsgStartOrStop);
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_AudioInput_Close,
                                         OnMsgClose);
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 void PepperAudioInputHost::StreamCreated(
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket) {
   OnOpenComplete(PP_OK, shared_memory_handle, shared_memory_size, socket);
 }
 
 void PepperAudioInputHost::StreamCreationFailed() {
   OnOpenComplete(PP_ERROR_FAILED, base::SharedMemory::NULLHandle(), 0,
                  base::SyncSocket::kInvalidHandle);
 }
 
-int32_t PepperAudioInputHost::OnMsgEnumerateDevices(
-    ppapi::host::HostMessageContext* context) {
-  if (enumerate_devices_context_.get())
-    return PP_ERROR_INPROGRESS;
-
-  webkit::ppapi::PluginDelegate* plugin_delegate = GetDelegate();
-  if (!plugin_delegate)
-    return PP_ERROR_FAILED;
-
-  enumerate_devices_context_.reset(
-      new ppapi::host::ReplyMessageContext(context->MakeReplyMessageContext()));
-  // Note that the callback may be called synchronously.
-  plugin_delegate->EnumerateDevices(
-      PP_DEVICETYPE_DEV_AUDIOCAPTURE,
-      base::Bind(&PepperAudioInputHost::EnumerateDevicesCallbackFunc,
-                 AsWeakPtr()));
-  return PP_OK_COMPLETIONPENDING;
+webkit::ppapi::PluginDelegate* PepperAudioInputHost::GetPluginDelegate() {
+  webkit::ppapi::PluginInstance* instance =
+      renderer_ppapi_host_->GetPluginInstance(pp_instance());
+  if (instance)
+    return instance->delegate();
+  return NULL;
 }
 
 int32_t PepperAudioInputHost::OnMsgOpen(
     ppapi::host::HostMessageContext* context,
     const std::string& device_id,
     PP_AudioSampleRate sample_rate,
     uint32_t sample_frame_count) {
   if (open_context_.get())
     return PP_ERROR_INPROGRESS;
   if (audio_input_)
     return PP_ERROR_FAILED;
 
-  webkit::ppapi::PluginDelegate* plugin_delegate = GetDelegate();
+  webkit::ppapi::PluginDelegate* plugin_delegate = GetPluginDelegate();
   if (!plugin_delegate)
     return PP_ERROR_FAILED;
 
   // When it is done, we'll get called back on StreamCreated() or
   // StreamCreationFailed().
   audio_input_ = plugin_delegate->CreateAudioInput(
       device_id, sample_rate, sample_frame_count, this);
   if (audio_input_) {
     open_context_.reset(new ppapi::host::ReplyMessageContext(
         context->MakeReplyMessageContext()));
@@ skipping 14 matching lines @@
     audio_input_->StopCapture();
   return PP_OK;
 }
 
 int32_t PepperAudioInputHost::OnMsgClose(
     ppapi::host::HostMessageContext* /* context */) {
   Close();
   return PP_OK;
 }
 
-void PepperAudioInputHost::EnumerateDevicesCallbackFunc(
-    int request_id,
-    bool succeeded,
-    const std::vector<ppapi::DeviceRefData>& devices) {
-  DCHECK(enumerate_devices_context_.get());
-
-  webkit::ppapi::PluginDelegate* plugin_delegate = GetDelegate();
-  if (plugin_delegate)
-    plugin_delegate->StopEnumerateDevices(request_id);
-
-  enumerate_devices_context_->params.set_result(
-      succeeded ? PP_OK : PP_ERROR_FAILED);
-  host()->SendReply(
-      *enumerate_devices_context_,
-      PpapiPluginMsg_AudioInput_EnumerateDevicesReply(
-          succeeded ? devices : std::vector<ppapi::DeviceRefData>()));
-  enumerate_devices_context_.reset();
-}
-
 void PepperAudioInputHost::OnOpenComplete(
     int32_t result,
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket_handle) {
   // Make sure the handles are cleaned up.
   base::SyncSocket scoped_socket(socket_handle);
   base::SharedMemory scoped_shared_memory(shared_memory_handle, false);
 
   if (!open_context_.get()) {
@@ skipping 61 matching lines @@
   audio_input_->ShutDown();
   audio_input_ = NULL;
 
   if (open_context_.get()) {
     open_context_->params.set_result(PP_ERROR_ABORTED);
     host()->SendReply(*open_context_, PpapiPluginMsg_AudioInput_OpenReply());
     open_context_.reset();
   }
 }
 
-webkit::ppapi::PluginDelegate* PepperAudioInputHost::GetDelegate() const {
-  webkit::ppapi::PluginInstance* instance =
-      renderer_ppapi_host_->GetPluginInstance(pp_instance());
-  if (instance)
-    return instance->delegate();
-  return NULL;
-}
-
 }  // namespace content