MediaResource refactoring to support multiple streams

chromecast/media/service/cast_renderer.cc

 // Copyright 2016 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 "chromecast/media/service/cast_renderer.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "chromecast/base/task_runner_impl.h"
 #include "chromecast/media/base/video_mode_switcher.h"
@@ skipping 87 matching lines @@
   // Create pipeline.
   MediaPipelineClient pipeline_client;
   pipeline_client.error_cb =
       base::Bind(&CastRenderer::OnError, weak_factory_.GetWeakPtr());
   pipeline_client.buffering_state_cb = base::Bind(
       &CastRenderer::OnBufferingStateChange, weak_factory_.GetWeakPtr());
   pipeline_.reset(new MediaPipelineImpl());
   pipeline_->SetClient(pipeline_client);
   pipeline_->Initialize(load_type, std::move(backend));
 
+  // TODO(servolk): Implement support for multiple streams. For now use the
+  // first enabled audio and video streams to preserve the existing behavior.
+  ::media::DemuxerStream* audio_stream =
+      media_resource->GetFirstStream(::media::DemuxerStream::AUDIO);
+  ::media::DemuxerStream* video_stream =
+      media_resource->GetFirstStream(::media::DemuxerStream::VIDEO);
+
   // Initialize audio.
-  ::media::DemuxerStream* audio_stream =
-      media_resource->GetStream(::media::DemuxerStream::AUDIO);
   if (audio_stream) {
     AvPipelineClient audio_client;
     audio_client.wait_for_key_cb = base::Bind(
         &CastRenderer::OnWaitingForDecryptionKey, weak_factory_.GetWeakPtr());
     audio_client.eos_cb = base::Bind(&CastRenderer::OnEnded,
                                      weak_factory_.GetWeakPtr(), STREAM_AUDIO);
     audio_client.playback_error_cb =
         base::Bind(&CastRenderer::OnError, weak_factory_.GetWeakPtr());
     audio_client.statistics_cb = base::Bind(&CastRenderer::OnStatisticsUpdate,
                                             weak_factory_.GetWeakPtr());
     std::unique_ptr<CodedFrameProvider> frame_provider(new DemuxerStreamAdapter(
         task_runner_, media_task_runner_factory_, audio_stream));
 
     ::media::PipelineStatus status =
         pipeline_->InitializeAudio(audio_stream->audio_decoder_config(),
                                    audio_client, std::move(frame_provider));
     if (status != ::media::PIPELINE_OK) {
       init_cb.Run(status);
       return;
     }
     audio_stream->EnableBitstreamConverter();
   }
 
   // Initialize video.
-  ::media::DemuxerStream* video_stream =
-      media_resource->GetStream(::media::DemuxerStream::VIDEO);
   if (video_stream) {
     VideoPipelineClient video_client;
     video_client.av_pipeline_client.wait_for_key_cb = base::Bind(
         &CastRenderer::OnWaitingForDecryptionKey, weak_factory_.GetWeakPtr());
     video_client.av_pipeline_client.eos_cb = base::Bind(
         &CastRenderer::OnEnded, weak_factory_.GetWeakPtr(), STREAM_VIDEO);
     video_client.av_pipeline_client.playback_error_cb =
         base::Bind(&CastRenderer::OnError, weak_factory_.GetWeakPtr());
     video_client.av_pipeline_client.statistics_cb = base::Bind(
         &CastRenderer::OnStatisticsUpdate, weak_factory_.GetWeakPtr());
@@ skipping 148 matching lines @@
 }
 
 void CastRenderer::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(opaque);
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media
 }  // namespace chromecast