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 11 matching lines @@
 
 // Polling-related constants.
 const int AudioOutputController::kPollNumAttempts = 3;
 const int AudioOutputController::kPollPauseInMilliseconds = 3;
 
 AudioOutputController::AudioOutputController(AudioManager* audio_manager,
                                              EventHandler* handler,
                                              const AudioParameters& params,
                                              SyncReader* sync_reader)
     : audio_manager_(audio_manager),
+      params_(params),
       handler_(handler),
       stream_(NULL),
+      diverting_to_stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
       sync_reader_(sync_reader),
       message_loop_(audio_manager->GetMessageLoop()),
       number_polling_attempts_left_(0),
-      params_(params),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)) {
+  // This thread-checker is only used to ensure calls to StartDiverting() and
+  // StopDiverting() are made by the same single outside thread.
+  divert_thread_checker_.DetachFromThread();
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
 
   if (message_loop_->BelongsToCurrentThread()) {
     DoStopCloseAndClearStream(NULL);
   } else {
     // http://crbug.com/120973
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
@@ skipping 12 matching lines @@
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     SyncReader* sync_reader) {
   DCHECK(audio_manager);
   DCHECK(sync_reader);
 
   if (!params.IsValid() || !audio_manager)
     return NULL;
 
-  // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
       audio_manager, event_handler, params, sync_reader));
-
   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoCreate, controller));
-
   return controller;
 }
 
 void AudioOutputController::Play() {
   DCHECK(message_loop_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoPlay, this));
 }
 
 void AudioOutputController::Pause() {
@@ skipping 23 matching lines @@
 
 void AudioOutputController::DoCreate() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
   DCHECK(state_ == kEmpty || state_ == kRecreating) << state_;
 
   DoStopCloseAndClearStream(NULL);
-  stream_ = audio_manager_->MakeAudioOutputStreamProxy(params_);
+  stream_ = diverting_to_stream_ ? diverting_to_stream_ :
+      audio_manager_->MakeAudioOutputStreamProxy(params_);
   if (!stream_) {
     state_ = kError;
 
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   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)
+  // Everything started okay, so re-register for state change callbacks if
+  // stream_ was created via AudioManager.  Note: The call to
+  // DoStopCloseAndClearStream() above called
+  // RemoveOutputDeviceChangeListener().
+  if (stream_ != diverting_to_stream_)
     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.
@@ skipping 187 matching lines @@
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoReportError, this, code));
 }
 
 void AudioOutputController::DoStopCloseAndClearStream(WaitableEvent* done) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream_ to close.
   if (stream_) {
+    // De-register from state change callbacks if stream_ was created via
+    // AudioManager.
+    if (stream_ != diverting_to_stream_)
+      audio_manager_->RemoveOutputDeviceChangeListener(this);
+
     stream_->Stop();
     stream_->Close();
+    if (stream_ == diverting_to_stream_)
+      diverting_to_stream_ = NULL;
     stream_ = NULL;
 
-    audio_manager_->RemoveOutputDeviceChangeListener(this);
-    audio_manager_ = NULL;
-
     weak_this_.InvalidateWeakPtrs();
   }
 
   // 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 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.
+  const State original_state = state_;
   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.";
   }
 }
 
+void AudioOutputController::StartDiverting(AudioOutputStream* to_stream) {
+  if (!message_loop_->BelongsToCurrentThread()) {

[DaleCurtis, 2013/01/02 21:56:44]

This is still odd and inconsistent with the rest of the file. The thread checker
doesn't add anything either since you're always posting the task.

Instead you should break this up into StartDiverting() and DoStartDiverting()
like the rest of the methods which do the same thing.

[miu, 2013/01/03 22:30:42]

Done.

+    DCHECK(divert_thread_checker_.CalledOnValidThread());
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&AudioOutputController::StartDiverting, this, to_stream));
+    return;
+  }
+
+  DCHECK(!diverting_to_stream_);
+  diverting_to_stream_ = to_stream;
+  DCHECK_NE(kClosed, state_);

[DaleCurtis, 2013/01/02 21:56:44]

Instead of a DHCECK_NE, shouldn't this be an if (state == kClosed) return before
diverting_to_stream_ is set?

[miu, 2013/01/03 22:30:42]

Done.

+  OnDeviceChange();
+}
+
+void AudioOutputController::StopDiverting() {

[DaleCurtis, 2013/01/02 21:56:44]

Ditto.

[miu, 2013/01/03 22:30:42]

Done.

+  if (!message_loop_->BelongsToCurrentThread()) {
+    DCHECK(divert_thread_checker_.CalledOnValidThread());
+    message_loop_->PostTask(
+        FROM_HERE, base::Bind(&AudioOutputController::StopDiverting, this));
+    return;
+  }
+
+  if (state_ != kClosed) {
+    OnDeviceChange();

[DaleCurtis, 2013/01/02 21:56:44]

This needs a comment since it's subtle that OnDeviceChange will automatically
stop diverting when DoStopCloseAndClearStream() occurs w/ divert_to_stream_ ==
stream_.

[miu, 2013/01/03 22:30:42]

Done.

+    DCHECK(!diverting_to_stream_);
+  }
+}
+
 }  // namespace media