Remove Pipeline::has_{audio,video}_ members.

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 66 matching lines @@
       playback_rate_change_pending_(false),
       did_loading_progress_(false),
       total_bytes_(0),
       natural_size_(0, 0),
       volume_(1.0f),
       playback_rate_(0.0f),
       pending_playback_rate_(0.0f),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
-      has_audio_(false),
-      has_video_(false),
       state_(kCreated),
       seek_timestamp_(kNoTimestamp()),
       audio_ended_(false),
       video_ended_(false),
       audio_disabled_(false),
       creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
@@ skipping 40 matching lines @@
       &Pipeline::SeekTask, 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_;
+  return audio_renderer_;
 }
 
 bool Pipeline::HasVideo() const {
   base::AutoLock auto_lock(lock_);
-  return has_video_;
+  return video_renderer_;
 }
 
 float Pipeline::GetPlaybackRate() const {
   base::AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
 void Pipeline::SetPlaybackRate(float playback_rate) {
   if (playback_rate < 0.0f)
     return;
@@ skipping 184 matching lines @@
       &Pipeline::AudioDisabledTask, 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_)
     return;
   if (waiting_for_clock_update_ && time < clock_->Elapsed())
     return;
 
   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_)
     return;
 
   if (state_ == kSeeking)
     return;
 
   DCHECK(!waiting_for_clock_update_);
   clock_->SetMaxTime(max_time);
 }
 
 void Pipeline::SetDuration(TimeDelta duration) {
@@ skipping 231 matching lines @@
     // If this method returns false, then there's no audio stream.
     if (InitializeAudioDecoder(demuxer_))
       return;
   }
 
   // Assuming audio decoder was created, create audio renderer.
   if (state_ == kInitAudioDecoder) {
     SetState(kInitAudioRenderer);
 
     // Returns false if there's no audio stream.
-    if (InitializeAudioRenderer(pipeline_init_state_->audio_decoder)) {
-      base::AutoLock auto_lock(lock_);
-      has_audio_ = true;
+    if (InitializeAudioRenderer(pipeline_init_state_->audio_decoder))
       return;
-    }
   }
 
   // Assuming audio renderer was created, create video renderer.
   if (state_ == kInitAudioRenderer) {
     SetState(kInitVideoRenderer);
     scoped_refptr<DemuxerStream> video_stream =
         demuxer_->GetStream(DemuxerStream::VIDEO);
     if (InitializeVideoRenderer(video_stream)) {
       base::AutoLock auto_lock(lock_);
-      has_video_ = true;
 
       // Get an initial natural size so we have something when we signal
       // the kHaveMetadata buffering state.
       natural_size_ = video_stream->video_decoder_config().natural_size();
       return;
     }
   }
 
   if (state_ == kInitVideoRenderer) {
     if (!IsPipelineOk() || !(HasAudio() || HasVideo())) {
@@ skipping 12 matching lines @@
 
     buffering_state_cb_.Run(kHaveMetadata);
 
     // Fire a seek request to get the renderers to preroll. We can skip a seek
     // here as the demuxer should be at the start of the stream.
     seek_pending_ = true;
     SetState(kSeeking);
     seek_timestamp_ = demuxer_->GetStartTime();
     DoSeek(seek_timestamp_, true,
            base::Bind(&Pipeline::OnFilterStateTransition, this));
+    return;
   }
+
+  NOTREACHED() << "Unexpected state: " << state_;

[Ami GONE FROM CHROMIUM, 2012/08/30 07:09:10]

Added b/c otherwise the control structures in this function make even less
sense.  

 }
 
 // This method is called as a result of the client calling Pipeline::Stop() or
 // as the result of an error condition.
 // We stop the filters in the reverse order.
 //
 // TODO(scherkus): beware!  this can get posted multiple times since we post
 // Stop() tasks even if we've already stopped.  Perhaps this should no-op for
 // additional calls, however most of this logic will be changing.
 void Pipeline::StopTask(const base::Closure& stop_cb) {
@@ skipping 171 matching lines @@
     clock_->EndOfStream();
   }
 
   ReportStatus(ended_cb_, status_);
 }
 
 void Pipeline::AudioDisabledTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
-  has_audio_ = false;
+  audio_renderer_ = NULL;
   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 57 matching lines @@
     // the seek has compelted.
     if (playback_rate_change_pending_) {
       playback_rate_change_pending_ = false;
       PlaybackRateChangedTask(pending_playback_rate_);
     }
 
     base::AutoLock auto_lock(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_) {
       clock_->SetMaxTime(clock_->Duration());
       StartClockIfWaitingForTimeUpdate_Locked();
     }
 
     // Check if we have a pending stop request that needs to be honored.
     if (!stop_cb_.is_null()) {
       TearDownPipeline();
     }
   } else {
     NOTREACHED() << "Unexpected state: " << state_;
@@ skipping 280 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media