DemuxerFactory is born!

media/filters/ffmpeg_demuxer_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 <deque>
 
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_ffmpeg.h"
@@ skipping 54 matching lines @@
 
   FFmpegDemuxerTest() {
     // Create an FFmpegDemuxer.
     demuxer_ = new FFmpegDemuxer(&message_loop_);
     DCHECK(demuxer_);
 
     // Inject a filter host and message loop and prepare a data source.
     demuxer_->set_host(&host_);
     data_source_ = new StrictMock<MockDataSource>();
 
+    EXPECT_CALL(*data_source_, Stop(NotNull()))
+        .WillRepeatedly(Invoke(&RunStopFilterCallback));
+
     // Initialize FFmpeg fixtures.
     memset(&format_context_, 0, sizeof(format_context_));
     memset(&input_format_, 0, sizeof(input_format_));
     memset(&streams_, 0, sizeof(streams_));
     memset(&codecs_, 0, sizeof(codecs_));
 
     // Initialize AVCodecContext structures.
     codecs_[AV_STREAM_DATA].codec_type = CODEC_TYPE_DATA;
     codecs_[AV_STREAM_DATA].codec_id = CODEC_ID_NONE;
 
@@ skipping 45 matching lines @@
   // Initializes both MockFFmpeg and FFmpegDemuxer.
   void InitializeDemuxer() {
     InitializeDemuxerMocks();
 
     // Since we ignore data streams, the duration should be equal to the longest
     // supported stream's duration (audio, in this case).
     base::TimeDelta expected_duration =
         base::TimeDelta::FromMicroseconds(kDurations[AV_STREAM_AUDIO]);
     EXPECT_CALL(host_, SetDuration(expected_duration));
 
-    demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
+    demuxer_->Initialize(data_source_.get(),
+                         NewExpectedStatusCallback(PIPELINE_OK));
     message_loop_.RunAllPending();
   }
 
   // Fixture members.
   scoped_refptr<FFmpegDemuxer> demuxer_;
   scoped_refptr<StrictMock<MockDataSource> > data_source_;
   StrictMock<MockFilterHost> host_;
   MessageLoop message_loop_;
 
   // FFmpeg fixtures.
@@ skipping 17 matching lines @@
 
 const size_t FFmpegDemuxerTest::kDataSize = 4;
 const uint8 FFmpegDemuxerTest::kAudioData[kDataSize] = {0, 1, 2, 3};
 const uint8 FFmpegDemuxerTest::kVideoData[kDataSize] = {4, 5, 6, 7};
 const uint8* FFmpegDemuxerTest::kNullData = NULL;
 
 TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
   // Simulate av_open_input_file() failing.
   EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(Return(-1));
-  EXPECT_CALL(host_, SetError(DEMUXER_ERROR_COULD_NOT_OPEN));
 
-  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
+  demuxer_->Initialize(data_source_.get(),
+                       NewExpectedStatusCallback(DEMUXER_ERROR_COULD_NOT_OPEN));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
   // Simulate av_find_stream_info() failing.
   EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
   EXPECT_CALL(mock_ffmpeg_, AVFindStreamInfo(&format_context_))
       .WillOnce(Return(AVERROR_IO));
   EXPECT_CALL(mock_ffmpeg_, AVCloseInputFile(&format_context_));
-  EXPECT_CALL(host_, SetError(DEMUXER_ERROR_COULD_NOT_PARSE));
 
-  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
+  demuxer_->Initialize(
+      data_source_.get(),
+      NewExpectedStatusCallback(DEMUXER_ERROR_COULD_NOT_PARSE));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Simulate media with no parseable streams.
   {
     SCOPED_TRACE("");
     InitializeDemuxerMocks();
   }
-  EXPECT_CALL(host_, SetError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   format_context_.nb_streams = 0;
 
-  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
+  demuxer_->Initialize(
+      data_source_.get(),
+      NewExpectedStatusCallback(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_DataStreamOnly) {
   // Simulate media with a data stream but no audio or video streams.
   {
     SCOPED_TRACE("");
     InitializeDemuxerMocks();
   }
-  EXPECT_CALL(host_, SetError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   EXPECT_EQ(format_context_.streams[0], &streams_[AV_STREAM_DATA]);
   format_context_.nb_streams = 1;
 
-  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
+  demuxer_->Initialize(
+      data_source_.get(),
+      NewExpectedStatusCallback(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Verify that our demuxer streams were created from our AVStream structures.
@@ skipping 315 matching lines @@
 
   // Create our mocked callback.  The demuxer will take ownership of this
   // pointer.
   scoped_ptr<StrictMock<MockReadCallback> > callback(
       new StrictMock<MockReadCallback>());
 
   // Get our stream.
   scoped_refptr<DemuxerStream> audio = demuxer_->GetStream(DS_STREAM_AUDIO);
   ASSERT_TRUE(audio);
 
-  // Stop the demuxer.
+  // Stop the demuxer, overriding the default expectation to assert that
+  // data_source_ really is Stop()'d.
+  EXPECT_CALL(*data_source_, Stop(_))
+      .WillOnce(Invoke(&RunStopFilterCallback))
+      .RetiresOnSaturation();
   demuxer_->Stop(NewExpectedCallback());
 
   // Expect all calls in sequence.
   InSequence s;
 
   // The callback should be immediately deleted.  We'll use a checkpoint to
   // verify that it has indeed been deleted.
   EXPECT_CALL(*callback, OnDelete());
   EXPECT_CALL(mock_ffmpeg_, CheckPoint(1));
 
@@ skipping 162 matching lines @@
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
   EXPECT_CALL(*data_source_, IsStreaming())
       .WillOnce(Return(false));
   EXPECT_FALSE(demuxer_->IsStreaming());
 }
 
 }  // namespace media