Mojify demuxers and allow running {Chunk/FFmpeg}Demuxer in a Utility Process

media/mojo/services/mojo_renderer_service.cc

Index: media/mojo/services/mojo_renderer_service.cc
diff --git a/media/mojo/services/mojo_renderer_service.cc b/media/mojo/services/mojo_renderer_service.cc
index 2ae2382f6d4dec044b80a941d0e294489c203120..47a6d5fd80f060f1bb7b409d58ecde5f822ea633 100644
--- a/media/mojo/services/mojo_renderer_service.cc
+++ b/media/mojo/services/mojo_renderer_service.cc
@@ -10,13 +10,16 @@
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "media/base/audio_renderer_sink.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/base/content_decryption_module.h"
+#include "media/base/media_log.h"
 #include "media/base/media_url_demuxer.h"
 #include "media/base/renderer.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/mojo/services/media_resource_shim.h"
 #include "media/mojo/services/mojo_audio_renderer_sink_adapter.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
+#include "media/mojo/services/mojo_demuxer_service_context.h"
 #include "media/mojo/services/mojo_video_renderer_sink_adapter.h"
 
 namespace media {
@@ -36,6 +39,7 @@ const int kTimeUpdateIntervalMs = 50;
 
 // static
 mojo::StrongBindingPtr<mojom::Renderer> MojoRendererService::Create(
+    base::WeakPtr<MojoDemuxerServiceContext> mojo_demuxer_service_context,
     base::WeakPtr<MojoCdmServiceContext> mojo_cdm_service_context,
     scoped_refptr<AudioRendererSink> audio_sink,
     std::unique_ptr<VideoRendererSink> video_sink,
@@ -43,8 +47,9 @@ mojo::StrongBindingPtr<mojom::Renderer> MojoRendererService::Create(
     InitiateSurfaceRequestCB initiate_surface_request_cb,
     mojo::InterfaceRequest<mojom::Renderer> request) {
   MojoRendererService* service = new MojoRendererService(
-      mojo_cdm_service_context, std::move(audio_sink), std::move(video_sink),
-      std::move(renderer), initiate_surface_request_cb);
+      mojo_demuxer_service_context, mojo_cdm_service_context,
+      std::move(audio_sink), std::move(video_sink), std::move(renderer),
+      initiate_surface_request_cb);
 
   mojo::StrongBindingPtr<mojom::Renderer> binding =
       mojo::MakeStrongBinding<mojom::Renderer>(base::WrapUnique(service),
@@ -56,14 +61,19 @@ mojo::StrongBindingPtr<mojom::Renderer> MojoRendererService::Create(
 }
 
 MojoRendererService::MojoRendererService(
+    base::WeakPtr<MojoDemuxerServiceContext> mojo_demuxer_service_context,
     base::WeakPtr<MojoCdmServiceContext> mojo_cdm_service_context,
     scoped_refptr<AudioRendererSink> audio_sink,
     std::unique_ptr<VideoRendererSink> video_sink,
     std::unique_ptr<media::Renderer> renderer,
     InitiateSurfaceRequestCB initiate_surface_request_cb)
-    : mojo_cdm_service_context_(mojo_cdm_service_context),
+    : mojo_demuxer_service_context_(mojo_demuxer_service_context),
+      mojo_cdm_service_context_(mojo_cdm_service_context),
       state_(STATE_UNINITIALIZED),
       playback_rate_(0),
+      media_resource_shim_(nullptr),
+      media_url_demuxer_(nullptr),
+      media_resource_(nullptr),
       audio_sink_(std::move(audio_sink)),
       video_sink_(std::move(video_sink)),
       renderer_(std::move(renderer)),
@@ -79,6 +89,7 @@ MojoRendererService::~MojoRendererService() {}
 
 void MojoRendererService::Initialize(
     mojom::RendererClientAssociatedPtrInfo client,
+    int32_t demuxer_id,
     base::Optional<std::vector<mojom::DemuxerStreamPtr>> streams,
     mojom::AudioRendererSinkPtr audio_renderer_sink_ptr,
     mojom::VideoRendererSinkPtr video_renderer_sink_ptr,
@@ -101,20 +112,30 @@ void MojoRendererService::Initialize(
         ->Initialize(std::move(video_renderer_sink_ptr));
   }
 
+  if (demuxer_id != MediaResource::kInvalidRemoteId) {
+    media_resource_ = mojo_demuxer_service_context_->GetDemuxer(
+        demuxer_id, base::Bind(&MojoRendererService::OnDemuxerInitialized,
+                               weak_this_, callback));
+    CHECK(media_resource_);
+    return;
+  }
+
   if (media_url == base::nullopt) {
     DCHECK(streams.has_value());
-    media_resource_.reset(new MediaResourceShim(
+    media_resource_shim_.reset(new MediaResourceShim(
         std::move(*streams),
         base::Bind(&MojoRendererService::OnStreamReady, weak_this_, callback)));
+    media_resource_ = media_resource_shim_.get();
     return;
   }
 
   DCHECK(!media_url.value().is_empty());
   DCHECK(first_party_for_cookies);
-  media_resource_.reset(new MediaUrlDemuxer(nullptr, media_url.value(),
-                                            first_party_for_cookies.value()));
+  media_url_demuxer_.reset(new MediaUrlDemuxer(
+      nullptr, media_url.value(), first_party_for_cookies.value()));
+  media_resource_ = media_url_demuxer_.get();
   renderer_->Initialize(
-      media_resource_.get(), this,
+      media_resource_, this,
       base::Bind(&MojoRendererService::OnRendererInitializeDone, weak_this_,
                  callback));
 }
@@ -219,13 +240,13 @@ void MojoRendererService::OnStreamReady(
   DCHECK_EQ(state_, STATE_INITIALIZING);
 
   renderer_->Initialize(
-      media_resource_.get(), this,
+      media_resource_, this,
       base::Bind(&MojoRendererService::OnRendererInitializeDone, weak_this_,
                  callback));
 }
 
 void MojoRendererService::OnRendererInitializeDone(
-    const base::Callback<void(bool)>& callback,
+    const InitializeCallback& callback,
     PipelineStatus status) {
   DVLOG(1) << __func__;
   DCHECK_EQ(state_, STATE_INITIALIZING);
@@ -306,4 +327,27 @@ void MojoRendererService::InitiateScopedSurfaceRequest(
   callback.Run(initiate_surface_request_cb_.Run());
 }
 
+void MojoRendererService::OnDemuxerInitialized(
+    const InitializeCallback& callback,
+    PipelineStatus status) {
+  if (status != PipelineStatus::PIPELINE_OK) {
+    OnError(status);
+    return;
+  }
+
+  // for chunk it is called from add id second
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&MojoRendererService::InitializeRenderer,
+                            weak_this_, callback),
+      base::TimeDelta::FromMilliseconds(100));
+}
+
+void MojoRendererService::InitializeRenderer(
+    const InitializeCallback& callback) {
+  renderer_->Initialize(
+      media_resource_, this,
+      base::Bind(&MojoRendererService::OnRendererInitializeDone, weak_this_,
+                 callback));
+}
+
 }  // namespace media