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 75 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);
 
+  const int64_t kMicrosecondsPerSecond = 1000000;

[miu, 2016/05/02 20:06:13]

Delete this line, and just use base::Time::kMicrosecondsPerSecond.

[qiangchen, 2016/05/03 16:58:23]

Done.

+  const base::TimeTicks reference_time =

[miu, 2016/05/02 20:06:13]

Please wrap all these lines of code to avoid the call to TimeTicks::Now() when
there are no duplication targets (the typical case):

  if (!duplicating_targets_.empty()) {
    ...
  }

[qiangchen, 2016/05/03 16:58:23]

Done.

+      base::TimeTicks::Now() + base::TimeDelta::FromMicroseconds(
+                                   kMicrosecondsPerSecond * total_bytes_delay /
+                                   params_.GetBytesPerSecond());
+  for (auto& target : duplicating_targets_)

[miu, 2016/05/02 20:06:13]

The "auto&" doesn't help readability here. Please use "AudioPushSink*" instead.

[qiangchen, 2016/05/03 16:58:23]

Done.

+    target->OnData(*dest, reference_time);
+
   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) {

[miu, 2016/05/02 20:06:13]

Looks like you don't need this at all. Let the guaranteed call to
StopDuplicating() guarantee that they will eventually be closed.

[qiangchen, 2016/05/03 16:58:23]

Done.

+      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);
+}
+
+void AudioOutputController::DoStopDuplicating(AudioPushSink* to_stream) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+
+  if (state_ == kClosed)
+    return;

[miu, 2016/05/02 20:06:13]

You should probably still call to_stream->Close() here. Otherwise, how will
|to_stream| ever be closed/destroyed? Suggestion:

  to_stream->Close();

  if (state_ == kClosed)
    return;

  // Note: no need to check whether |to_stream| is actually in the set.
  duplicating_targets_.erase(to_stream);

[qiangchen, 2016/05/03 16:58:23]

Done.

+
+  // 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