[DO NOT COMMIT] Initial MediaPlayerRenderer plumbing and basic features

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(base::WeakPtr<PipelineImpl> weak_pipeline,
@@ skipping 23 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;
 
   void DoSeek(base::TimeDelta seek_timestamp, const PipelineStatusCB& done_cb);
   void DoStop(const base::Closure& done_cb);
   void OnPipelineError(PipelineStatus error);
   void OnTextRendererEnded();
   void RunEndedCallbackIfNeeded();
   void SetState(State next_state);
   State GetNextState() const;
   void StateTransitionTask(PipelineStatus status);
   void OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
@@ skipping 452 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::SetDuration(base::TimeDelta duration) {
   // TODO(alokp): Add thread DCHECK after ensuring that all Demuxer
   // implementations call DemuxerHost on the media thread.
   media_log_->AddEvent(media_log_->CreateTimeEvent(MediaLogEvent::DURATION_SET,
                                                    "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::OnDurationChange, weak_pipeline_, duration));
@@ skipping 421 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 BUILDFLAG(FORCE_MOJO_MEDIA_PLAYER_RENDERER)
+  if (!demuxer_->GetStream(DemuxerStream::URL)) {
+    done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
+    return;
+  }
+#else
   if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
       !demuxer_->GetStream(DemuxerStream::VIDEO)) {
     done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
     return;
   }
+#endif  // BUILDFLAG(FORCE_MOJO_MEDIA_PLAYER_RENDERER)
 
   if (cdm_context_)
     renderer_->SetCdm(cdm_context_, base::Bind(&IgnoreCdmAttached));
 
   renderer_->Initialize(demuxer_, this, done_cb);
 }
 
 void PipelineImpl::RendererWrapper::ReportMetadata() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   PipelineMetadata metadata;
+#if BUILDFLAG(FORCE_MOJO_MEDIA_PLAYER_RENDERER)
+  if (demuxer_->GetStream(DemuxerStream::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;
+  }
+#else
   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;
   }
+#endif  // BUILDFLAG(FORCE_MOJO_MEDIA_PLAYER_RENDERER)
 
   main_task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::OnMetadata,
                                                     weak_pipeline_, metadata));
 }
 
 void PipelineImpl::OnError(PipelineStatus error) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
@@ skipping 177 matching lines @@
   // even for accessing media time http://crbug.com/370634.
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(media_time_lock_);
   if (suspend_timestamp_ != kNoTimestamp())
     return suspend_timestamp_;
   return renderer_ ? renderer_->GetMediaTime() : base::TimeDelta();
 }
 
 }  // namespace media