Allow muting/unmuting audio through media track API

media/renderers/renderer_impl.cc

 // Copyright 2014 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/renderers/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 187 matching lines @@
   if (old_rate == 0 && playback_rate > 0)
     video_renderer_->OnTimeStateChanged(true);
   else if (old_rate > 0 && playback_rate == 0)
     video_renderer_->OnTimeStateChanged(false);
 }
 
 void RendererImpl::SetVolume(float volume) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
+  audio_volume_ = volume;

[wolenetz, 2016/03/30 00:31:32]

ISTM that this could be more readable and correct if we had something like
"audio output selected" separate from volume for our current
single-audio-track-maximum logic.

Example: 1 audio track enabled.
App disables that audio track.
App then sets volume to 100%.
* What should happen vs what actually happens?
I think something is mismatching at *.

[servolk, 2016/03/30 01:29:49]

That's a very good point. But please keep in mind that the most important point
of this CL was to demonstrate how we can convey media track status changes from
blink all the way to media renderer, where we can handle it. Of course ideally
in the future we want to avoid decoding audio/video at all if the corresponding
media track is disabled/deselected. And this CL provides a foundation for doing
that by delivering the media track/demux stream status notification to the
renderers. Changing renderers to properly support disabling/enabling tracks is
going to be a separate non-trivial CL. One issue that immediately comes to mind
is how can we switch between using audio-based clock and wall clock for driving
video renderer on the flight.

[wolenetz, 2016/03/30 20:08:11]

I think in short-term, while we're still decoding even the (max 1 currently)
audio track in this CL:
1) add a TODO+crbug for tracking the disabling of audio decode (and switching to
wall-clock), and
2) use a separate flag in the audio renderer path that overrides whatever the
app-provided volume is with 0% volume iff the (max 1 currently) audio track is
disabled.

(2), especially, would fix the unexpected behavior where an app could still
cause a "disabled audio track" to render at non-zero volume.

   if (audio_renderer_)
     audio_renderer_->SetVolume(volume);
 }
 
 base::TimeDelta RendererImpl::GetMediaTime() {
   // No BelongsToCurrentThread() checking because this can be called from other
   // threads.
   return time_source_->CurrentMediaTime();
 }
 
 bool RendererImpl::HasAudio() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return audio_renderer_ != NULL;
 }
 
 bool RendererImpl::HasVideo() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return video_renderer_ != NULL;
 }
 
+void RendererImpl::OnEnabledAudioStreamsChanged(
+    const std::vector<const DemuxerStream*>& enabledAudioStreams) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DemuxerStream* audio_stream =
+      demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
+
+  bool audio_stream_enabled = false;
+  for (const DemuxerStream* demuxer_stream : enabledAudioStreams) {
+    DCHECK_EQ(demuxer_stream->type(), DemuxerStream::AUDIO);
+    if (demuxer_stream == audio_stream)
+      audio_stream_enabled = true;
+  }
+
+  if (audio_renderer_) {
+    if (audio_stream_enabled) {
+      DVLOG(5) << __FUNCTION__ << " enabled audio. SetVolume=" << audio_volume_;
+      audio_renderer_->SetVolume(audio_volume_);
+    } else {
+      DVLOG(5) << __FUNCTION__ << " disabled audio. SetVolume=0";
+      audio_renderer_->SetVolume(0);
+    }
+  }
+}
+
+void RendererImpl::OnSelectedVideoStreamChanged(
+    const DemuxerStream* selectedVideoStream) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DemuxerStream* video_stream =
+      demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
+  if (selectedVideoStream) {
+    CHECK_EQ(selectedVideoStream, video_stream);
+  }
+}
+
 void RendererImpl::DisableUnderflowForTesting() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   underflow_disabled_for_testing_ = true;
 }
 
 void RendererImpl::EnableClocklessVideoPlaybackForTesting() {
   DVLOG(1) << __FUNCTION__;
@@ skipping 422 matching lines @@
   }
 
   // After OnError() returns, the pipeline may destroy |this|.
   base::ResetAndReturn(&error_cb_).Run(error);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 }
 
 }  // namespace media