refactor AudioInputDevice to remove race condition.

content/renderer/media/audio_input_device.cc

 // 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 "content/renderer/media/audio_input_device.h"
 
-#include "base/message_loop.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread.h"
+#include "content/renderer/media/audio_input_device_event_handler.h"
 #include "media/audio/audio_util.h"
 
 AudioInputDevice::AudioInputDevice(size_t buffer_size,
                                    int channels,
                                    double sample_rate,
+                                   base::MessageLoopProxy* message_loop_proxy,
+                                   AudioInputDeviceEventHandler* handler,
                                    CaptureCallback* callback)
     : buffer_size_(buffer_size),
       channels_(channels),
       bits_per_sample_(16),
       sample_rate_(sample_rate),
       callback_(callback),
+      event_handler_(handler),
       audio_delay_milliseconds_(0),
       volume_(1.0),
+      capture_message_loop_proxy_(message_loop_proxy),
+      state_(kStopped),
       stream_id_(0) {
+  DCHECK(handler);
   filter_ = RenderThread::current()->audio_input_message_filter();
   audio_data_.reserve(channels);
   for (int i = 0; i < channels; ++i) {
     float* channel_data = new float[buffer_size];
     audio_data_.push_back(channel_data);
   }
 }
 
 AudioInputDevice::~AudioInputDevice() {
-  // Make sure we have been shut down.
-  DCHECK_EQ(0, stream_id_);
-  Stop();
   for (int i = 0; i < channels_; ++i)
     delete [] audio_data_[i];
 }
 
 bool AudioInputDevice::Start() {
-  // Make sure we don't call Start() more than once.
-  DCHECK_EQ(0, stream_id_);
-  if (stream_id_)
-    return false;
-
-  AudioParameters params;
-  // TODO(henrika): add support for low-latency mode?
-  params.format = AudioParameters::AUDIO_PCM_LINEAR;
-  params.channels = channels_;
-  params.sample_rate = static_cast<int>(sample_rate_);
-  params.bits_per_sample = bits_per_sample_;
-  params.samples_per_packet = buffer_size_;
-
-  ChildProcess::current()->io_message_loop()->PostTask(
-    FROM_HERE,
-    NewRunnableMethod(this, &AudioInputDevice::InitializeOnIOThread, params));
-
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioInputDevice::StartOnCaptureThread));
   return true;
 }
 
 bool AudioInputDevice::Stop() {
-  if (!stream_id_)
-    return false;
-
-  ChildProcess::current()->io_message_loop()->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &AudioInputDevice::ShutDownOnIOThread));
-
-  if (audio_thread_.get()) {
-    socket_->Close();
-    audio_thread_->Join();
-  }
-
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioInputDevice::StopOnCaptureThread));
   return true;
 }
 
 bool AudioInputDevice::SetVolume(double volume) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool AudioInputDevice::GetVolume(double* volume) {
   NOTIMPLEMENTED();
   return false;
 }
 
-void AudioInputDevice::InitializeOnIOThread(const AudioParameters& params) {
-  stream_id_ = filter_->AddDelegate(this);
+void AudioInputDevice::StartOnCaptureThread() {
+  // Client should call Start() after fully stopped.
+  DCHECK_NE(state_, kStopping);
+  // Make sure we don't call Start() more than once.
+  if (state_ == kStarting || state_ == kStarted)
+    return;
+
+  state_ = kStarting;
+  ChildProcess::current()->io_message_loop_proxy()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioInputDevice::AddDelegateOnIOThread));
+}
+
+void AudioInputDevice::OnDelegateAddedOnCaptureThread(int32 stream_id) {
+  stream_id_ = stream_id;
+
+  // Got Stop() during starting.
+  if (state_ == kStopping) {
+    event_handler_->OnRecordingStarted();
+    ChildProcess::current()->io_message_loop_proxy()->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &AudioInputDevice::RemoveDelegateOnIOThread,
+                          stream_id_));
+    stream_id_ = 0;
+    return;
+  }
+
+  AudioParameters params;
+  // TODO(henrika): add support for low-latency mode?
+  params.format = AudioParameters::AUDIO_PCM_LINEAR;
+  params.channels = channels_;
+  params.sample_rate = static_cast<int>(sample_rate_);
+  params.bits_per_sample = bits_per_sample_;
+  params.samples_per_packet = buffer_size_;
+
   Send(new AudioInputHostMsg_CreateStream(stream_id_, params, true));
 }
 
-void AudioInputDevice::StartOnIOThread() {
-  if (stream_id_)
-    Send(new AudioInputHostMsg_RecordStream(stream_id_));
-}
-
-void AudioInputDevice::ShutDownOnIOThread() {
-  // Make sure we don't call shutdown more than once.
-  if (!stream_id_)
-    return;
-
-  filter_->RemoveDelegate(stream_id_);
-  Send(new AudioInputHostMsg_CloseStream(stream_id_));
-  stream_id_ = 0;
-}
-
-void AudioInputDevice::SetVolumeOnIOThread(double volume) {
-  if (stream_id_)
-    Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
-}
-
-void AudioInputDevice::OnLowLatencyCreated(
+void AudioInputDevice::StartRecordingOnCaptureThread(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
-  DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
   DCHECK(length);
 
+  // Got Stop() during starting.
+  if (state_ == kStopping) {
+    base::SharedMemory::CloseHandle(handle);
+    base::SyncSocket socket(socket_handle);
+    event_handler_->OnRecordingStarted();
+    ChildProcess::current()->io_message_loop_proxy()->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &AudioInputDevice::RemoveDelegateOnIOThread,
+                          stream_id_));
+    return;
+  }
+
   shared_memory_.reset(new base::SharedMemory(handle, false));
   shared_memory_->Map(length);
 
   socket_.reset(new base::SyncSocket(socket_handle));
 
   audio_thread_.reset(
-      new base::DelegateSimpleThread(this, "renderer_audio_input_thread"));
+      new base::DelegateSimpleThread(this, "RendererAudioInputThread"));
   audio_thread_->Start();
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &AudioInputDevice::StartOnIOThread));
+  Send(new AudioInputHostMsg_RecordStream(stream_id_));
+  state_ = kStarted;
+  event_handler_->OnRecordingStarted();
+}
+
+void AudioInputDevice::StopOnCaptureThread() {
+  // Make sure we don't call shutdown more than once.
+  if (state_ == kStopping || state_ == kStopped)
+    return;
+
+  // Got Stop() during starting.
+  if (state_ == kStarting) {
+    state_ = kStopping;
+    return;
+  }
+
+  ChildProcess::current()->io_message_loop_proxy()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioInputDevice::RemoveDelegateOnIOThread,
+                        stream_id_));
+}
+
+void AudioInputDevice::OnDelegateRemovedOnCaptureThread() {
+  if (stream_id_) {
+    Send(new AudioInputHostMsg_CloseStream(stream_id_));
+    stream_id_ = 0;
+  }
+
+  if (audio_thread_.get()) {
+    socket_->Close();
+    audio_thread_->Join();
+    audio_thread_.reset(NULL);
+  }
+
+  state_ = kStopped;
+  event_handler_->OnRecordingStopped();
+}
+
+
+void AudioInputDevice::SetVolumeOnCaptureThread(double volume) {
+  if (stream_id_)
+    Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
+}
+
+void AudioInputDevice::OnLowLatencyCreated(
+    base::SharedMemoryHandle handle,
+    base::SyncSocket::Handle socket_handle,
+    uint32 length) {
+  DCHECK(ChildProcess::current()->io_message_loop_proxy()->
+         BelongsToCurrentThread());
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioInputDevice::StartRecordingOnCaptureThread,
+                        handle, socket_handle, length));
 }
 
 void AudioInputDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
 void AudioInputDevice::Send(IPC::Message* message) {
-  filter_->Send(message);
+  ChildProcess::current()->io_message_loop_proxy()->PostTask(FROM_HERE,
+      NewRunnableMethod(filter_.get(),
+                        &AudioInputMessageFilter::Send, message));
 }
 
 // Our audio thread runs here. We receive captured audio samples on
 // this thread.
 void AudioInputDevice::Run() {
   audio_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   int pending_data;
   const int samples_per_ms = static_cast<int>(sample_rate_) / 1000;
   const int bytes_per_ms = channels_ * (bits_per_sample_ / 8) * samples_per_ms;
@@ skipping 32 matching lines @@
                                     bytes_per_sample,
                                     number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   callback_->Capture(audio_data_,
                      number_of_frames,
                      audio_delay_milliseconds_);
 }
+
+void AudioInputDevice::AddDelegateOnIOThread() {
+  int32 stream_id = filter_->AddDelegate(this);
+  VLOG(1) << "add stream_id = " << stream_id;
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioInputDevice::OnDelegateAddedOnCaptureThread,
+                        stream_id));
+}
+
+void AudioInputDevice::RemoveDelegateOnIOThread(int32 stream_id) {
+  filter_->RemoveDelegate(stream_id);
+  VLOG(1) << "remove stream_id = " << stream_id;
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      NewRunnableMethod(this,
+                        &AudioInputDevice::OnDelegateRemovedOnCaptureThread));
+}