Move VideoDecoder initialization into VideoRendererBase.

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 27 matching lines @@
 
 ACTION_P(SetDemuxerProperties, duration) {
   arg0->SetTotalBytes(kTotalBytes);
   arg0->SetDuration(duration);
 }
 
 ACTION(RunPipelineStatusCB1) {
   arg1.Run(PIPELINE_OK);
 }
 
+ACTION(RunPipelineStatusCB2) {
+  arg2.Run(PIPELINE_OK);
+}
+
 ACTION_P(RunPipelineStatusCB1WithStatus, status) {
   arg1.Run(status);
 }
 
+ACTION_P(RunPipelineStatusCB2WithStatus, status) {
+  arg2.Run(status);
+}
+
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD1(OnStart, void(PipelineStatus));
   MOCK_METHOD1(OnSeek, void(PipelineStatus));
   MOCK_METHOD0(OnStop, void());
@@ skipping 88 matching lines @@
   }
 
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
-  // Sets up expectations to allow the video decoder to initialize.
-  void InitializeVideoDecoder(const scoped_refptr<DemuxerStream>& stream) {
-    EXPECT_CALL(*mocks_->video_decoder(),
-                Initialize(stream, _, _))
-        .WillOnce(RunPipelineStatusCB1());
-  }
-
   // Sets up expectations to allow the audio decoder to initialize.
   void InitializeAudioDecoder(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, _, _))
         .WillOnce(RunPipelineStatusCB1());
   }
 
   // Sets up expectations to allow the video renderer to initialize.
-  void InitializeVideoRenderer() {
+  void InitializeVideoRenderer(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->video_renderer(), Initialize(
-        scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
-        _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCB1());
+        stream, _, _, _, _, _, _, _, _, _))
+        .WillOnce(RunPipelineStatusCB2());
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->video_renderer(),
                 Preroll(mocks_->demuxer()->GetStartTime(), _))
         .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
         .WillOnce(RunClosure());
   }
 
@@ skipping 224 matching lines @@
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_FALSE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, VideoStream) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, AudioVideoStream) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   // Initialize then seek!
   InitializePipeline(PIPELINE_OK);
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   ExpectSeek(expected);
   DoSeek(expected);
 }
 
@@ skipping 15 matching lines @@
   pipeline_->SetVolume(expected);
 }
 
 TEST_F(PipelineTest, Properties) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetMediaDuration().ToInternalValue());
   EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 }
 
 TEST_F(PipelineTest, GetBufferedTimeRanges) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
 
   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
   pipeline_->AddBufferedByteRange(0, kTotalBytes / 8);
   EXPECT_TRUE(pipeline_->DidLoadingProgress());
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
@@ skipping 34 matching lines @@
 TEST_F(PipelineTest, DisableAudioRenderer) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*mocks_->demuxer(), OnAudioRendererDisabled());
   pipeline_->OnAudioDisabled();
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnRendererEnded();
 }
 
 TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer(true);
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnRendererEnded();
 }
 
 TEST_F(PipelineTest, EndedCallback) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
   InitializePipeline(PIPELINE_OK);
 
   // Due to short circuit evaluation we only need to test a subset of cases.
   InSequence s;
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(false));
   pipeline_->OnRendererEnded();
 
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
@@ skipping 24 matching lines @@
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   // Replace the clock so we can simulate wallclock time advancing w/o using
   // Sleep().
   pipeline_->SetClockForTesting(new Clock(&StaticClockFunction));
 
   InitializeDemuxer(&streams, duration);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
   InitializePipeline(PIPELINE_OK);
 
   EXPECT_EQ(0, pipeline_->GetMediaTime().ToInternalValue());
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
@@ skipping 123 matching lines @@
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineTest, StartTimeIsZero) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
 }
 
 TEST_F(PipelineTest, StartTimeIsNonZero) {
   const base::TimeDelta kStartTime = base::TimeDelta::FromSeconds(4);
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 
   EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
       .WillRepeatedly(Return(kStartTime));
 
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, kDuration);
-  InitializeVideoDecoder(video_stream());
-  InitializeVideoRenderer();
+  InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
 }
 
 static void RunTimeCB(const AudioRenderer::TimeCB& time_cb,
@@ skipping 103 matching lines @@
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(expected_status);
   EXPECT_FALSE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
 }
 
-TEST_F(PipelineTest, InitFailure_VideoDecoder) {
-  CreateAudioStream();
-  CreateVideoStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-  streams.push_back(video_stream());
-
-  InitializeDemuxer(&streams);
-  InitializeAudioDecoder(audio_stream());
-  InitializeAudioRenderer();
-
-  PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
-  scoped_refptr<DemuxerStream> stream = streams[1];
-  EXPECT_CALL(*mocks_->video_decoder(),
-              Initialize(stream, _, _))
-      .WillOnce(RunPipelineStatusCB1WithStatus(expected_status));
-
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  InitializePipeline(expected_status);
-  EXPECT_FALSE(pipeline_->IsInitialized());
-  EXPECT_TRUE(pipeline_->HasAudio());
-  EXPECT_FALSE(pipeline_->HasVideo());
-}
-
 TEST_F(PipelineTest, InitFailure_VideoRenderer) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
 
   PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
+  scoped_refptr<DemuxerStream> stream = streams[1];
   EXPECT_CALL(*mocks_->video_renderer(), Initialize(
-        scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
-        _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCB1WithStatus(expected_status));
+      stream, _, _, _, _, _, _, _, _, _))
+      .WillOnce(RunPipelineStatusCB2WithStatus(expected_status));
 
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(expected_status);
   EXPECT_FALSE(pipeline_->IsInitialized());
@@ skipping 48 matching lines @@
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(0));
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 }  // namespace media