Introducing DemuxerHost::OnMetadata.

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 80 matching lines @@
 
     // Accumulated statistics reported by the renderer.
     PipelineStatistics statistics;
 
     // The media timestamp to return while the pipeline is suspended.
     // Otherwise set to kNoTimestamp.
     base::TimeDelta suspend_timestamp = kNoTimestamp;
   };
 
   // DemuxerHost implementaion.
+  void OnMetadata(PipelineMetadata metadata) final;
   void OnBufferedTimeRangesChanged(const Ranges<base::TimeDelta>& ranges) final;
   void SetDuration(base::TimeDelta duration) final;
   void OnDemuxerError(PipelineStatus error) final;
   void AddTextStream(DemuxerStream* text_stream,
                      const TextTrackConfig& config) final;
   void RemoveTextStream(DemuxerStream* text_stream) final;
 
   // RendererClient implementation.
   void OnError(PipelineStatus error) final;
   void OnEnded() final;
@@ skipping 17 matching lines @@
                      bool success);
   void CheckPlaybackEnded();
 
   // State transition tasks.
   void SetState(State next_state);
   void CompleteSeek(base::TimeDelta seek_time, PipelineStatus status);
   void CompleteSuspend(PipelineStatus status);
   void InitializeDemuxer(const PipelineStatusCB& done_cb);
   void InitializeRenderer(const PipelineStatusCB& done_cb);
   void DestroyRenderer();
-  void ReportMetadata();
 
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const scoped_refptr<MediaLog> media_log_;
 
   base::WeakPtr<PipelineImpl> weak_pipeline_;
   Demuxer* demuxer_;
   std::unique_ptr<TextRenderer> text_renderer_;
   double playback_rate_;
   float volume_;
@@ skipping 85 matching lines @@
   }
   weak_pipeline_ = weak_pipeline;
 
   // Queue asynchronous actions required to start.
   DCHECK(!pending_callbacks_);
   SerialRunner::Queue fns;
 
   // Initialize demuxer.
   fns.Push(base::Bind(&RendererWrapper::InitializeDemuxer, weak_this_));
 
-  // Once the demuxer is initialized successfully, media metadata must be
-  // available - report the metadata to client.
-  fns.Push(base::Bind(&RendererWrapper::ReportMetadata, weak_this_));
-
   // Initialize renderer.
   fns.Push(base::Bind(&RendererWrapper::InitializeRenderer, weak_this_));
 
   // Run tasks.
   pending_callbacks_ =
       SerialRunner::Run(fns, base::Bind(&RendererWrapper::CompleteSeek,
                                         weak_this_, base::TimeDelta()));
 }
 
 void PipelineImpl::RendererWrapper::Stop(const base::Closure& stop_cb) {
@@ skipping 221 matching lines @@
     cdm_context_ = cdm_context;
     cdm_attached_cb.Run(true);
     return;
   }
 
   shared_state_.renderer->SetCdm(
       cdm_context, base::Bind(&RendererWrapper::OnCdmAttached, weak_this_,
                               cdm_attached_cb, cdm_context));
 }
 
+void PipelineImpl::RendererWrapper::OnMetadata(PipelineMetadata metadata) {
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::OnMetadata,
+                                                    weak_pipeline_, metadata));
+}
+
 void PipelineImpl::RendererWrapper::OnBufferedTimeRangesChanged(
     const Ranges<base::TimeDelta>& ranges) {
   // TODO(alokp): Add thread DCHECK after ensuring that all Demuxer
   // implementations call DemuxerHost on the media thread.
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.did_loading_progress = true;
   shared_state_.buffered_time_ranges = ranges;
 }
 
 void PipelineImpl::RendererWrapper::SetDuration(base::TimeDelta duration) {
@@ skipping 339 matching lines @@
 
   // 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;
-  }
-
-  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),
       media_log_(media_log),
       client_(nullptr),
       playback_rate_(kDefaultPlaybackRate),
       volume_(kDefaultVolume),
       weak_factory_(this) {
   DVLOG(2) << __func__;
@@ skipping 358 matching lines @@
 void PipelineImpl::OnSuspendDone() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media