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

media/blink/webmediaplayer_impl.cc

Index: media/blink/webmediaplayer_impl.cc
diff --git a/media/blink/webmediaplayer_impl.cc b/media/blink/webmediaplayer_impl.cc
index a195bbffe433dd586df6ba14be3dffe79a5891dd..2178fb44182fa9e286b1c537ec5b00f868c61aa3 100644
--- a/media/blink/webmediaplayer_impl.cc
+++ b/media/blink/webmediaplayer_impl.cc
@@ -32,12 +32,16 @@
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/cdm_context.h"
 #include "media/base/content_decryption_module.h"
+#include "media/base/demuxer.h"
 #include "media/base/limits.h"
 #include "media/base/media_content_type.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
+#include "media/base/media_tracks.h"
 #include "media/base/media_url_demuxer.h"
+#include "media/base/source_buffer.h"
 #include "media/base/text_renderer.h"
+#include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/blink/texttrack_impl.h"
@@ -48,8 +52,6 @@
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "media/blink/webmediasource_impl.h"
-#include "media/filters/chunk_demuxer.h"
-#include "media/filters/ffmpeg_demuxer.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaTypes.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerEncryptedMediaClient.h"
@@ -170,6 +172,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     WebMediaPlayerDelegate* delegate,
+    std::unique_ptr<DemuxerFactory> demuxer_factory,
     std::unique_ptr<RendererFactory> renderer_factory,
     linked_ptr<UrlIndex> url_index,
     const WebMediaPlayerParams& params)
@@ -215,7 +218,9 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       adjust_allocated_memory_cb_(params.adjust_allocated_memory_cb()),
       last_reported_memory_usage_(0),
       supports_save_(true),
-      chunk_demuxer_(NULL),
+      data_source_(nullptr),
+      demuxer_(nullptr),
+      source_buffer_(nullptr),
       url_index_(url_index),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(params.compositor_task_runner()
@@ -227,6 +232,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
+      demuxer_factory_(std::move(demuxer_factory)),
       renderer_factory_(std::move(renderer_factory)),
       surface_manager_(params.surface_manager()),
       overlay_surface_id_(SurfaceManager::kNoSurfaceID),
@@ -510,7 +516,7 @@ void WebMediaPlayerImpl::DoSeek(base::TimeDelta time, bool time_updated) {
   //      Because the buffers may have changed between seeks, MSE seeks are
   //      never elided.
   if (paused_ && pipeline_controller_.IsStable() && paused_time_ == time &&
-      !chunk_demuxer_) {
+      !demuxer_) {
     // If the ready state was high enough before, we can indicate that the seek
     // completed just by restoring it. Otherwise we will just wait for the real
     // ready state change to eventually happen.
@@ -715,8 +721,8 @@ double WebMediaPlayerImpl::duration() const {
   // TimeDelta with potentially reduced precision (limited to Microseconds).
   // ChunkDemuxer returns the full-precision user-specified double. This ensures
   // users can "get" the exact duration they "set".
-  if (chunk_demuxer_)
-    return chunk_demuxer_->GetDuration();
+  if (source_buffer_)
+    return source_buffer_->GetDuration();
 
   base::TimeDelta pipeline_duration = GetPipelineMediaDuration();
   return pipeline_duration == kInfiniteDuration
@@ -1011,7 +1017,7 @@ void WebMediaPlayerImpl::OnFFmpegMediaTracksUpdated(
   // For MSE/chunk_demuxer case the media track updates are handled by
   // WebSourceBufferImpl.
   DCHECK(demuxer_.get());
-  DCHECK(!chunk_demuxer_);
+  DCHECK(!source_buffer_);
 
   // Report the media track information to blink.
   for (const auto& track : tracks->tracks()) {
@@ -1160,7 +1166,7 @@ void WebMediaPlayerImpl::OnPipelineResumed() {
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->mediaSourceOpened(
-      new WebMediaSourceImpl(chunk_demuxer_, media_log_));
+      new WebMediaSourceImpl(source_buffer_, media_log_));
 }
 
 void WebMediaPlayerImpl::OnMemoryPressure(
@@ -1168,7 +1174,7 @@ void WebMediaPlayerImpl::OnMemoryPressure(
   DVLOG(2) << __func__ << " memory_pressure_level=" << memory_pressure_level;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(base::FeatureList::IsEnabled(kMemoryPressureBasedSourceBufferGC));
-  DCHECK(chunk_demuxer_);
+  DCHECK(source_buffer_);
 
   // The new value of |memory_pressure_level| will take effect on the next
   // garbage collection. Typically this means the next SourceBuffer append()
@@ -1187,8 +1193,8 @@ void WebMediaPlayerImpl::OnMemoryPressure(
   // base::Unretained is safe, since chunk_demuxer_ is actually owned by
   // |this| via this->demuxer_.
   media_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&ChunkDemuxer::OnMemoryPressure,
-                            base::Unretained(chunk_demuxer_),
+      FROM_HERE, base::Bind(&media::SourceBuffer::OnMemoryPressure,
+                            base::Unretained(source_buffer_),
                             base::TimeDelta::FromSecondsD(currentTime()),
                             memory_pressure_level, force_instant_gc));
 }
@@ -1691,6 +1697,34 @@ void WebMediaPlayerImpl::OnSurfaceRequested(
   OnSurfaceCreated(overlay_surface_id_);
 }
 
+std::unique_ptr<Demuxer> WebMediaPlayerImpl::CreateDemuxer() {
+  CHECK(main_task_runner_->BelongsToCurrentThread());
+
+  if (load_type_ != LoadTypeMediaSource) {
+    return demuxer_factory_->CreateDemuxer(
+        main_task_runner_, media_task_runner_, data_source_.get(),
+        BindToCurrentLoop(base::Bind(
+            &WebMediaPlayerImpl::OnEncryptedMediaInitData, AsWeakPtr())),
+        BindToCurrentLoop(base::Bind(
+            &WebMediaPlayerImpl::OnFFmpegMediaTracksUpdated, AsWeakPtr())));
+  }
+
+  if (base::FeatureList::IsEnabled(kMemoryPressureBasedSourceBufferGC)) {
+    // base::Unretained is safe because |this| owns memory_pressure_listener_.
+    memory_pressure_listener_ =
+        base::MakeUnique<base::MemoryPressureListener>(base::Bind(
+            &WebMediaPlayerImpl::OnMemoryPressure, base::Unretained(this)));
+  }
+
+  return demuxer_factory_->CreateDemuxerSourceBuffer(
+      main_task_runner_, media_task_runner_,
+      BindToCurrentLoop(
+          base::Bind(&WebMediaPlayerImpl::OnDemuxerOpened, AsWeakPtr())),
+      BindToCurrentLoop(base::Bind(
+          &WebMediaPlayerImpl::OnEncryptedMediaInitData, AsWeakPtr())),
+      &source_buffer_);
+}
+
 std::unique_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
@@ -1710,10 +1744,6 @@ std::unique_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
 void WebMediaPlayerImpl::StartPipeline() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
-      BindToCurrentLoop(base::Bind(
-          &WebMediaPlayerImpl::OnEncryptedMediaInitData, AsWeakPtr()));
-
   if (use_fallback_path_) {
     demuxer_.reset(
         new MediaUrlDemuxer(media_task_runner_, fallback_url_,
@@ -1722,44 +1752,15 @@ void WebMediaPlayerImpl::StartPipeline() {
     return;
   }
 
-  // Figure out which demuxer to use.
-  if (load_type_ != LoadTypeMediaSource) {
-    DCHECK(!chunk_demuxer_);
-    DCHECK(data_source_);
-
-#if !defined(MEDIA_DISABLE_FFMPEG)
-    Demuxer::MediaTracksUpdatedCB media_tracks_updated_cb =
-        BindToCurrentLoop(base::Bind(
-            &WebMediaPlayerImpl::OnFFmpegMediaTracksUpdated, AsWeakPtr()));
-
-    demuxer_.reset(new FFmpegDemuxer(media_task_runner_, data_source_.get(),
-                                     encrypted_media_init_data_cb,
-                                     media_tracks_updated_cb, media_log_));
-#else
+  demuxer_ = CreateDemuxer();
+  if (!demuxer_) {
     OnError(PipelineStatus::DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
-#endif
-  } else {
-    DCHECK(!chunk_demuxer_);
-    DCHECK(!data_source_);
-
-    chunk_demuxer_ = new ChunkDemuxer(
-        BindToCurrentLoop(
-            base::Bind(&WebMediaPlayerImpl::OnDemuxerOpened, AsWeakPtr())),
-        encrypted_media_init_data_cb, media_log_);
-    demuxer_.reset(chunk_demuxer_);
-
-    if (base::FeatureList::IsEnabled(kMemoryPressureBasedSourceBufferGC)) {
-      // base::Unretained is safe because |this| owns memory_pressure_listener_.
-      memory_pressure_listener_ =
-          base::MakeUnique<base::MemoryPressureListener>(base::Bind(
-              &WebMediaPlayerImpl::OnMemoryPressure, base::Unretained(this)));
-    }
   }
 
   // TODO(sandersd): FileSystem objects may also be non-static, but due to our
   // caching layer such situations are broken already. http://crbug.com/593159
-  bool is_static = !chunk_demuxer_;
+  bool is_static = !demuxer_;
   bool is_streaming = IsStreaming();
   UMA_HISTOGRAM_BOOLEAN("Media.IsStreaming", is_streaming);
 
@@ -2116,10 +2117,10 @@ void WebMediaPlayerImpl::ScheduleIdlePauseTimer() {
 
 void WebMediaPlayerImpl::CreateWatchTimeReporter() {
   // Create the watch time reporter and synchronize its initial state.
-  watch_time_reporter_.reset(new WatchTimeReporter(
-      hasAudio(), hasVideo(), !!chunk_demuxer_, is_encrypted_, media_log_,
-      pipeline_metadata_.natural_size,
-      base::Bind(&GetCurrentTimeInternal, this)));
+  watch_time_reporter_.reset(
+      new WatchTimeReporter(hasAudio(), hasVideo(), !!demuxer_, is_encrypted_,
+                            media_log_, pipeline_metadata_.natural_size,
+                            base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
   if (delegate_->IsFrameHidden())
     watch_time_reporter_->OnHidden();