[DO NOT COMMIT] MediaPlayerRenderer using StreamTextures.

media/base/pipeline_impl.cc

 // Copyright (c) 2012 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/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 10 matching lines @@
 #include "media/base/demuxer.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/base/serial_runner.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
+#include "media/media_features.h"
 
 static const double kDefaultPlaybackRate = 0.0;
 static const float kDefaultVolume = 1.0f;
 
 namespace media {
 
 class PipelineImpl::RendererWrapper : public DemuxerHost,
                                       public RendererClient {
  public:
   RendererWrapper(scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
@@ skipping 65 matching lines @@
   void RemoveTextStream(DemuxerStream* text_stream) final;
 
   // RendererClient implementation.
   void OnError(PipelineStatus error) final;
   void OnEnded() final;
   void OnStatisticsUpdate(const PipelineStatistics& stats) final;
   void OnBufferingStateChange(BufferingState state) final;
   void OnWaitingForDecryptionKey() final;
   void OnVideoNaturalSizeChange(const gfx::Size& size) final;
   void OnVideoOpacityChange(bool opaque) final;
+  void OnDurationChange(base::TimeDelta duration) final;
 
   // TextRenderer tasks and notifications.
   void OnTextRendererEnded();
   void AddTextStreamTask(DemuxerStream* text_stream,
                          const TextTrackConfig& config);
   void RemoveTextStreamTask(DemuxerStream* text_stream);
 
   // Common handlers for notifications from renderers and demuxer.
   void OnPipelineError(PipelineStatus error);
   void OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
@@ skipping 471 matching lines @@
 }
 
 void PipelineImpl::RendererWrapper::OnVideoOpacityChange(bool opaque) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::OnVideoOpacityChange, weak_pipeline_, opaque));
 }
 
+void PipelineImpl::RendererWrapper::OnDurationChange(base::TimeDelta duration) {
+#if BUILDFLAG(FORCE_MOJO_MEDIA_PLAYER_RENDERER)
+  SetDuration(duration);
+#else
+  // Duration changes should be surfaced by the DemuxerStream, via the
+  // DemuxerHost interface.
+  NOTREACHED();
+#endif
+}
+
 void PipelineImpl::RendererWrapper::OnTextRendererEnded() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::TEXT_ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!text_renderer_ended_);
   text_renderer_ended_ = true;
   CheckPlaybackEnded();
@@ skipping 255 matching lines @@
     const PipelineStatusCB& done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   demuxer_->Initialize(this, done_cb, !!text_renderer_);
 }
 
 void PipelineImpl::RendererWrapper::InitializeRenderer(
     const PipelineStatusCB& done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
-  if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
-      !demuxer_->GetStream(DemuxerStream::VIDEO)) {
-    done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
-    return;
+  switch (demuxer_->GetType()) {
+    case DemuxerStreamProvider::Type::STREAM:
+      if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
+          !demuxer_->GetStream(DemuxerStream::VIDEO)) {
+        done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
+        return;
+      }
+      break;
+
+    case DemuxerStreamProvider::Type::URL:
+      // N.B: Empty GURL are not valid.
+      if (!demuxer_->GetUrl().is_valid()) {
+        done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
+        return;
+      }
+      break;
   }
 
   if (cdm_context_)
     shared_state_.renderer->SetCdm(cdm_context_,
                                    base::Bind(&IgnoreCdmAttached));
 
   shared_state_.renderer->Initialize(demuxer_, this, done_cb);
 }
 
 void PipelineImpl::RendererWrapper::DestroyRenderer() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Destroy the renderer outside the lock scope to avoid holding the lock
   // while renderer is being destroyed (in case Renderer destructor is costly).
   std::unique_ptr<Renderer> renderer;
   {
     base::AutoLock auto_lock(shared_state_lock_);
     renderer.swap(shared_state_.renderer);
   }
 }
 
 void PipelineImpl::RendererWrapper::ReportMetadata() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   PipelineMetadata metadata;
-  metadata.timeline_offset = demuxer_->GetTimelineOffset();
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
-  if (stream) {
-    metadata.has_video = true;
-    metadata.natural_size = stream->video_decoder_config().natural_size();
-    metadata.video_rotation = stream->video_rotation();
-  }
-  if (demuxer_->GetStream(DemuxerStream::AUDIO)) {
-    metadata.has_audio = true;
+  DemuxerStream* stream;
+
+  switch (demuxer_->GetType()) {
+    case DemuxerStreamProvider::Type::STREAM:
+      metadata.timeline_offset = demuxer_->GetTimelineOffset();
+      stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+      if (stream) {
+        metadata.has_video = true;
+        metadata.natural_size = stream->video_decoder_config().natural_size();
+        metadata.video_rotation = stream->video_rotation();
+      }
+      if (demuxer_->GetStream(DemuxerStream::AUDIO)) {
+        metadata.has_audio = true;
+      }
+      break;
+
+    case DemuxerStreamProvider::Type::URL:
+      // We don't know if the MediaPlayerRender has Audio/Video until we start
+      // playing. Conservatively assume that they do.
+      metadata.has_video = true;
+      metadata.has_audio = true;
+      break;
   }
 
   main_task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::OnMetadata,
                                                     weak_pipeline_, metadata));
 }
 
 PipelineImpl::PipelineImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     MediaLog* media_log)
     : media_task_runner_(media_task_runner),
@@ skipping 365 matching lines @@
 void PipelineImpl::OnSuspendDone(base::TimeDelta suspend_time) {
   DVLOG(3) << __FUNCTION__ << "(" << suspend_time.InMicroseconds() << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media