Updated FFmpegDemuxerTest and FFmpegVideoDecoderTest to use the gmock-based MockFilterHost.

media/filters/ffmpeg_demuxer_unittest.cc

 // Copyright (c) 2009 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 "media/base/filters.h"
 #include "media/base/mock_ffmpeg.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 48 matching lines @@
 
   FFmpegDemuxerTest() {
     // Create an FFmpegDemuxer.
     factory_ = FFmpegDemuxer::CreateFilterFactory();
     MediaFormat media_format;
     media_format.SetAsString(MediaFormat::kMimeType,
                              mime_type::kApplicationOctetStream);
     demuxer_ = factory_->Create<FFmpegDemuxer>(media_format);
     DCHECK(demuxer_);
 
-    // Provide a message loop.
+    // Inject a filter host and message loop and prepare a data source.
+    demuxer_->SetFilterHost(&host_);
     demuxer_->SetMessageLoop(&message_loop_);
-
-    // Prepare a filter host and data source for the demuxer.
-    pipeline_.reset(new MockPipeline());
-    filter_host_.reset(new old_mocks::MockFilterHost<Demuxer>(pipeline_.get(),
-                                                              demuxer_));
     data_source_ = new StrictMock<MockDataSource>();
 
     // Initialize FFmpeg fixtures.
     memset(&format_context_, 0, sizeof(format_context_));
     memset(&streams_, 0, sizeof(streams_));
     memset(&codecs_, 0, sizeof(codecs_));
 
     // Initialize AVCodexContext structures.
     codecs_[AV_STREAM_DATA].codec_type = CODEC_TYPE_DATA;
     codecs_[AV_STREAM_DATA].codec_id = CODEC_ID_NONE;
@@ skipping 26 matching lines @@
   virtual ~FFmpegDemuxerTest() {
     // Call Stop() to shut down internal threads.
     demuxer_->Stop();
 
     // Finish up any remaining tasks.
     message_loop_.RunAllPending();
 
     // Release the reference to the demuxer.
     demuxer_ = NULL;
 
-    // Filter host also holds a reference to demuxer, destroy it.
-    filter_host_.reset();
-
     // Reset MockFFmpeg.
     MockFFmpeg::set(NULL);
   }
 
   // Sets up MockFFmpeg to allow FFmpegDemuxer to successfully initialize.
   void InitializeDemuxerMocks() {
     EXPECT_CALL(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
         .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
     EXPECT_CALL(*MockFFmpeg::get(), AVFindStreamInfo(&format_context_))
         .WillOnce(Return(0));
     EXPECT_CALL(*MockFFmpeg::get(), AVCloseInputFile(&format_context_));
   }
 
   // Initializes both MockFFmpeg and FFmpegDemuxer.
   void InitializeDemuxer() {
     InitializeDemuxerMocks();
+
+    // We expect a successful initialization.
+    EXPECT_CALL(host_, InitializationComplete());
+
+    // 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));
+
     EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
     message_loop_.RunAllPending();
-    EXPECT_TRUE(filter_host_->WaitForInitialized());
-    EXPECT_TRUE(filter_host_->IsInitialized());
-    EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   }
 
   // Fixture members.
   scoped_refptr<FilterFactory> factory_;
   scoped_refptr<FFmpegDemuxer> demuxer_;
-  scoped_ptr<MockPipeline> pipeline_;
-  scoped_ptr<old_mocks::MockFilterHost<Demuxer> > filter_host_;
   scoped_refptr<StrictMock<MockDataSource> > data_source_;
+  StrictMock<MockFilterHost> host_;
   MessageLoop message_loop_;
 
   // FFmpeg fixtures.
   AVFormatContext format_context_;
   AVCodecContext codecs_[AV_STREAM_MAX];
   AVStream streams_[AV_STREAM_MAX];
   MockFFmpeg mock_ffmpeg_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
@@ skipping 25 matching lines @@
   media_format.SetAsString(MediaFormat::kMimeType,
                            mime_type::kApplicationOctetStream);
   demuxer = factory->Create<Demuxer>(media_format);
   ASSERT_TRUE(demuxer);
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
   // Simulate av_open_input_file() failing.
   EXPECT_CALL(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(Return(-1));
+  EXPECT_CALL(host_, Error(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   message_loop_.RunAllPending();
-  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_COULD_NOT_OPEN));
-  EXPECT_FALSE(filter_host_->IsInitialized());
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
   // Simulate av_find_stream_info() failing.
   EXPECT_CALL(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
   EXPECT_CALL(*MockFFmpeg::get(), AVFindStreamInfo(&format_context_))
       .WillOnce(Return(AVERROR_IO));
   EXPECT_CALL(*MockFFmpeg::get(), AVCloseInputFile(&format_context_));
+  EXPECT_CALL(host_, Error(DEMUXER_ERROR_COULD_NOT_PARSE));
 
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   message_loop_.RunAllPending();
-  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_COULD_NOT_PARSE));
-  EXPECT_FALSE(filter_host_->IsInitialized());
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Simulate media with no parseable streams.
   {
     SCOPED_TRACE("");
     InitializeDemuxerMocks();
   }
+  EXPECT_CALL(host_, Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   format_context_.nb_streams = 0;
 
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   message_loop_.RunAllPending();
-  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
-  EXPECT_FALSE(filter_host_->IsInitialized());
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_DataStreamOnly) {
   // Simulate media with a data stream but no audio or video streams.
   {
     SCOPED_TRACE("");
     InitializeDemuxerMocks();
   }
+  EXPECT_CALL(host_, Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   EXPECT_EQ(format_context_.streams[0], &streams_[AV_STREAM_DATA]);
   format_context_.nb_streams = 1;
 
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   message_loop_.RunAllPending();
-  EXPECT_TRUE(filter_host_->WaitForError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
-  EXPECT_FALSE(filter_host_->IsInitialized());
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Verify that our demuxer streams were created from our AVStream structures.
   EXPECT_EQ(DS_STREAM_MAX, static_cast<int>(demuxer_->GetNumberOfStreams()));
 
-  // Since we ignore data streams, the duration should be equal to the longest
-  // supported stream's duration (audio, in this case).
-  EXPECT_EQ(kDurations[AV_STREAM_AUDIO],
-            pipeline_->GetDuration().InMicroseconds());
-
   // First stream should be video and support the FFmpegDemuxerStream interface.
   scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(DS_STREAM_VIDEO);
   AVStreamProvider* av_stream_provider = NULL;
   ASSERT_TRUE(stream);
   std::string mime_type;
   EXPECT_TRUE(
       stream->media_format().GetAsString(MediaFormat::kMimeType, &mime_type));
   EXPECT_STREQ(mime_type::kFFmpegVideo, mime_type.c_str());
   EXPECT_TRUE(stream->QueryInterface(&av_stream_provider));
   EXPECT_TRUE(av_stream_provider);
@@ skipping 377 matching lines @@
 
   // Attempt the read...
   audio->Read(callback.release());
   message_loop_.RunAllPending();
 
   // ...and verify that |callback| was deleted.
   MockFFmpeg::get()->CheckPoint(1);
 }
 
 }  // namespace media