Remove HasAudio(), HasVideo(), GetInitialNaturalSize() from media::Pipeline.

media/base/pipeline.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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 27 matching lines @@
     : task_runner_(task_runner),
       media_log_(media_log),
       running_(false),
       did_loading_progress_(false),
       total_bytes_(0),
       volume_(1.0f),
       playback_rate_(0.0f),
       clock_(new Clock(&default_tick_clock_)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
-      has_audio_(false),
-      has_video_(false),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
       text_ended_(false),
       audio_disabled_(false),
       demuxer_(NULL),
       creation_time_(default_tick_clock_.NowTicks()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
 Pipeline::~Pipeline() {
   DCHECK(thread_checker_.CalledOnValidThread())
       << "Pipeline must be destroyed on same thread that created it";
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(stop_cb_.is_null());
   DCHECK(seek_cb_.is_null());
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
 void Pipeline::Start(scoped_ptr<FilterCollection> collection,
                      const base::Closure& ended_cb,
                      const PipelineStatusCB& error_cb,
                      const PipelineStatusCB& seek_cb,
+                     const HasTrackCB& has_track_cb,
                      const BufferingStateCB& buffering_state_cb,
                      const base::Closure& duration_change_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
   DCHECK(!buffering_state_cb.is_null());
 
+  filter_collection_ = collection.Pass();
+  ended_cb_ = ended_cb;
+  error_cb_ = error_cb;
+  seek_cb_ = seek_cb;
+  has_track_cb_ = has_track_cb;
+  buffering_state_cb_ = buffering_state_cb;
+  duration_change_cb_ = duration_change_cb;
+
   running_ = true;
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::StartTask, base::Unretained(this), base::Passed(&collection),
-      ended_cb, error_cb, seek_cb, buffering_state_cb, duration_change_cb));
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Pipeline::StartTask, base::Unretained(this)));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
   base::AutoLock auto_lock(lock_);
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StopTask, base::Unretained(this), stop_cb));
 }
 
 void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   if (!running_) {
     NOTREACHED() << "Media pipeline isn't running";
     return;
   }
 
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::SeekTask, base::Unretained(this), time, seek_cb));
 }
 
 bool Pipeline::IsRunning() const {
   base::AutoLock auto_lock(lock_);
   return running_;
 }
 
-bool Pipeline::HasAudio() const {
-  base::AutoLock auto_lock(lock_);
-  return has_audio_;
-}
-
-bool Pipeline::HasVideo() const {
-  base::AutoLock auto_lock(lock_);
-  return has_video_;
-}
-
 float Pipeline::GetPlaybackRate() const {
   base::AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
 void Pipeline::SetPlaybackRate(float playback_rate) {
   if (playback_rate < 0.0f)
     return;
 
   base::AutoLock auto_lock(lock_);
@@ skipping 195 matching lines @@
       &Pipeline::AudioDisabledTask, base::Unretained(this)));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
 }
 
 void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK_LE(time.InMicroseconds(), max_time.InMicroseconds());
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
-  if (!has_audio_)
+  if (audio_renderer_ == NULL || audio_disabled_)
     return;
+
   if (waiting_for_clock_update_ && time < clock_->Elapsed())
     return;
 
   // TODO(scherkus): |state_| should only be accessed on pipeline thread, see
   // http://crbug.com/137973
   if (state_ == kSeeking)
     return;
 
   clock_->SetTime(time, max_time);
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
 void Pipeline::OnVideoTimeUpdate(TimeDelta max_time) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
-  if (has_audio_)
+  if (audio_renderer_ != NULL && !audio_disabled_)
     return;
 
   // TODO(scherkus): |state_| should only be accessed on pipeline thread, see
   // http://crbug.com/137973
   if (state_ == kSeeking)
     return;
 
   DCHECK(!waiting_for_clock_update_);
   clock_->SetMaxTime(max_time);
 }
@@ skipping 90 matching lines @@
     case kInitVideoRenderer:
       return InitializeVideoRenderer(done_cb);
 
     case kInitPrerolling:
       filter_collection_.reset();
       {
         base::AutoLock l(lock_);
         // We do not want to start the clock running. We only want to set the
         // base media time so our timestamp calculations will be correct.
         clock_->SetTime(demuxer_->GetStartTime(), demuxer_->GetStartTime());
-
-        // TODO(scherkus): |has_audio_| should be true no matter what --
-        // otherwise people with muted/disabled sound cards will make our
-        // default controls look as if every video doesn't contain an audio
-        // track.
-        has_audio_ = audio_renderer_ != NULL && !audio_disabled_;
-        has_video_ = video_renderer_ != NULL;
       }
       if (!audio_renderer_ && !video_renderer_) {
         done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
         return;
       }
 
       buffering_state_cb_.Run(kHaveMetadata);
 
       return DoInitialPreroll(done_cb);
 
     case kStarting:
       return DoPlay(done_cb);
 
     case kStarted:
       {
         base::AutoLock l(lock_);
         // We use audio stream to update the clock. So if there is such a
         // stream, we pause the clock until we receive a valid timestamp.
         waiting_for_clock_update_ = true;
-        if (!has_audio_) {
+        if (audio_renderer_ == NULL || audio_disabled_) {
           clock_->SetMaxTime(clock_->Duration());
           StartClockIfWaitingForTimeUpdate_Locked();
         }
       }
 
       DCHECK(!seek_cb_.is_null());
       DCHECK_EQ(status_, PIPELINE_OK);
 
       // Fire canplaythrough immediately after playback begins because of
       // crbug.com/106480.
@@ skipping 222 matching lines @@
 
 // Called from any thread.
 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
-void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
-                         const base::Closure& ended_cb,
-                         const PipelineStatusCB& error_cb,
-                         const PipelineStatusCB& seek_cb,
-                         const BufferingStateCB& buffering_state_cb,
-                         const base::Closure& duration_change_cb) {
+void Pipeline::StartTask() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
-  filter_collection_ = filter_collection.Pass();
-  ended_cb_ = ended_cb;
-  error_cb_ = error_cb;
-  seek_cb_ = seek_cb;
-  buffering_state_cb_ = buffering_state_cb;
-  duration_change_cb_ = duration_change_cb;
-
   text_renderer_ = filter_collection_->GetTextRenderer();
-
   if (text_renderer_) {
     text_renderer_->Initialize(
         base::Bind(&Pipeline::OnTextRendererEnded, base::Unretained(this)));
   }
 
   StateTransitionTask(PIPELINE_OK);
 }
 
 void Pipeline::StopTask(const base::Closure& stop_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 155 matching lines @@
   }
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
 void Pipeline::AudioDisabledTask() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
-  has_audio_ = false;
   audio_disabled_ = true;
 
   // Notify our demuxer that we're no longer rendering audio.
   demuxer_->OnAudioRendererDisabled();
 
   // Start clock since there is no more audio to trigger clock updates.
   clock_->SetMaxTime(clock_->Duration());
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
@@ skipping 23 matching lines @@
   audio_renderer_ = filter_collection_->GetAudioRenderer();
   audio_renderer_->Initialize(
       demuxer_->GetStream(DemuxerStream::AUDIO),
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)),
       base::Bind(&Pipeline::OnAudioUnderflow, base::Unretained(this)),
       base::Bind(&Pipeline::OnAudioTimeUpdate, base::Unretained(this)),
       base::Bind(&Pipeline::OnAudioRendererEnded, base::Unretained(this)),
       base::Bind(&Pipeline::OnAudioDisabled, base::Unretained(this)),
       base::Bind(&Pipeline::SetError, base::Unretained(this)));
+
+  if (!has_track_cb_.is_null())
+    has_track_cb_.Run(AUDIO);
 }
 
 void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Get an initial natural size so we have something when we signal
   // the kHaveMetadata buffering state.
   //
   // TODO(acolwell): We have to query demuxer outside of the lock to prevent a
   // deadlock between ChunkDemuxer and Pipeline. See http://crbug.com/334325 for
   // ideas on removing locking from ChunkDemuxer.
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   gfx::Size initial_natural_size =
       stream->video_decoder_config().natural_size();
   {
     base::AutoLock l(lock_);
     initial_natural_size_ = initial_natural_size;
   }
 
   video_renderer_ = filter_collection_->GetVideoRenderer();
   video_renderer_->Initialize(
       stream,
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)),
       base::Bind(&Pipeline::OnVideoTimeUpdate, base::Unretained(this)),
       base::Bind(&Pipeline::OnVideoRendererEnded, base::Unretained(this)),
       base::Bind(&Pipeline::SetError, base::Unretained(this)),
       base::Bind(&Pipeline::GetMediaTime, base::Unretained(this)),
       base::Bind(&Pipeline::GetMediaDuration, base::Unretained(this)));
+
+  if (!has_track_cb_.is_null())
+    has_track_cb_.Run(VIDEO);
 }
 
 void Pipeline::OnAudioUnderflow() {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(
         &Pipeline::OnAudioUnderflow, base::Unretained(this)));
     return;
   }
 
   if (state_ != kStarted)
     return;
 
   if (audio_renderer_)
     audio_renderer_->ResumeAfterUnderflow();
 }
 
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media