MediaResource refactoring to support multiple streams

media/remoting/remote_renderer_impl.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 "media/remoting/remote_renderer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_math.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/base/bind_to_current_loop.h"
-#include "media/base/demuxer_stream_provider.h"
+#include "media/base/media_resource.h"
 #include "media/remoting/remote_demuxer_stream_adapter.h"
 #include "media/remoting/remoting_renderer_controller.h"
 #include "media/remoting/rpc/proto_enum_utils.h"
 #include "media/remoting/rpc/proto_utils.h"
 
 namespace {
 
 // The moving time window to track the media time and statistics updates.
 constexpr base::TimeDelta kTrackingWindow = base::TimeDelta::FromSeconds(5);
 
@@ skipping 24 matching lines @@
 namespace media {
 
 RemoteRendererImpl::RemoteRendererImpl(
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     const base::WeakPtr<RemotingRendererController>&
         remoting_renderer_controller,
     VideoRendererSink* video_renderer_sink)
     : state_(STATE_UNINITIALIZED),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_task_runner_(std::move(media_task_runner)),
-      demuxer_stream_provider_(nullptr),
+      media_resource_(nullptr),
       client_(nullptr),
       remoting_renderer_controller_(remoting_renderer_controller),
       rpc_broker_(remoting_renderer_controller_->GetRpcBroker()),
       rpc_handle_(rpc_broker_->GetUniqueHandle()),
       remote_renderer_handle_(remoting::kInvalidHandle),
       video_renderer_sink_(video_renderer_sink),
       weak_factory_(this) {
   VLOG(2) << __func__;
   // The constructor is running on the main thread.
   DCHECK(remoting_renderer_controller_);
@@ skipping 21 matching lines @@
                  remoting_renderer_controller_,
                  RemotingRendererController::ShowInterstitialCallback()));
 
   // Post task on main thread to unregister message receiver.
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&remoting::RpcBroker::UnregisterMessageReceiverCallback,
                  rpc_broker_, rpc_handle_));
 }
 
-void RemoteRendererImpl::Initialize(
-    DemuxerStreamProvider* demuxer_stream_provider,
-    media::RendererClient* client,
-    const PipelineStatusCB& init_cb) {
+void RemoteRendererImpl::Initialize(MediaResource* media_resource,
+                                    media::RendererClient* client,
+                                    const PipelineStatusCB& init_cb) {
   VLOG(2) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
-  DCHECK(demuxer_stream_provider);
+  DCHECK(media_resource);
   DCHECK(client);
 
   if (state_ != STATE_UNINITIALIZED) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(init_cb, PIPELINE_ERROR_INVALID_STATE));
     return;
   }
 
-  demuxer_stream_provider_ = demuxer_stream_provider;
+  media_resource_ = media_resource;
   client_ = client;
   init_workflow_done_callback_ = init_cb;
 
   state_ = STATE_CREATE_PIPE;
+
+  std::vector<::media::DemuxerStream*> streams = media_resource_->GetStreams();
+  ::media::DemuxerStream* audio_demuxer_stream = nullptr;
+  ::media::DemuxerStream* video_demuxer_stream = nullptr;
+  for (const auto& s : streams) {
+    if (s->type() == DemuxerStream::AUDIO && s->enabled() &&
+        !audio_demuxer_stream)
+      audio_demuxer_stream = s;
+    if (s->type() == DemuxerStream::VIDEO && s->enabled() &&
+        !video_demuxer_stream)
+      video_demuxer_stream = s;
+  }
+
   // Create audio mojo data pipe handles if audio is available.
-  ::media::DemuxerStream* audio_demuxer_stream =
-      demuxer_stream_provider_->GetStream(::media::DemuxerStream::AUDIO);
   std::unique_ptr<mojo::DataPipe> audio_data_pipe;
   if (audio_demuxer_stream) {
     audio_data_pipe = base::WrapUnique(remoting::CreateDataPipe());
   }
 
   // Create video mojo data pipe handles if video is available.
-  ::media::DemuxerStream* video_demuxer_stream =
-      demuxer_stream_provider_->GetStream(::media::DemuxerStream::VIDEO);
   std::unique_ptr<mojo::DataPipe> video_data_pipe;
   if (video_demuxer_stream) {
     video_data_pipe = base::WrapUnique(remoting::CreateDataPipe());
   }
 
   // Establish remoting data pipe connection using main thread.
   const RemotingSourceImpl::DataPipeStartCallback data_pipe_callback =
       base::Bind(&RemoteRendererImpl::OnDataPipeCreatedOnMainThread,
                  media_task_runner_, weak_factory_.GetWeakPtr(), rpc_broker_);
   main_task_runner_->PostTask(
@@ skipping 170 matching lines @@
     int audio_rpc_handle,
     int video_rpc_handle) {
   VLOG(2) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(!init_workflow_done_callback_.is_null());
 
   if (state_ == STATE_ERROR)
     return;  // Abort because something went wrong in the meantime.
   DCHECK_EQ(state_, STATE_CREATE_PIPE);
 
+  // TODO(erickung): Make remote renderer multi-stream capable.
+  std::vector<::media::DemuxerStream*> streams = media_resource_->GetStreams();
+  ::media::DemuxerStream* audio_demuxer_stream = nullptr;
+  ::media::DemuxerStream* video_demuxer_stream = nullptr;
+  for (const auto& s : streams) {
+    if (s->type() == DemuxerStream::AUDIO && s->enabled() &&
+        !audio_demuxer_stream)
+      audio_demuxer_stream = s;
+    if (s->type() == DemuxerStream::VIDEO && s->enabled() &&
+        !video_demuxer_stream)
+      video_demuxer_stream = s;
+  }
+
   // Create audio demuxer stream adapter if audio is available.
-  ::media::DemuxerStream* audio_demuxer_stream =
-      demuxer_stream_provider_->GetStream(::media::DemuxerStream::AUDIO);
   if (audio_demuxer_stream && audio.is_valid() && audio_handle.is_valid() &&
       audio_rpc_handle != remoting::kInvalidHandle) {
     VLOG(2) << "Initialize audio";
     audio_demuxer_stream_adapter_.reset(
         new remoting::RemoteDemuxerStreamAdapter(
             main_task_runner_, media_task_runner_, "audio",
             audio_demuxer_stream, rpc_broker_, audio_rpc_handle,
             std::move(audio), std::move(audio_handle),
             base::Bind(&RemoteRendererImpl::OnFatalError,
                        base::Unretained(this))));
   }
 
   // Create video demuxer stream adapter if video is available.
-  ::media::DemuxerStream* video_demuxer_stream =
-      demuxer_stream_provider_->GetStream(::media::DemuxerStream::VIDEO);
   if (video_demuxer_stream && video.is_valid() && video_handle.is_valid() &&
       video_rpc_handle != remoting::kInvalidHandle) {
     VLOG(2) << "Initialize video";
     video_demuxer_stream_adapter_.reset(
         new remoting::RemoteDemuxerStreamAdapter(
             main_task_runner_, media_task_runner_, "video",
             video_demuxer_stream, rpc_broker_, video_rpc_handle,
             std::move(video), std::move(video_handle),
             base::Bind(&RemoteRendererImpl::OnFatalError,
                        base::Unretained(this))));
@@ skipping 510 matching lines @@
          kDataFlowPollPeriod.InSecondsF()) /
         kBytesPerKilobit;
     DCHECK_GE(kilobits_per_second, 0);
     const base::CheckedNumeric<int> checked_kbps = kilobits_per_second;
     metrics_recorder_.OnVideoRateEstimate(
         checked_kbps.ValueOrDefault(std::numeric_limits<int>::max()));
   }
 }
 
 }  // namespace media