Tab Audio Capture: Browser-side connect/disconnect functionality.

media/audio/audio_output_controller.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_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 119 matching lines @@
 
   if (!stream_->Open()) {
     state_ = kError;
     DoStopCloseAndClearStream(NULL);
 
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
-  // Everything started okay, so register for state change callbacks if we have
-  // not already done so.
-  if (state_ != kRecreating)
-    audio_manager_->AddOutputDeviceChangeListener(this);
+  // Everything started okay, so re-register for state change callbacks (the
+  // call to DoStopCloseAndClearStream() above de-registered this instance).
+  audio_manager_->AddOutputDeviceChangeListener(this);
 
   // We have successfully opened the stream. Set the initial volume.
   stream_->SetVolume(volume_);
 
   // Finally set the state to kCreated.
   State original_state = state_;
   state_ = kCreated;
 
   // And then report we have been created if we haven't done so already.
   if (original_state != kRecreating)
@@ skipping 143 matching lines @@
                                       AudioBuffersState buffers_state) {
   return OnMoreIOData(NULL, dest, buffers_state);
 }
 
 int AudioOutputController::OnMoreIOData(AudioBus* source,
                                         AudioBus* dest,
                                         AudioBuffersState buffers_state) {
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreIOData");
 
   {
-    // Check state and do nothing if we are not playing.
+    // Check state.  When not playing, fill the destination with zeros.
     // We are on the hardware audio thread, so lock is needed.
     base::AutoLock auto_lock(lock_);
     if (state_ != kPlaying) {
-      return 0;
+      dest->Zero();
+      return dest->frames();
     }
   }
 
   int frames = sync_reader_->Read(source, dest);
   sync_reader_->UpdatePendingBytes(
       buffers_state.total_bytes() + frames * params_.GetBytesPerFrame());
   return frames;
 }
 
 void AudioOutputController::WaitTillDataReady() {
@@ skipping 32 matching lines @@
   }
 
   // Should be last in the method, do not touch "this" from here on.
   if (done)
     done->Signal();
 }
 
 void AudioOutputController::OnDeviceChange() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
-  // We should always have a stream by this point.
-  CHECK(stream_);
+  // Preserve the original state.
+  State original_state = state_;
 
-  // Preserve the original state and shutdown the stream.
-  State original_state = state_;
-  stream_->Stop();
-  stream_->Close();
-  stream_ = NULL;
-
-  // Recreate the stream, exit if we ran into an error.
+  // Recreate the stream (DoCreate() will first shut down an existing stream).
+  // Exit if we ran into an error.
   state_ = kRecreating;
   DoCreate();
   if (!stream_ || state_ == kError)
     return;
 
   // Get us back to the original state or an equivalent state.
   switch (original_state) {
     case kStarting:
     case kPlaying:
       DoPlay();
       return;
     case kCreated:
     case kPausedWhenStarting:
     case kPaused:
       // From the outside these three states are equivalent.
       return;
     default:
       NOTREACHED() << "Invalid original state.";
   }
 }
 
+AudioOutputStream::AudioSourceCallback* AudioOutputController::Divert() {
+  // Assumption: AudioRendererHost is calling this method on the IO
+  // BrowserThread.
+  DCHECK(!message_loop_->BelongsToCurrentThread());
+
+  // Block until stream closure is complete because, otherwise, it's possible
+  // for two entities to be pulling audio data at the same time.  In addition,
+  // a side effect of closing the stream is that this controller will be
+  // de-registered from device change events (from AudioManager) during the
+  // "divert."
+  base::WaitableEvent blocker(true, false);
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioOutputController::DoStopCloseAndClearStream, this,
+                 &blocker));
+  blocker.Wait();
+
+  return this;
+}
+
+void AudioOutputController::Revert(
+    AudioOutputStream::AudioSourceCallback* asc) {
+  // Assumption: AudioRendererHost is calling this method on the IO
+  // BrowserThread.
+  DCHECK(!message_loop_->BelongsToCurrentThread());
+
+  DCHECK_EQ(this, asc);
+
+  // The following re-creates the normal audio output stream and places it in
+  // the correct playback state.  It also re-registers this controller for
+  // device change events from AudioManager.
+  message_loop_->PostTask(
+      FROM_HERE, base::Bind(&AudioOutputController::OnDeviceChange, this));
+}
+
 }  // namespace media