Revert 75444 - Move MockFFmpeg instance setting into the constructor/destruct...

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 87 matching lines @@
     // Initialize AVStream and AVFormatContext structures.  We set the time base
     // of the streams such that duration is reported in microseconds.
     format_context_.nb_streams = AV_STREAM_MAX;
     for (size_t i = 0; i < AV_STREAM_MAX; ++i) {
       format_context_.streams[i] = &streams_[i];
       streams_[i].codec = &codecs_[i];
       streams_[i].duration = kDurations[i];
       streams_[i].time_base.den = 1 * base::Time::kMicrosecondsPerSecond;
       streams_[i].time_base.num = 1;
     }
+
+    // Initialize MockFFmpeg.
+    MockFFmpeg::set(&mock_ffmpeg_);
   }
 
   virtual ~FFmpegDemuxerTest() {
     // Call Stop() to shut down internal threads.
     demuxer_->Stop(NewExpectedCallback());
 
     // Finish up any remaining tasks.
     message_loop_.RunAllPending();
 
     // Release the reference to the demuxer.
     demuxer_ = NULL;
+
+    // Reset MockFFmpeg.
+    MockFFmpeg::set(NULL);
   }
 
   // Sets up MockFFmpeg to allow FFmpegDemuxer to successfully initialize.
   void InitializeDemuxerMocks() {
-    EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
+    EXPECT_CALL(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
         .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
-    EXPECT_CALL(mock_ffmpeg_, AVFindStreamInfo(&format_context_))
+    EXPECT_CALL(*MockFFmpeg::get(), AVFindStreamInfo(&format_context_))
         .WillOnce(Return(0));
-    EXPECT_CALL(mock_ffmpeg_, AVCloseInputFile(&format_context_));
+    EXPECT_CALL(*MockFFmpeg::get(), AVCloseInputFile(&format_context_));
   }
 
   // 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]);
@@ skipping 28 matching lines @@
 const int FFmpegDemuxerTest::kWidth = 1280;
 const int FFmpegDemuxerTest::kHeight = 720;
 
 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))
+  EXPECT_CALL(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(Return(-1));
   EXPECT_CALL(host_, SetError(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
   // Simulate av_find_stream_info() failing.
-  EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
+  EXPECT_CALL(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
-  EXPECT_CALL(mock_ffmpeg_, AVFindStreamInfo(&format_context_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVFindStreamInfo(&format_context_))
       .WillOnce(Return(AVERROR_IO));
-  EXPECT_CALL(mock_ffmpeg_, AVCloseInputFile(&format_context_));
+  EXPECT_CALL(*MockFFmpeg::get(), AVCloseInputFile(&format_context_));
   EXPECT_CALL(host_, SetError(DEMUXER_ERROR_COULD_NOT_PARSE));
 
   demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Simulate media with no parseable streams.
   {
     SCOPED_TRACE("");
@@ skipping 56 matching lines @@
 TEST_F(FFmpegDemuxerTest, Read_DiscardUninteresting) {
   // We test that on a successful audio packet read, that the packet is
   // duplicated (FFmpeg memory management safety), and a copy of it ends up in
   // the DemuxerStream.
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Ignore all AVFreePacket() calls.  We check this elsewhere.
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
+  EXPECT_CALL(*MockFFmpeg::get(), AVFreePacket(_)).Times(AnyNumber());
 
   // The demuxer will read a data packet which will get immediately freed,
   // followed by a read error to end the reading.
   InSequence s;
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_DATA, kNullData, 0));
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(Return(AVERROR_IO));
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<DemuxerStream> audio = demuxer_->GetStream(DS_STREAM_AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(audio);
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_TRUE(reader->buffer()->IsEndOfStream());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
   // We test that on a successful audio packet read, that the packet is
   // duplicated (FFmpeg memory management safety), and a copy of it ends up in
   // the DemuxerStream.
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Ignore all AVFreePacket() calls.  We check this via valgrind.
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
+  EXPECT_CALL(*MockFFmpeg::get(), AVFreePacket(_)).Times(AnyNumber());
 
   // The demuxer will read a data packet which will get immediately freed,
   // followed by reading an audio packet...
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<DemuxerStream> audio = demuxer_->GetStream(DS_STREAM_AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(audio);
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kAudioData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Video) {
   // We test that on a successful video packet read, that the packet is
   // duplicated (FFmpeg memory management safety), and a copy of it ends up in
   // the DemuxerStream.
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Ignore all AVFreePacket() calls.  We check this via valgrind.
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
+  EXPECT_CALL(*MockFFmpeg::get(), AVFreePacket(_)).Times(AnyNumber());
 
   // Simulate a successful frame read.
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_VIDEO, kVideoData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
 
   // Attempt a read from the video stream and run the message loop until done.
   scoped_refptr<DemuxerStream> video = demuxer_->GetStream(DS_STREAM_VIDEO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(video);
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
   // On end of stream, a new, empty, AVPackets are created without any data for
   // each stream and enqueued into the Buffer stream.  Verify that these are
   // indeed inserted.
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Ignore all AVFreePacket() calls.  We check this via valgrind.
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
+  EXPECT_CALL(*MockFFmpeg::get(), AVFreePacket(_)).Times(AnyNumber());
 
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(Return(AVERROR_IO));
 
   // We should now expect an end of stream buffer.
   scoped_refptr<DemuxerStream> audio = demuxer_->GetStream(DS_STREAM_AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_TRUE(reader->buffer()->IsEndOfStream());
@@ skipping 16 matching lines @@
   scoped_refptr<DemuxerStream> video = demuxer_->GetStream(DS_STREAM_VIDEO);
   scoped_refptr<DemuxerStream> audio = demuxer_->GetStream(DS_STREAM_AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Expected values.
   const int64 kExpectedTimestamp = 1234;
   const int64 kExpectedFlags = AVSEEK_FLAG_BACKWARD;
 
   // Ignore all AVFreePacket() calls.  We check this via valgrind.
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
+  EXPECT_CALL(*MockFFmpeg::get(), AVFreePacket(_)).Times(AnyNumber());
 
   // Expect all calls in sequence.
   InSequence s;
 
   // First we'll read a video packet that causes two audio packets to be queued
   // inside FFmpegDemuxer...
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_VIDEO, kVideoData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
 
-  EXPECT_CALL(mock_ffmpeg_, CheckPoint(1));
+  EXPECT_CALL(*MockFFmpeg::get(), CheckPoint(1));
 
   // ...then we'll expect a seek call...
-  EXPECT_CALL(mock_ffmpeg_,
+  EXPECT_CALL(*MockFFmpeg::get(),
       AVSeekFrame(&format_context_, -1, kExpectedTimestamp, kExpectedFlags))
       .WillOnce(Return(0));
 
   // ...then our callback will be executed...
   FilterCallback* seek_callback = NewExpectedCallback();
-  EXPECT_CALL(mock_ffmpeg_, CheckPoint(2));
+  EXPECT_CALL(*MockFFmpeg::get(), CheckPoint(2));
 
   // ...followed by two audio packet reads we'll trigger...
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
 
   // ...followed by two video packet reads...
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_VIDEO, kVideoData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_VIDEO, kVideoData, kDataSize));
-  EXPECT_CALL(mock_ffmpeg_, AVDupPacket(_))
+  EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
 
   // ...and finally a sanity checkpoint to make sure everything was released.
-  EXPECT_CALL(mock_ffmpeg_, CheckPoint(3));
+  EXPECT_CALL(*MockFFmpeg::get(), CheckPoint(3));
 
   // Read a video packet and release it.
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(video);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 
   // Release the video packet and verify the other packets are still queued.
   reader->Reset();
   message_loop_.RunAllPending();
-  mock_ffmpeg_.CheckPoint(1);
+  MockFFmpeg::get()->CheckPoint(1);
 
   // Issue a simple forward seek, which should discard queued packets.
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(kExpectedTimestamp),
                  seek_callback);
   message_loop_.RunAllPending();
-  mock_ffmpeg_.CheckPoint(2);
+  MockFFmpeg::get()->CheckPoint(2);
 
   // Audio read #1.
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kAudioData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 
@@ skipping 23 matching lines @@
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 
   // Manually release the last reference to the buffer and verify it was freed.
   reader->Reset();
   message_loop_.RunAllPending();
-  mock_ffmpeg_.CheckPoint(3);
+  MockFFmpeg::get()->CheckPoint(3);
 }
 
 // A mocked callback specialization for calling Read().  Since RunWithParams()
 // is mocked we don't need to pass in object or method pointers.
 typedef CallbackImpl<FFmpegDemuxerTest,
                      void (FFmpegDemuxerTest::*)(Buffer*),
                      Tuple1<Buffer*> > ReadCallback;
 class MockReadCallback : public ReadCallback {
  public:
   MockReadCallback()
@@ skipping 27 matching lines @@
 
   // Stop the demuxer.
   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));
+  EXPECT_CALL(*MockFFmpeg::get(), CheckPoint(1));
 
   // Attempt the read...
   audio->Read(callback.release());
   message_loop_.RunAllPending();
 
   // ...and verify that |callback| was deleted.
-  mock_ffmpeg_.CheckPoint(1);
+  MockFFmpeg::get()->CheckPoint(1);
 }
 
 TEST_F(FFmpegDemuxerTest, DisableAudioStream) {
   // We are doing the following things here:
   // 1. Initialize the demuxer with audio and video stream.
   // 2. Send a "disable audio stream" message to the demuxer.
   // 3. Demuxer will free audio packets even if audio stream was initialized.
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Submit a "disable audio stream" message to the demuxer.
   demuxer_->OnAudioRendererDisabled();
   message_loop_.RunAllPending();
 
   // Ignore all AVFreePacket() calls.  We check this via valgrind.
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
+  EXPECT_CALL(*MockFFmpeg::get(), AVFreePacket(_)).Times(AnyNumber());
 
   // Expect all calls in sequence.
   InSequence s;
 
   // The demuxer will read an audio packet which will get immediately freed.
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kNullData, 0));
 
   // Then an end-of-stream packet is read.
-  EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
+  EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(Return(AVERROR_IO));
 
   // Get our streams.
   scoped_refptr<DemuxerStream> video = demuxer_->GetStream(DS_STREAM_VIDEO);
   ASSERT_TRUE(video);
 
   // Attempt a read from the video stream and run the message loop until done.
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(video);
   message_loop_.RunAllPending();
@@ skipping 118 matching lines @@
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
   EXPECT_CALL(*data_source_, IsStreaming())
       .WillOnce(Return(false));
   EXPECT_FALSE(demuxer_->IsStreaming());
 }
 
 }  // namespace media