First step towards moving AudioDevice from content/ to media/audio.

content/renderer/media/audio_input_device.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/media/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 27 matching lines @@
 };
 
 AudioInputDevice::AudioInputDevice(const media::AudioParameters& params,
                                    CaptureCallback* callback,
                                    CaptureEventHandler* event_handler)
     : ScopedLoopObserver(
           ChildProcess::current()->io_message_loop()->message_loop_proxy()),
       audio_parameters_(params),
       callback_(callback),
       event_handler_(event_handler),
-      volume_(1.0),
       stream_id_(0),
       session_id_(0),
       pending_device_ready_(false),
       agc_is_enabled_(false) {
-  filter_ = RenderThreadImpl::current()->audio_input_message_filter();
+  // TODO(tommi): This needs to be updated to match AudioDevice.
+  ipc_ = RenderThreadImpl::current()->audio_input_message_filter();
 }
 
 void AudioInputDevice::SetDevice(int session_id) {
   DVLOG(1) << "SetDevice (session_id=" << session_id << ")";
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::SetSessionIdOnIOThread, this, session_id));
 }
 
 void AudioInputDevice::Start() {
   DVLOG(1) << "Start()";
@@ skipping 62 matching lines @@
   audio_thread_.Start(audio_callback_.get(), socket_handle, "AudioInputDevice");
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::StartOnIOThread, this));
 }
 
 void AudioInputDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
-void AudioInputDevice::OnStateChanged(AudioStreamState state) {
+void AudioInputDevice::OnStateChanged(
+    media::AudioInputDeviceIPCDelegate::State state) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
   if (!stream_id_)
     return;
 
   switch (state) {
-    // TODO(xians): This should really be kAudioStreamStopped since the stream
-    // has been closed at this point.
-    case kAudioStreamPaused:
+    case media::AudioInputDeviceIPCDelegate::kStopped:
       // TODO(xians): Should we just call ShutDownOnIOThread here instead?
-      filter_->RemoveDelegate(stream_id_);
+      ipc_->RemoveDelegate(stream_id_);
 
       audio_thread_.Stop(MessageLoop::current());
       audio_callback_.reset();
 
       if (event_handler_)
         event_handler_->OnDeviceStopped();
 
       stream_id_ = 0;
       pending_device_ready_ = false;
       break;
-    case kAudioStreamPlaying:
+    case media::AudioInputDeviceIPCDelegate::kRecording:
       NOTIMPLEMENTED();
       break;
-    case kAudioStreamError:
+    case media::AudioInputDeviceIPCDelegate::kError:
       DLOG(WARNING) << "AudioInputDevice::OnStateChanged(kError)";
       // Don't dereference the callback object if the audio thread
       // is stopped or stopping.  That could mean that the callback
       // object has been deleted.
       // TODO(tommi): Add an explicit contract for clearing the callback
       // object.  Possibly require calling Initialize again or provide
       // a callback object via Start() and clear it in Stop().
       if (!audio_thread_.IsStopped())
         callback_->OnCaptureError();
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AudioInputDevice::OnDeviceReady(const std::string& device_id) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   DVLOG(1) << "OnDeviceReady (device_id=" << device_id << ")";
 
   // Takes care of the case when Stop() is called before OnDeviceReady().
   if (!pending_device_ready_)
     return;
 
   // If AudioInputDeviceManager returns an empty string, it means no device
   // is ready for start.
   if (device_id.empty()) {
-    filter_->RemoveDelegate(stream_id_);
+    ipc_->RemoveDelegate(stream_id_);
     stream_id_ = 0;
   } else {
-    Send(new AudioInputHostMsg_CreateStream(stream_id_, audio_parameters_,
-                                            device_id, agc_is_enabled_));
+    ipc_->CreateStream(stream_id_, audio_parameters_, device_id,
+        agc_is_enabled_);

[scherkus (not reviewing), 2012/07/24 17:57:48]

indenting

[tommi (sloooow) - chröme, 2012/07/25 13:46:17]

Done.

   }
 
   pending_device_ready_ = false;
   // Notify the client that the device has been started.
   if (event_handler_)
     event_handler_->OnDeviceStarted(device_id);
 }
 
+void AudioInputDevice::OnIPCClosed() {
+  ipc_ = NULL;

[scherkus (not reviewing), 2012/07/24 17:57:48]

FYI we seem to guard against calling ipc_ with stream_id_ -- this may lead to
null deref

[tommi (sloooow) - chröme, 2012/07/25 13:46:17]

The stream_id_ checks are not really meant to guard the ipc_ variable.  Some
checks are for if (stream_id_), others if (!stream_id_) and in some places
there's no check.  I see your point though and I have thought about it.  In
practice, the audio message filter always outlives the audio devices, but I
intentionally added this callback to force a NULL crash in case we make a
mistake (and not accessing deleted memory).

+}
+
 AudioInputDevice::~AudioInputDevice() {
   // TODO(henrika): The current design requires that the user calls
   // Stop before deleting this class.
   CHECK_EQ(0, stream_id_);
 }
 
 void AudioInputDevice::InitializeOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   // Make sure we don't call Start() more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
-  stream_id_ = filter_->AddDelegate(this);
+  stream_id_ = ipc_->AddDelegate(this);
   // If |session_id_| is not specified, it will directly create the stream;
   // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
   // and create the stream when getting a OnDeviceReady() callback.
   if (!session_id_) {
-    Send(new AudioInputHostMsg_CreateStream(
-        stream_id_, audio_parameters_,
-        media::AudioManagerBase::kDefaultDeviceId,
-        agc_is_enabled_));
+    ipc_->CreateStream(stream_id_, audio_parameters_,
+        media::AudioManagerBase::kDefaultDeviceId, agc_is_enabled_);
   } else {
-    Send(new AudioInputHostMsg_StartDevice(stream_id_, session_id_));
+    ipc_->StartDevice(stream_id_, session_id_);
     pending_device_ready_ = true;
   }
 }
 
 void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   session_id_ = session_id;
 }
 
 void AudioInputDevice::StartOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
-    Send(new AudioInputHostMsg_RecordStream(stream_id_));
+    ipc_->RecordStream(stream_id_);
 }
 
 void AudioInputDevice::ShutDownOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   // NOTE: |completion| may be NULL.
   // Make sure we don't call shutdown more than once.
   if (stream_id_) {
-    filter_->RemoveDelegate(stream_id_);
-    Send(new AudioInputHostMsg_CloseStream(stream_id_));
+    ipc_->CloseStream(stream_id_);
+    ipc_->RemoveDelegate(stream_id_);
 
     stream_id_ = 0;
     session_id_ = 0;
     pending_device_ready_ = false;
     agc_is_enabled_ = false;
   }
 
   // We can run into an issue where ShutDownOnIOThread is called right after
   // OnStreamCreated is called in cases where Start/Stop are called before we
   // get the OnStreamCreated callback.  To handle that corner case, we call
   // Stop(). In most cases, the thread will already be stopped.
   // Another situation is when the IO thread goes away before Stop() is called
   // in which case, we cannot use the message loop to close the thread handle
   // and can't not rely on the main thread existing either.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   audio_thread_.Stop(NULL);
   audio_callback_.reset();
 }
 
 void AudioInputDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
-    Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
+    ipc_->SetVolume(stream_id_, volume);
 }
 
 void AudioInputDevice::SetAutomaticGainControlOnIOThread(bool enabled) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   DCHECK_EQ(0, stream_id_) <<
       "The AGC state can not be modified while capturing is active.";
   if (stream_id_)
     return;
 
   // We simply store the new AGC setting here. This value will be used when
   // a new stream is initialized and by GetAutomaticGainControl().
   agc_is_enabled_ = enabled;
 }
 
-void AudioInputDevice::Send(IPC::Message* message) {
-  filter_->Send(message);
-}
-
 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the input device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioInputDevice::AudioThreadCallback
 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
     const media::AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
@@ skipping 34 matching lines @@
                                     channel_index,
                                     bytes_per_sample,
                                     number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   capture_callback_->Capture(audio_data_, number_of_frames,
                              audio_delay_milliseconds, volume);
 }