DemuxerFactory is born!

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/callback.h"
 #include "base/stl_util-inl.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::InSequence;
 using ::testing::Invoke;
+using ::testing::InvokeArgument;

[acolwell GONE FROM CHROMIUM, 2011/03/08 21:48:09]

Is this still needed?

[Ami GONE FROM CHROMIUM, 2011/03/08 22:44:48]

Nope, deleted.

 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::StrictMock;
 
 namespace {
 
 // Total bytes of the data source.
 const int kTotalBytes = 1024;
@@ skipping 52 matching lines @@
                                 &CallbackHelper::OnStop));
     message_loop_.RunAllPending();
 
     // Free allocated media formats (if any).
     STLDeleteElements(&stream_media_formats_);
 
     mocks_.reset();
   }
 
  protected:
-  // Sets up expectations to allow the data source to initialize.
-  void InitializeDataSource() {
-    mocks_->data_source()->SetTotalAndBufferedBytes(kTotalBytes,
-                                                    kBufferedBytes);
-
-    EXPECT_CALL(*mocks_->data_source(), SetPlaybackRate(0.0f));
-    EXPECT_CALL(*mocks_->data_source(), Seek(base::TimeDelta(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
-    EXPECT_CALL(*mocks_->data_source(), Stop(NotNull()))
-        .WillOnce(Invoke(&RunStopFilterCallback));
-  }
-
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
-    EXPECT_CALL(*mocks_->demuxer(),
-                Initialize(mocks_->data_source(), NotNull()))
-        .WillOnce(DoAll(SetDuration(mocks_->data_source(), duration),
-                        Invoke(&RunFilterCallback)));
+    mocks_->demuxer()->SetTotalAndBufferedBytesAndDuration(
+        kTotalBytes, kBufferedBytes, duration);
     EXPECT_CALL(*mocks_->demuxer(), GetNumberOfStreams())
         .WillRepeatedly(Return(streams->size()));
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->demuxer(), Seek(base::TimeDelta(), NotNull()))
         .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->demuxer(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
@@ skipping 102 matching lines @@
   MockDemuxerStream* audio_stream() {
     return audio_stream_;
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
-    EXPECT_CALL(*mocks_->data_source(), Seek(seek_time, NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, NotNull()))
         .WillOnce(Invoke(&RunFilterCallback));
 
     if (audio_stream_) {
       EXPECT_CALL(*mocks_->audio_decoder(), Seek(seek_time, NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
       EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
     }
 
     if (video_stream_) {
       EXPECT_CALL(*mocks_->video_decoder(), Seek(seek_time, NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
       EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
     }
 
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek());
 
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
                     NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                 &CallbackHelper::OnSeek));
 
     // We expect the time to be updated only after the seek has completed.
-    EXPECT_TRUE(seek_time != pipeline_->GetCurrentTime());
+    EXPECT_NE(seek_time, pipeline_->GetCurrentTime());
     message_loop_.RunAllPending();
-    EXPECT_TRUE(seek_time == pipeline_->GetCurrentTime());
+    EXPECT_EQ(seek_time, pipeline_->GetCurrentTime());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   MessageLoop message_loop_;
   scoped_refptr<PipelineImpl> pipeline_;
   scoped_ptr<media::MockFilterCollection> mocks_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
 
@@ skipping 100 matching lines @@
   EXPECT_CALL(callbacks_, OnError());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
   EXPECT_FALSE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_ERROR_URL_NOT_FOUND, pipeline_->GetError());
 }
 
 TEST_F(PipelineImplTest, NoStreams) {
   // Manually set these expectations because SetPlaybackRate() is not called if
   // we cannot fully initialize the pipeline.
-  EXPECT_CALL(*mocks_->data_source(), Stop(NotNull()))
-      .WillOnce(Invoke(&RunStopFilterCallback));
-
-  EXPECT_CALL(*mocks_->demuxer(), Initialize(mocks_->data_source(), NotNull()))
-      .WillOnce(Invoke(&RunFilterCallback));
   EXPECT_CALL(*mocks_->demuxer(), GetNumberOfStreams())
       .WillRepeatedly(Return(0));
   EXPECT_CALL(*mocks_->demuxer(), Stop(NotNull()))
       .WillOnce(Invoke(&RunStopFilterCallback));
   EXPECT_CALL(callbacks_, OnError());
 
   InitializePipeline();
   EXPECT_FALSE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_ERROR_COULD_NOT_RENDER, pipeline_->GetError());
 }
 
 TEST_F(PipelineImplTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeAudio));
   EXPECT_FALSE(pipeline_->IsRendered(media::mime_type::kMajorTypeVideo));
 }
 
 TEST_F(PipelineImplTest, VideoStream) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_FALSE(pipeline_->IsRendered(media::mime_type::kMajorTypeAudio));
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeVideo));
 }
 
 TEST_F(PipelineImplTest, AudioVideoStream) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeAudio));
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeVideo));
 }
 
 TEST_F(PipelineImplTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   ExpectSeek(expected);
 
   // Initialize then seek!
   InitializePipeline();
   DoSeek(expected);
 }
 
 TEST_F(PipelineImplTest, SetVolume) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(expected));
 
   // Initialize then set volume!
   InitializePipeline();
   pipeline_->SetVolume(expected);
 }
 
 TEST_F(PipelineImplTest, Properties) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetMediaDuration().ToInternalValue());
   EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
   EXPECT_EQ(kBufferedBytes, pipeline_->GetBufferedBytes());
 
   // Because kTotalBytes and kBufferedBytes are equal to each other,
   // the entire video should be buffered.
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetBufferedTime().ToInternalValue());
 }
 
 TEST_F(PipelineImplTest, GetBufferedTime) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // TODO(vrk): The following mini-test cases are order-dependent, and should
@@ skipping 49 matching lines @@
             pipeline_->GetBufferedTime().ToInternalValue());
 }
 
 TEST_F(PipelineImplTest, DisableAudioRenderer) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->IsRendered(mime_type::kMajorTypeAudio));
   EXPECT_TRUE(pipeline_->IsRendered(mime_type::kMajorTypeVideo));
 
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(1.0f))
       .WillOnce(DisableAudioRenderer(mocks_->audio_renderer()));
-  EXPECT_CALL(*mocks_->data_source(),
-              OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_renderer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_renderer(),
               OnAudioRendererDisabled());
 
   mocks_->audio_renderer()->SetPlaybackRate(1.0f);
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded());
   FilterHost* host = pipeline_;
   host->NotifyEnded();
 }
 
 TEST_F(PipelineImplTest, DisableAudioRendererDuringInit) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer(true);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
-  EXPECT_CALL(*mocks_->data_source(),
-              OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_renderer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_renderer(),
               OnAudioRendererDisabled());
@@ skipping 12 matching lines @@
   host->NotifyEnded();
 }
 
 TEST_F(PipelineImplTest, EndedCallback) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
   InitializePipeline();
 
   // For convenience to simulate filters calling the methods.
   FilterHost* host = pipeline_;
 
@@ skipping 25 matching lines @@
 
 TEST_F(PipelineImplTest, AudioStreamShorterThanVideo) {
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, duration);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
   InitializePipeline();
 
   // For convenience to simulate filters calling the methods.
   FilterHost* host = pipeline_;
 
   // Replace the clock so we can simulate wallclock time advancing w/o using
   // Sleep().
   pipeline_->SetClockForTesting(new Clock(&StaticClockFunction));
 
   EXPECT_EQ(0, host->GetTime().ToInternalValue());
 
   float playback_rate = 1.0f;
-  EXPECT_CALL(*mocks_->data_source(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->video_decoder(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_decoder(), 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();
 
   InSequence s;
 
@@ skipping 25 matching lines @@
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded());
   host->NotifyEnded();
 }
 
 TEST_F(PipelineImplTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDataSource();
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializePipeline();
 
   float playback_rate = 1.0f;
-  EXPECT_CALL(*mocks_->data_source(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_decoder(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   InSequence s;
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
-  EXPECT_CALL(*mocks_->data_source(), Seek(seek_time, NotNull()))
-      .WillOnce(Invoke(&RunFilterCallback));
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, NotNull()))
       .WillOnce(DoAll(SetError(mocks_->demuxer(),
                                PIPELINE_ERROR_READ),
                       Invoke(&RunFilterCallback)));
 
   pipeline_->Seek(seek_time, NewExpectedCallback());
   EXPECT_CALL(callbacks_, OnError());
   message_loop_.RunAllPending();
 }
 
 }  // namespace media