Associate audio streams with their source/destination RenderView.

media/audio/audio_output_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 "media/audio/audio_output_device.h"
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 28 matching lines @@
   scoped_ptr<AudioBus> output_bus_;
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioOutputDevice::AudioOutputDevice(
     AudioOutputIPC* ipc,
     const scoped_refptr<base::MessageLoopProxy>& io_loop)
     : ScopedLoopObserver(io_loop),
       input_channels_(0),
       callback_(NULL),
-      ipc_(ipc),
-      stream_id_(0),
+      stream_id_(-1),
+      state_(kIpcClosed),
       play_on_start_(true),
-      is_started_(false),
       stopping_hack_(false) {
-  CHECK(ipc_);
+  CHECK(ipc);
+  message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AudioOutputDevice::RegisterDelegateOnIOThread, this, ipc));
+}
+
+void AudioOutputDevice::RegisterDelegateOnIOThread(AudioOutputIPC* ipc) {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  DCHECK_EQ(kIpcClosed, state_);
+  ipc_ = ipc->AsWeakPtr();
+  stream_id_ = ipc_ ? ipc_->AddDelegate(this) : 0;
+  if (stream_id_ > 0)
+    state_ = kIdle;
+}
+
+int AudioOutputDevice::stream_id() const {
+  DCHECK_LE(0, stream_id_) << "Call to stream_id() before being initialized.";
+  return stream_id_;
 }
 
 void AudioOutputDevice::Initialize(const AudioParameters& params,
                                    RenderCallback* callback) {
-  CHECK_EQ(0, stream_id_) <<
-      "AudioOutputDevice::Initialize() must be called before Start()";
-
-  CHECK(!callback_);  // Calling Initialize() twice?
-
+  DCHECK(!callback_) << "Calling Initialize() twice?";
   audio_parameters_ = params;
   callback_ = callback;
 }
 
 void AudioOutputDevice::InitializeIO(const AudioParameters& params,
                                      int input_channels,
                                      RenderCallback* callback) {
   DCHECK_GE(input_channels, 0);
   DCHECK_LT(input_channels, limits::kMaxChannels);
   input_channels_ = input_channels;
   Initialize(params, callback);
 }
 
 AudioOutputDevice::~AudioOutputDevice() {
-  // The current design requires that the user calls Stop() before deleting
-  // this class.
-  CHECK_EQ(0, stream_id_);
+  message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AudioOutputIPC::RemoveDelegate, ipc_, stream_id_));
 }
 
 void AudioOutputDevice::Start() {
   DCHECK(callback_) << "Initialize hasn't been called";
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioOutputDevice::CreateStreamOnIOThread, this,
                  audio_parameters_, input_channels_));
 }
 
 void AudioOutputDevice::Stop() {
@@ skipping 25 matching lines @@
           base::Bind(&AudioOutputDevice::SetVolumeOnIOThread, this, volume))) {
     return false;
   }
 
   return true;
 }
 
 void AudioOutputDevice::CreateStreamOnIOThread(const AudioParameters& params,
                                                int input_channels) {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  // Make sure we don't create the stream more than once.
-  DCHECK_EQ(0, stream_id_);
-  if (stream_id_)
-    return;
-
-  stream_id_ = ipc_->AddDelegate(this);
-  ipc_->CreateStream(stream_id_, params, input_channels);
+  if (state_ == kIdle && ipc_) {
+    state_ = kCreatingStream;
+    ipc_->CreateStream(stream_id_, params, input_channels);
+  }
 }
 
 void AudioOutputDevice::PlayOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_ && is_started_)
+  if (state_ == kPaused && ipc_) {
     ipc_->PlayStream(stream_id_);
-  else
+    state_ = kPlaying;
+    play_on_start_ = false;
+  } else {
     play_on_start_ = true;
+  }
 }
 
 void AudioOutputDevice::PauseOnIOThread(bool flush) {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_ && is_started_) {
-    ipc_->PauseStream(stream_id_);
-    if (flush)
-      ipc_->FlushStream(stream_id_);
+  if (state_ == kPlaying) {
+    if (ipc_) {
+      ipc_->PauseStream(stream_id_);
+      if (flush)
+        ipc_->FlushStream(stream_id_);
+    }
+    state_ = kPaused;
   } else {
     // Note that |flush| isn't relevant here since this is the case where
     // the stream is first starting.
-    play_on_start_ = false;
   }
+  play_on_start_ = false;
 }
 
 void AudioOutputDevice::ShutDownOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Make sure we don't call shutdown more than once.
-  if (stream_id_) {
-    is_started_ = false;
-
-    if (ipc_) {
+  if (state_ >= kCreatingStream) {
+    if (ipc_)
       ipc_->CloseStream(stream_id_);
-      ipc_->RemoveDelegate(stream_id_);
-    }
-
-    stream_id_ = 0;
+    state_ = kIdle;
   }
 
   // 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 rely on the main thread existing either.
   base::AutoLock auto_lock_(audio_thread_lock_);
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   audio_thread_.Stop(NULL);
   audio_callback_.reset();
   stopping_hack_ = false;
 }
 
 void AudioOutputDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_)
+  if (state_ >= kPaused && ipc_)
     ipc_->SetVolume(stream_id_, volume);
 }
 
 void AudioOutputDevice::OnStateChanged(AudioOutputIPCDelegate::State state) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
-  if (!stream_id_)
+  if (state_ < kCreatingStream)
     return;
 
   if (state == AudioOutputIPCDelegate::kError) {
     DLOG(WARNING) << "AudioOutputDevice::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_->OnRenderError();
   }
 }
 
 void AudioOutputDevice::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     int length) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
 
-  // We should only get this callback if stream_id_ is valid.  If it is not,
-  // the IPC layer should have closed the shared memory and socket handles
-  // for us and not invoked the callback.  The basic assertion is that when
-  // stream_id_ is 0 the AudioOutputDevice instance is not registered as a
-  // delegate and hence it should not receive callbacks.
-  DCHECK(stream_id_);
+  if (state_ != kCreatingStream)
+    return;
 
   // We can receive OnStreamCreated() on the IO thread after the client has
   // called Stop() but before ShutDownOnIOThread() is processed. In such a
   // situation |callback_| might point to freed memory. Instead of starting
   // |audio_thread_| do nothing and wait for ShutDownOnIOThread() to get called.
   //
   // TODO(scherkus): The real fix is to have sane ownership semantics. The fact
   // that |callback_| (which should own and outlive this object!) can point to
   // freed memory is a mess. AudioRendererSink should be non-refcounted so that
   // owners (WebRtcAudioDeviceImpl, AudioRendererImpl, etc...) can Stop() and
   // delete as they see fit. AudioOutputDevice should internally use WeakPtr
   // to handle teardown and thread hopping. See http://crbug.com/151051 for
   // details.
   base::AutoLock auto_lock(audio_thread_lock_);
   if (stopping_hack_)
     return;
 
   DCHECK(audio_thread_.IsStopped());
   audio_callback_.reset(new AudioOutputDevice::AudioThreadCallback(
       audio_parameters_, input_channels_, handle, length, callback_));
   audio_thread_.Start(audio_callback_.get(), socket_handle,
       "AudioOutputDevice");
+  state_ = kPaused;
 
   // We handle the case where Play() and/or Pause() may have been called
   // multiple times before OnStreamCreated() gets called.
-  is_started_ = true;
   if (play_on_start_)
     PlayOnIOThread();
 }
 
 void AudioOutputDevice::OnIPCClosed() {
-  ipc_ = NULL;
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  state_ = kIpcClosed;
+  ipc_.reset();
 }
 
 void AudioOutputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the audio device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioOutputDevice::AudioThreadCallback
 
 AudioOutputDevice::AudioThreadCallback::AudioThreadCallback(
@@ skipping 69 matching lines @@
   // TODO(dalecurtis): Technically this is not always correct.  Due to channel
   // padding for alignment, there may be more data available than this.  We're
   // relying on AudioSyncReader::Read() to parse this with that in mind.  Rename
   // these methods to Set/GetActualFrameCount().
   SetActualDataSizeInBytes(
       &shared_memory_, memory_length_,
       num_frames * sizeof(*output_bus_->channel(0)) * output_bus_->channels());
 }
 
 }  // namespace media.