PepperPlatformAudioInputImpl: support audio input device selection.

ppapi/shared_impl/ppb_audio_input_shared.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/shared_impl/ppb_audio_input_shared.h"
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
@@ skipping 73 matching lines @@
 }
 
 PP_Bool PPB_AudioInput_Shared::StartCapture() {
   if (open_state_ == CLOSED || (open_state_ == BEFORE_OPEN &&
                                 !TrackedCallback::IsPending(open_callback_))) {
     return PP_FALSE;
   }
   if (capturing_)
     return PP_TRUE;
 
+  // If the audio input device hasn't been opened, set |capturing_| to true and
+  // return directly. Capturing will be started once the open operation is
+  // completed.
+  if (open_state_ == BEFORE_OPEN) {
+    capturing_ = true;
+    return PP_TRUE;
+  }
+
   return InternalStartCapture();
 }
 
 PP_Bool PPB_AudioInput_Shared::StopCapture() {
-  if (open_state_ == CLOSED || (open_state_ == BEFORE_OPEN &&
-                                !TrackedCallback::IsPending(open_callback_))) {
+  if (open_state_ == CLOSED)
     return PP_FALSE;
-  }
   if (!capturing_)
     return PP_TRUE;
 
+  // If the audio input device hasn't been opened, set |capturing_| to false and
+  // return directly.
+  if (open_state_ == BEFORE_OPEN) {
+    capturing_ = false;
+    return PP_TRUE;
+  }
+
   return InternalStopCapture();
 }
 
 void PPB_AudioInput_Shared::Close() {
   if (open_state_ == CLOSED)
     return;
 
   open_state_ = CLOSED;
   InternalClose();
 
@@ skipping 28 matching lines @@
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket_handle) {
   if (open_state_ == BEFORE_OPEN && result == PP_OK) {
     open_state_ = OPENED;
     SetStreamInfo(shared_memory_handle, shared_memory_size, socket_handle);
   } else {
     // Clean up the handles.
     base::SyncSocket temp_socket(socket_handle);
     base::SharedMemory temp_mem(shared_memory_handle, false);
+    capturing_ = false;
   }
 
   // The callback may have been aborted by Close().
   if (TrackedCallback::IsPending(open_callback_))
     TrackedCallback::ClearAndRun(&open_callback_, result);
 }
 
 // static
 PP_CompletionCallback PPB_AudioInput_Shared::MakeIgnoredCompletionCallback() {
   return PP_MakeCompletionCallback(&IgnoredCompletionCallback, NULL);
 }
 
 void PPB_AudioInput_Shared::SetStartCaptureState() {
   DCHECK(!capturing_);
   DCHECK(!audio_input_thread_.get());
 
-  // If the socket doesn't exist, that means that the plugin has started before
-  // the browser has had a chance to create all the shared memory info and
-  // notify us. This is a common case. In this case, we just set the capturing_
-  // flag and the capture will automatically start when that data is available
-  // in SetStreamInfo.
   if (audio_input_callback_ && socket_.get())
     StartThread();
   capturing_ = true;
 }
 
 void PPB_AudioInput_Shared::SetStopCaptureState() {
   DCHECK(capturing_);
 
   if (audio_input_thread_.get()) {
     audio_input_thread_->Join();
     audio_input_thread_.reset();
   }
   capturing_ = false;
 }
 
 void PPB_AudioInput_Shared::SetStreamInfo(
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket_handle) {
   socket_.reset(new base::SyncSocket(socket_handle));
   shared_memory_.reset(new base::SharedMemory(shared_memory_handle, false));
   shared_memory_size_ = shared_memory_size;
 
-  if (audio_input_callback_) {
+  if (audio_input_callback_)
     shared_memory_->Map(shared_memory_size_);
 
-    // StartCapture() may be called before SetSreamInfo().
-    if (capturing_)
-      StartThread();
+  // There is a pending capture request before SetStreamInfo().
+  if (capturing_) {
+    // Set |capturing_| to false so that the state looks consistent to
+    // InternalStartCapture(). It will be reset to true by
+    // SetStartCaptureState().
+    capturing_ = false;
+    InternalStartCapture();
   }
 }
 
 void PPB_AudioInput_Shared::StartThread() {
   DCHECK(audio_input_callback_);
   DCHECK(!audio_input_thread_.get());
   audio_input_thread_.reset(new base::DelegateSimpleThread(
       this, "plugin_audio_input_thread"));
   audio_input_thread_->Start();
 }
@@ skipping 31 matching lines @@
 
   config_ = config;
   audio_input_callback_ = audio_input_callback;
   user_data_ = user_data;
 
   return InternalOpen(device_id, enter_config.object()->GetSampleRate(),
                       enter_config.object()->GetSampleFrameCount(), callback);
 }
 
 }  // namespace ppapi