Merge AssociateStreamWithProducer message into CreateStream message for both audio output and input.

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 31 matching lines @@
 AudioOutputDevice::AudioOutputDevice(
     AudioOutputIPC* ipc,
     const scoped_refptr<base::MessageLoopProxy>& io_loop)
     : ScopedLoopObserver(io_loop),
       callback_(NULL),
       ipc_(ipc),
       state_(IDLE),
       play_on_start_(true),
       stopping_hack_(false) {
   CHECK(ipc_);
-  stream_id_ = ipc_->AddDelegate(this);
 }
 
 void AudioOutputDevice::Initialize(const AudioParameters& params,
                                    RenderCallback* callback) {
   DCHECK(!callback_) << "Calling Initialize() twice?";
   DCHECK(params.IsValid());
   audio_parameters_ = params;
   callback_ = callback;
 }
 
 AudioOutputDevice::~AudioOutputDevice() {
   // The current design requires that the user calls Stop() before deleting
   // this class.
   DCHECK(audio_thread_.IsStopped());
-
-  if (ipc_)
-    ipc_->RemoveDelegate(stream_id_);
 }
 
 void AudioOutputDevice::Start() {
   DCHECK(callback_) << "Initialize hasn't been called";
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioOutputDevice::CreateStreamOnIOThread, this,
                  audio_parameters_));
 }
 
 void AudioOutputDevice::Stop() {
@@ skipping 26 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void AudioOutputDevice::CreateStreamOnIOThread(const AudioParameters& params) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (state_ == IDLE) {
     state_ = CREATING_STREAM;
-    ipc_->CreateStream(stream_id_, params);
+    ipc_->CreateStream(this, params);
   }
 }
 
 void AudioOutputDevice::PlayOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (state_ == PAUSED) {
-    ipc_->PlayStream(stream_id_);
+    ipc_->PlayStream();
     state_ = PLAYING;
     play_on_start_ = false;
   } else {
     play_on_start_ = true;
   }
 }
 
 void AudioOutputDevice::PauseOnIOThread(bool flush) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (state_ == PLAYING) {
-    ipc_->PauseStream(stream_id_);
+    ipc_->PauseStream();
     if (flush)
-      ipc_->FlushStream(stream_id_);
+      ipc_->FlushStream();
     state_ = PAUSED;
   } else {
     // Note that |flush| isn't relevant here since this is the case where
     // the stream is first starting.
   }
   play_on_start_ = false;
 }
 
 void AudioOutputDevice::ShutDownOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Make sure we don't call shutdown more than once.
   if (state_ >= CREATING_STREAM) {
-    ipc_->CloseStream(stream_id_);
+    ipc_->CloseStream();
     state_ = IDLE;
   }
 
   // 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 (state_ >= CREATING_STREAM)
-    ipc_->SetVolume(stream_id_, volume);
+    ipc_->SetVolume(volume);
 }
 
 void AudioOutputDevice::OnStateChanged(AudioOutputIPCDelegate::State state) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
   if (state_ < CREATING_STREAM)
     return;
 
   if (state == AudioOutputIPCDelegate::kError) {
@@ skipping 50 matching lines @@
 
   // We handle the case where Play() and/or Pause() may have been called
   // multiple times before OnStreamCreated() gets called.
   if (play_on_start_)
     PlayOnIOThread();
 }
 
 void AudioOutputDevice::OnIPCClosed() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   state_ = IPC_CLOSED;
-  ipc_ = NULL;

[DaleCurtis, 2013/03/01 00:27:52]

filter_ is destroyed after this is called, so you need to be careful if you're
going to leave ipc_ around. As is, I think this crashes.

[miu, 2013/03/02 00:24:16]

That's why I added the comment in the header file "Only valid when state_ !=
IPC_CLOSED" and I made sure the code is following that.  All said, I will be
doing VERY CAREFUL testing here.  I'm aware how sensitive and exposed this code
is.  ;-)

 }
 
 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.