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

media/mojo/services/mojo_renderer_service.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/mojo/services/mojo_renderer_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #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 {
 
 namespace {
 
 void CloseBindingOnBadMessage(mojo::StrongBindingPtr<mojom::Renderer> binding) {
   LOG(ERROR) << __func__;
   DCHECK(binding);
   binding->Close();
 }
 
 }  // namespace
 
 // Time interval to update media time.
 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,
     std::unique_ptr<media::Renderer> renderer,
     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),
                                                std::move(request));
 
   service->set_bad_message_cb(base::Bind(&CloseBindingOnBadMessage, binding));
 
   return binding;
 }
 
 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)),
       initiate_surface_request_cb_(initiate_surface_request_cb),
       weak_factory_(this) {
   DVLOG(1) << __func__;
   DCHECK(renderer_);
 
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 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,
     const base::Optional<GURL>& media_url,
     const base::Optional<GURL>& first_party_for_cookies,
     const InitializeCallback& callback) {
   DVLOG(1) << __func__;
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   client_.Bind(std::move(client));
   state_ = STATE_INITIALIZING;
 
   if (audio_renderer_sink_ptr) {
     static_cast<MojoAudioRendererSinkAdapter*>(audio_sink_.get())
         ->SetClient(std::move(audio_renderer_sink_ptr));
   }
 
   if (video_renderer_sink_ptr) {
     static_cast<MojoVideoRendererSinkAdapter*>(video_sink_.get())
         ->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));
 }
 
 void MojoRendererService::Flush(const FlushCallback& callback) {
   DVLOG(2) << __func__;
   DCHECK_EQ(state_, STATE_PLAYING);
 
   state_ = STATE_FLUSHING;
   CancelPeriodicMediaTimeUpdates();
@@ skipping 84 matching lines @@
 void MojoRendererService::OnVideoOpacityChange(bool opaque) {
   DVLOG(2) << __func__ << "(" << opaque << ")";
   client_->OnVideoOpacityChange(opaque);
 }
 
 void MojoRendererService::OnStreamReady(
     const base::Callback<void(bool)>& callback) {
   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);
 
   if (status != PIPELINE_OK) {
     state_ = STATE_ERROR;
     callback.Run(false);
     return;
   }
 
@@ skipping 60 matching lines @@
     // This may cause |this| to be destructed.
     DCHECK(!bad_message_cb_.is_null());
     bad_message_cb_.Run();
 
     return;
   }
 
   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