Tab Audio Mirroring: WebContentsAudioInputStream is a new implementation which represents the lifet…

media/audio/audio_manager_base.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_manager_base.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/thread.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/audio/virtual_audio_input_stream.h"
@@ skipping 97 matching lines @@
       params.format() == AudioParameters::AUDIO_FAKE ||
       !HasAudioOutputDevices();
 
   AudioOutputStream* stream = NULL;
   if (virtual_audio_input_stream_) {
 #if defined(OS_IOS)
     // We do not currently support iOS. It does not link.
     NOTIMPLEMENTED();
     return NULL;
 #else
-    stream = VirtualAudioOutputStream::MakeStream(this, params, message_loop_,
-        virtual_audio_input_stream_);
+    stream = new VirtualAudioOutputStream(
+        params, message_loop_, virtual_audio_input_stream_,
+        base::Bind(&AudioManagerBase::ReleaseVirtualOutputStream,
+                   base::Unretained(this)));
 #endif
   } else if (audio_output_disabled) {
     stream = FakeAudioOutputStream::MakeFakeStream(this, params);
   } else if (params.format() == AudioParameters::AUDIO_PCM_LINEAR) {
     stream = MakeLinearOutputStream(params);
   } else if (params.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
     stream = MakeLowLatencyOutputStream(params);
   }
 
   if (stream)
@@ skipping 24 matching lines @@
   AudioInputStream* stream = NULL;
   if (params.format() == AudioParameters::AUDIO_VIRTUAL) {
 #if defined(OS_IOS)
     // We do not currently support iOS.
     NOTIMPLEMENTED();
     return NULL;
 #else
     // TODO(justinlin): Currently, audio mirroring will only work for the first
     // request. Subsequent requests will not get audio.
     if (!virtual_audio_input_stream_) {
-      virtual_audio_input_stream_ =
-          VirtualAudioInputStream::MakeStream(this, params, message_loop_);
+      virtual_audio_input_stream_ = new VirtualAudioInputStream(
+          params, message_loop_,
+          base::Bind(&AudioManagerBase::ReleaseVirtualInputStream,
+                     base::Unretained(this)));
       stream = virtual_audio_input_stream_;
       DVLOG(1) << "Virtual audio input stream created.";
 
       // Make all current output streams recreate themselves as
       // VirtualAudioOutputStreams that will attach to the above
       // VirtualAudioInputStream.
       NotifyAllOutputDeviceChangeListeners();
     } else {
       stream = NULL;
     }
@@ skipping 104 matching lines @@
 
 void AudioManagerBase::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
 }
 
 void AudioManagerBase::ReleaseOutputStream(AudioOutputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioOutputStream.
   // For example, pass the ownership to AudioManager so it can delete the
   // streams.
-  num_output_streams_--;
+  --num_output_streams_;
   delete stream;
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
-
-  if (virtual_audio_input_stream_ == stream) {
-    DVLOG(1) << "Virtual audio input stream stopping.";
-    virtual_audio_input_stream_->Stop();
-    virtual_audio_input_stream_ = NULL;
-
-    // Make all VirtualAudioOutputStreams unregister from the
-    // VirtualAudioInputStream and recreate themselves as regular audio streams
-    // to return sound to hardware.
-    NotifyAllOutputDeviceChangeListeners();
-  }
-
-  num_input_streams_--;
+  --num_input_streams_;
   delete stream;
 }
 
+void AudioManagerBase::ReleaseVirtualInputStream(
+    VirtualAudioInputStream* stream) {
+  DCHECK_EQ(virtual_audio_input_stream_, stream);
+
+  virtual_audio_input_stream_ = NULL;
+
+  // Notify listeners to re-create output streams.  This will cause all
+  // outstanding VirtualAudioOutputStreams pointing at the
+  // VirtualAudioInputStream to be closed and destroyed.  Once this has
+  // happened, there will be no other references to the input stream, and it
+  // will then be safe to delete it.
+  NotifyAllOutputDeviceChangeListeners();
+
+  ReleaseInputStream(stream);
+}
+
+void AudioManagerBase::ReleaseVirtualOutputStream(
+    VirtualAudioOutputStream* stream) {
+  ReleaseOutputStream(stream);
+}
+
 void AudioManagerBase::IncreaseActiveInputStreamCount() {
   base::AtomicRefCountInc(&num_active_input_streams_);
 }
 
 void AudioManagerBase::DecreaseActiveInputStreamCount() {
   DCHECK(IsRecordingInProcess());
   base::AtomicRefCountDec(&num_active_input_streams_);
 }
 
 bool AudioManagerBase::IsRecordingInProcess() {
@@ skipping 79 matching lines @@
   output_listeners_.RemoveObserver(listener);
 }
 
 void AudioManagerBase::NotifyAllOutputDeviceChangeListeners() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DVLOG(1) << "Firing OnDeviceChange() notifications.";
   FOR_EACH_OBSERVER(AudioDeviceListener, output_listeners_, OnDeviceChange());
 }
 
 }  // namespace media