Implement disabling and enabling media tracks

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 559 matching lines @@
 
   return pipeline_metadata_.has_video;
 }
 
 bool WebMediaPlayerImpl::hasAudio() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return pipeline_metadata_.has_audio;
 }
 
+using RestartStreamPlaybackCB =
+    base::Callback<void(DemuxerStream*, base::TimeDelta)>;
+
+void OnEnabledAudioTracksChanged(
+    Demuxer* demuxer,
+    base::TimeDelta currentTime,
+    const blink::WebVector<blink::WebMediaPlayer::TrackId>& enabledTrackIds,
+    const RestartStreamPlaybackCB& restart_stream_playback_cb) {
+  DemuxerStream* audio_stream = demuxer->GetStream(DemuxerStream::AUDIO);
+  bool enabled = false;
+  for (const auto& trackId : enabledTrackIds) {
+    const DemuxerStream* s = demuxer->GetDemuxerStreamByTrackId(trackId);
+    CHECK(s);
+    CHECK_EQ(s, audio_stream);
+    enabled = true;
+  }
+
+  DVLOG(1) << __FUNCTION__ << (enabled ? " enabling" : " disabling")
+           << " audio_stream=" << audio_stream
+           << " currentTime=" << currentTime.InSecondsF();
+  bool was_disabled = !audio_stream->enabled();
+  audio_stream->set_enabled(enabled, currentTime);
+  if (enabled && was_disabled) {
+    restart_stream_playback_cb.Run(audio_stream, currentTime);
+  }
+}
+
 void WebMediaPlayerImpl::enabledAudioTracksChanged(
     const blink::WebVector<blink::WebMediaPlayer::TrackId>& enabledTrackIds) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   CHECK(demuxer_.get());
 
-  // TODO(servolk): Implement disabling/enabling audio streams.
+  media_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &OnEnabledAudioTracksChanged, demuxer_.get(),
+          base::TimeDelta::FromSecondsD(currentTime()), enabledTrackIds,
+          BindToCurrentLoop(base::Bind(
+              &WebMediaPlayerImpl::RestartStreamPlayback, AsWeakPtr()))));
+}
+
+void OnSelectedVideoTrackChanged(
+    Demuxer* demuxer,
+    base::TimeDelta currentTime,
+    const std::vector<blink::WebMediaPlayer::TrackId>& selectedTrackIdVector,
+    const RestartStreamPlaybackCB& restart_stream_playback_cb) {
+  DemuxerStream* video_stream = demuxer->GetStream(DemuxerStream::VIDEO);
+  bool enabled = false;
+  if (!selectedTrackIdVector.empty()) {
+    const DemuxerStream* selectedVideoStream =
+        demuxer->GetDemuxerStreamByTrackId(selectedTrackIdVector[0]);
+    CHECK(selectedVideoStream);
+    CHECK_EQ(selectedVideoStream, video_stream);
+    enabled = true;
+  }
+
+  DVLOG(1) << __FUNCTION__ << (enabled ? " enabling" : " disabling")
+           << " video_stream=" << video_stream
+           << " currentTime=" << currentTime.InSecondsF();
+  bool was_disabled = !video_stream->enabled();
+  video_stream->set_enabled(enabled, currentTime);
+  if (enabled && was_disabled) {
+    restart_stream_playback_cb.Run(video_stream, currentTime);
+  }
 }
 
 void WebMediaPlayerImpl::selectedVideoTrackChanged(
     blink::WebMediaPlayer::TrackId* selectedTrackId) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   CHECK(demuxer_.get());
 
-  // TODO(servolk): Implement disabling/enabling video stream.
+  std::vector<blink::WebMediaPlayer::TrackId> selectedTrackIdVector;
+  if (selectedTrackId) {
+    selectedTrackIdVector.push_back(*selectedTrackId);
+  }
+  media_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &OnSelectedVideoTrackChanged, demuxer_.get(),
+          base::TimeDelta::FromSecondsD(currentTime()), selectedTrackIdVector,
+          BindToCurrentLoop(base::Bind(
+              &WebMediaPlayerImpl::RestartStreamPlayback, AsWeakPtr()))));
+}
+
+void WebMediaPlayerImpl::RestartStreamPlayback(DemuxerStream* stream,
+                                               base::TimeDelta time) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  pipeline_.RestartStreamPlayback(stream, time);
 }
 
 blink::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return blink::WebSize(pipeline_metadata_.natural_size);
 }
 
 bool WebMediaPlayerImpl::paused() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 1025 matching lines @@
            << ", Video: " << stats.video_memory_usage << ", DataSource: "
            << (data_source_ ? data_source_->GetMemoryUsage() : 0)
            << ", Demuxer: " << demuxer_memory_usage;
 
   const int64_t delta = current_memory_usage - last_reported_memory_usage_;
   last_reported_memory_usage_ = current_memory_usage;
   adjust_allocated_memory_cb_.Run(delta);
 }
 
 }  // namespace media