Replace MockFilterCallback with MockCallback and simplify unit tests.

media/filters/ffmpeg_demuxer_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/callback.h"
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
+#include "media/base/mock_callback.h"
 #include "media/base/mock_ffmpeg.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "media/base/mock_reader.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::DoAll;
@@ skipping 86 matching lines @@
       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.
-    EXPECT_CALL(callback_, OnFilterCallback());
-    EXPECT_CALL(callback_, OnCallbackDestroyed());
-    demuxer_->Stop(callback_.NewCallback());
+    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(*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(callback_, OnFilterCallback());
-    EXPECT_CALL(callback_, OnCallbackDestroyed());
-
     // 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(), callback_.NewCallback());
+    demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
     message_loop_.RunAllPending();
   }
 
   // Fixture members.
   scoped_refptr<FFmpegDemuxer> demuxer_;
   scoped_refptr<StrictMock<MockDataSource> > data_source_;
   StrictMock<MockFilterHost> host_;
-  StrictMock<MockFilterCallback> callback_;
   MessageLoop message_loop_;
 
   // FFmpeg fixtures.
   AVFormatContext format_context_;
   AVInputFormat input_format_;
   AVCodecContext codecs_[AV_STREAM_MAX];
   AVStream streams_[AV_STREAM_MAX];
   MockFFmpeg mock_ffmpeg_;
 
  private:
@@ skipping 11 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(*MockFFmpeg::get(), AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(Return(-1));
   EXPECT_CALL(host_, SetError(DEMUXER_ERROR_COULD_NOT_OPEN));
-  EXPECT_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
 
-  demuxer_->Initialize(data_source_.get(), callback_.NewCallback());
+  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
   message_loop_.RunAllPending();
 }
 
 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_, SetError(DEMUXER_ERROR_COULD_NOT_PARSE));
-  EXPECT_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
 
-  demuxer_->Initialize(data_source_.get(), callback_.NewCallback());
+  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
   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));
-  EXPECT_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
   format_context_.nb_streams = 0;
 
-  demuxer_->Initialize(data_source_.get(), callback_.NewCallback());
+  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
   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_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
   EXPECT_EQ(format_context_.streams[0], &streams_[AV_STREAM_DATA]);
   format_context_.nb_streams = 1;
 
-  demuxer_->Initialize(data_source_.get(), callback_.NewCallback());
+  demuxer_->Initialize(data_source_.get(), NewExpectedCallback());
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Verify that our demuxer streams were created from our AVStream structures.
@@ skipping 187 matching lines @@
       .WillOnce(Return(0));
 
   EXPECT_CALL(*MockFFmpeg::get(), CheckPoint(1));
 
   // ...then we'll expect a seek call...
   EXPECT_CALL(*MockFFmpeg::get(),
       AVSeekFrame(&format_context_, -1, kExpectedTimestamp, kExpectedFlags))
       .WillOnce(Return(0));
 
   // ...then our callback will be executed...
-  StrictMock<MockFilterCallback> seek_callback;
-  EXPECT_CALL(seek_callback, OnFilterCallback());
-  EXPECT_CALL(seek_callback, OnCallbackDestroyed());
+  FilterCallback* seek_callback = NewExpectedCallback();
   EXPECT_CALL(*MockFFmpeg::get(), CheckPoint(2));
 
   // ...followed by two audio packet reads we'll trigger...
   EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
   EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
       .WillOnce(Return(0));
   EXPECT_CALL(*MockFFmpeg::get(), AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kAudioData, kDataSize));
   EXPECT_CALL(*MockFFmpeg::get(), AVDupPacket(_))
@@ skipping 22 matching lines @@
   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();
   MockFFmpeg::get()->CheckPoint(1);
 
   // Issue a simple forward seek, which should discard queued packets.
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(kExpectedTimestamp),
-                 seek_callback.NewCallback());
+                 seek_callback);
   message_loop_.RunAllPending();
   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(),
@@ skipping 65 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.
-  EXPECT_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
-  demuxer_->Stop(callback_.NewCallback());
+  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(*MockFFmpeg::get(), CheckPoint(1));
 
   // Attempt the read...
@@ skipping 104 matching lines @@
   // Second read.
   EXPECT_EQ(512, demuxer->Read(512, kBuffer));
   EXPECT_TRUE(demuxer->GetPosition(&position));
   EXPECT_EQ(1024, position);
 
   // Third read will get an end-of-file error.
   EXPECT_EQ(AVERROR_EOF, demuxer->Read(512, kBuffer));
 
   // This read complete signal is generated when demuxer is stopped.
   EXPECT_CALL(*demuxer, SignalReadCompleted(DataSource::kReadError));
-  EXPECT_CALL(callback_, OnFilterCallback());
-  EXPECT_CALL(callback_, OnCallbackDestroyed());
-  demuxer->Stop(callback_.NewCallback());
+  demuxer->Stop(NewExpectedCallback());
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, ProtocolGetSetPosition) {
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   InSequence s;
@@ skipping 34 matching lines @@
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
   EXPECT_CALL(*data_source_, IsStreaming())
       .WillOnce(Return(false));
   EXPECT_FALSE(demuxer_->IsStreaming());
 }
 
 }  // namespace media