PepperPlatformAudioInputImpl: support audio input device selection.

webkit/plugins/ppapi/ppb_audio_input_impl.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 "webkit/plugins/ppapi/ppb_audio_input_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/shared_memory.h"
@@ skipping 76 matching lines @@
 
 const PPB_AudioInput_Impl::DeviceRefDataVector&
     PPB_AudioInput_Impl::GetDeviceRefData() const {
   return devices_data_;
 }
 
 void PPB_AudioInput_Impl::StreamCreated(
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket) {
-  // TODO(yzshen): Report open failure.
   OnOpenComplete(PP_OK, shared_memory_handle, shared_memory_size, socket);
 }
 
+void PPB_AudioInput_Impl::StreamCreationFailed() {
+  OnOpenComplete(PP_ERROR_FAILED, base::SharedMemory::NULLHandle(), 0,
+                 base::SyncSocket::kInvalidHandle);
+}
+
 int32_t PPB_AudioInput_Impl::InternalEnumerateDevices(
     PP_Resource* devices,
     PP_CompletionCallback callback) {
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return PP_ERROR_FAILED;
 
   devices_ = devices;
   enumerate_devices_callback_ = new TrackedCallback(this, callback);
   plugin_delegate->EnumerateDevices(
       PP_DEVICETYPE_DEV_AUDIOCAPTURE,
       base::Bind(&PPB_AudioInput_Impl::EnumerateDevicesCallbackFunc,
                  AsWeakPtr()));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_AudioInput_Impl::InternalOpen(const std::string& device_id,
                                           PP_AudioSampleRate sample_rate,
                                           uint32_t sample_frame_count,
                                           PP_CompletionCallback callback) {
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return PP_ERROR_FAILED;
 
-  // TODO(yzshen): Open the device specified by |device_id|.
   // When the stream is created, we'll get called back on StreamCreated().
   DCHECK(!audio_input_);
   audio_input_ = plugin_delegate->CreateAudioInput(
-      sample_rate, sample_frame_count, this);
+      device_id, sample_rate, sample_frame_count, this);
   if (audio_input_) {
     open_callback_ = new TrackedCallback(this, callback);
     return PP_OK_COMPLETIONPENDING;
   } else {
     return PP_ERROR_FAILED;
   }
 }
 
 PP_Bool PPB_AudioInput_Impl::InternalStartCapture() {
   if (!audio_input_)
     return PP_FALSE;
   SetStartCaptureState();
-  return BoolToPPBool(audio_input_->StartCapture());
+  audio_input_->StartCapture();
+  return PP_TRUE;
 }
 
 PP_Bool PPB_AudioInput_Impl::InternalStopCapture() {
   if (!audio_input_)
     return PP_FALSE;
-  if (!audio_input_->StopCapture())
-    return PP_FALSE;
+  audio_input_->StopCapture();
   SetStopCaptureState();
   return PP_TRUE;
 }
 
 void PPB_AudioInput_Impl::InternalClose() {
   // Calling ShutDown() makes sure StreamCreated() cannot be called anymore and
   // releases the audio data associated with the pointer. Note however, that
   // until ShutDown() returns, StreamCreated() may still be called. This will be
   // OK since OnOpenComplete() will clean up the handles and do nothing else in
   // that case.
   if (audio_input_) {
     audio_input_->ShutDown();
     audio_input_ = NULL;
   }
 }
 
 void PPB_AudioInput_Impl::EnumerateDevicesCallbackFunc(
     int request_id,
     bool succeeded,
     const DeviceRefDataVector& devices) {
   devices_data_.clear();
   if (succeeded)
     devices_data_ = devices;
 
   OnEnumerateDevicesComplete(succeeded ? PP_OK : PP_ERROR_FAILED, devices);
 }
 
 }  // namespace ppapi
 }  // namespace webkit