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

media/base/pipeline_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ skipping 76 matching lines @@
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
 // initialization is moved to a separate thread this test will become flaky.
 class PipelineTest : public ::testing::Test {
  public:
   PipelineTest()
       : pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
-                               new MediaLog())) {
+                               new MediaLog())),
+        audio_disabled_(false) {
     mocks_.reset(new MockFilterCollection());
 
     // InitializeDemuxer() adds overriding expectations for expected non-NULL
     // streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*mocks_->demuxer(), GetStream(_))
         .WillRepeatedly(Return(null_pointer));
 
     EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
         .WillRepeatedly(Return(base::TimeDelta()));
   }
 
   virtual ~PipelineTest() {
     // Shutdown sequence.
     if (pipeline_->IsRunning()) {
       EXPECT_CALL(*mocks_->demuxer(), Stop(_))
           .WillOnce(RunClosure());
 
       // TODO(scherkus): Don't pause+flush on shutdown,
       // see http://crbug.com/110228
-      if (audio_stream_) {
+      if (audio_stream_ && !audio_disabled_) {
         EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
             .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
             .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
             .WillOnce(RunClosure());
       }
 
       if (video_stream_) {
         EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
@@ skipping 67 matching lines @@
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(bool disable_after_init_cb = false) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
           _, _, _, _, _, _))
           .WillOnce(DoAll(RunPipelineStatusCB(),
                           WithArg<5>(RunClosure())));  // |disabled_cb|.
+      audio_disabled_ = true;
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
           _, _, _, _, _, _))
           .WillOnce(DoAll(SaveArg<3>(&audio_time_cb_),
                           RunPipelineStatusCB()));
     }
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
       EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
 
-      if (audio_stream_) {
+      if (audio_stream_ && !audio_disabled_) {
         EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
         EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
         // Startup sequence.
         EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
             .WillOnce(RunPipelineStatusCB());
         EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
             .WillOnce(RunClosure());
       }
       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
@@ skipping 64 matching lines @@
     pipeline_->Seek(seek_time,
                     base::Bind(&CallbackHelper::OnSeek,
                                base::Unretained(&callbacks_)));
 
     // We expect the time to be updated only after the seek has completed.
     EXPECT_NE(seek_time, pipeline_->GetMediaTime());
     message_loop_.RunAllPending();
     EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   }
 
+  void DisableAudio() {
+    pipeline_->OnAudioDisabled();
+    audio_disabled_ = true;
+  }
+
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   MessageLoop message_loop_;
   scoped_refptr<Pipeline> pipeline_;
   scoped_ptr<media::MockFilterCollection> mocks_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
+  bool audio_disabled_;
   AudioRenderer::TimeCB audio_time_cb_;
   VideoDecoderConfig video_decoder_config_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
 TEST_F(PipelineTest, NotStarted) {
@@ skipping 248 matching lines @@
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*mocks_->demuxer(), OnAudioRendererDisabled());
-  pipeline_->OnAudioDisabled();
+  DisableAudio();
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnVideoRendererEnded();
 }
 
 TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
@@ skipping 724 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media