Unmute Tab Audio For Desktop Share

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 <stdint.h>
 
 #include <limits>
 
@@ skipping 101 matching lines @@
 
 void AudioOutputController::DoCreate(bool is_for_device_change) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CreateTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoCreate");
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
 
-  DoStopCloseAndClearStream();  // Calls RemoveOutputDeviceChangeListener().
+  // Calls RemoveOutputDeviceChangeListener().
+  DoStopCloseAndClearStream(is_for_device_change);
   DCHECK_EQ(kEmpty, state_);
 
   stream_ = diverting_to_stream_ ?
       diverting_to_stream_ :
       audio_manager_->MakeAudioOutputStreamProxy(params_, output_device_id_);
   if (!stream_) {
     state_ = kError;
     handler_->OnError();
     return;
   }
 
   if (!stream_->Open()) {
-    DoStopCloseAndClearStream();
+    DoStopCloseAndClearStream(false);
     state_ = kError;
     handler_->OnError();
     return;
   }
 
   // Everything started okay, so re-register for state change callbacks if
   // stream_ was created via AudioManager.
   if (stream_ != diverting_to_stream_)
     audio_manager_->AddOutputDeviceChangeListener(this);
 
@@ skipping 16 matching lines @@
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
 
   // Ask for first packet.
   sync_reader_->UpdatePendingBytes(0, 0);
 
   state_ = kPlaying;
 
   stream_->Start(this);
+  for (auto& target : duplicating_targets_)
+    target->Start();
 
   // For UMA tracking purposes, start the wedge detection timer.  This allows us
   // to record statistics about the number of wedged playbacks in the field.
   //
   // WedgeCheck() will look to see if |on_more_io_data_called_| is true after
   // the timeout expires.  Care must be taken to ensure the wedge check delay is
   // large enough that the value isn't queried while OnMoreDataIO() is setting
   // it.
   //
   // Timer self-manages its lifetime and WedgeCheck() will only record the UMA
   // statistic if state is still kPlaying.  Additional Start() calls will
   // invalidate the previous timer.
   wedge_timer_.reset(new base::OneShotTimer());
   wedge_timer_->Start(
       FROM_HERE, TimeDelta::FromSeconds(5), this,
       &AudioOutputController::WedgeCheck);
 
   handler_->OnPlaying();
 }
 
 void AudioOutputController::StopStream() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kPlaying) {
     wedge_timer_.reset();
     stream_->Stop();
 
+    for (auto& target : duplicating_targets_)
+      target->Stop();
+
     // A stopped stream is silent, and power_montior_.Scan() is no longer being
     // called; so we must reset the power monitor.
     power_monitor_.Reset();
 
     state_ = kPaused;
   }
 }
 
 void AudioOutputController::DoPause() {
   DCHECK(message_loop_->BelongsToCurrentThread());
@@ skipping 12 matching lines @@
 
   handler_->OnPaused();
 }
 
 void AudioOutputController::DoClose() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CloseTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoClose");
 
   if (state_ != kClosed) {
-    DoStopCloseAndClearStream();
+    DoStopCloseAndClearStream(false);
     sync_reader_->Close();
     state_ = kClosed;
   }
 }
 
 void AudioOutputController::DoSetVolume(double volume) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Saves the volume to a member first. We may not be able to set the volume
   // right away but when the stream is created we'll set the volume.
@@ skipping 52 matching lines @@
   // thread starts, its safe to compare and then increment.
   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
     base::AtomicRefCountInc(&on_more_io_data_called_);
 
   sync_reader_->Read(dest);
 
   const int frames = dest->frames();
   sync_reader_->UpdatePendingBytes(
       total_bytes_delay + frames * params_.GetBytesPerFrame(), frames_skipped);
 
+  for (auto& target : duplicating_targets_)
+    target->OnData(dest);

[miu, 2016/04/21 00:15:25]

Please pass the delay information here as well, ideally as a TimeTicks (the
Chrome media stack really needs to update the delay values in these interfaces).
 Suggestion:

  const base::TimeTicks reference_time = base::TimeTicks::Now() +
base::TimeDelta::FromMicroseconds(1000000.0 * total_bytes_delay /
params_.GetBytesPerSecond());
  for (VirtualAudioSink* target : duplicating_targets_)
    target->OnData(*dest, reference_time);

[qiangchen, 2016/04/28 00:00:56]

Done.

+
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
 
   return frames;
 }
 
 void AudioOutputController::OnError(AudioOutputStream* stream) {
   {
     base::AutoLock auto_lock(error_lock_);
     if (ignore_errors_during_stop_close_)
       return;
   }
 
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoReportError, this));
 }
 
-void AudioOutputController::DoStopCloseAndClearStream() {
+void AudioOutputController::DoStopCloseAndClearStream(
+    bool is_for_device_change) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream_ to close.
   if (stream_) {
     {
       base::AutoLock auto_lock(error_lock_);
       ignore_errors_during_stop_close_ = true;
     }
 
     // De-register from state change callbacks if stream_ was created via
     // AudioManager.
     if (stream_ != diverting_to_stream_)
       audio_manager_->RemoveOutputDeviceChangeListener(this);
 
     StopStream();
     stream_->Close();
+
+    // Only close duplicating streams when this is really a close class
+    // For device change call, duplicating streams should remain unchanged.
+    if (!is_for_device_change) {
+      for (auto& target : duplicating_targets_)
+        target->Close();
+    }
+
     if (stream_ == diverting_to_stream_)
       diverting_to_stream_ = NULL;
     stream_ = NULL;
 
     // Since the stream is no longer running, no lock is necessary.
     ignore_errors_during_stop_close_ = false;
   }
 
   state_ = kEmpty;
 }
@@ skipping 36 matching lines @@
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&AudioOutputController::DoStartDiverting, this, to_stream));
 }
 
 void AudioOutputController::StopDiverting() {
   message_loop_->PostTask(
       FROM_HERE, base::Bind(&AudioOutputController::DoStopDiverting, this));
 }
 
+void AudioOutputController::StartDuplicating(AudioPushSink* sink) {
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioOutputController::DoStartDuplicating, this, sink));
+}
+
+void AudioOutputController::StopDuplicating(AudioPushSink* sink) {
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioOutputController::DoStopDuplicating, this, sink));
+}
+
 void AudioOutputController::DoStartDiverting(AudioOutputStream* to_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kClosed)
     return;
 
   DCHECK(!diverting_to_stream_);
   diverting_to_stream_ = to_stream;
   // Note: OnDeviceChange() will engage the "re-create" process, which will
   // detect and use the alternate AudioOutputStream rather than create a new one
   // via AudioManager.
   OnDeviceChange();
 }
 
 void AudioOutputController::DoStopDiverting() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kClosed)
     return;
 
   // Note: OnDeviceChange() will cause the existing stream (the consumer of the
   // diverted audio data) to be closed, and diverting_to_stream_ will be set
   // back to NULL.
   OnDeviceChange();
   DCHECK(!diverting_to_stream_);
 }
 
+void AudioOutputController::DoStartDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  if (state_ == kClosed)
+    return;
+
+  // Already serving the stream.
+  if (duplicating_targets_.find(to_stream) != duplicating_targets_.end())
+    return;
+
+  duplicating_targets_.insert(to_stream);
+  if (state_ == kPlaying)
+    to_stream->Start();
+}
+
+void AudioOutputController::DoStopDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  if (state_ == kClosed)
+    return;
+
+  // No such stream.
+  if (duplicating_targets_.find(to_stream) == duplicating_targets_.end())
+    return;
+
+  duplicating_targets_.erase(to_stream);
+  to_stream->Close();
+}
+
 std::pair<float, bool> AudioOutputController::ReadCurrentPowerAndClip() {
   DCHECK(will_monitor_audio_levels());
   return power_monitor_.ReadCurrentPowerAndClip();
 }
 
 void AudioOutputController::WedgeCheck() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media