Remove mock_ffmpeg and update media unittests.

media/filters/bitstream_converter_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 "media/base/mock_ffmpeg.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/bitstream_converter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using ::testing::DoAll;
-using ::testing::Mock;
-using ::testing::Return;
-using ::testing::ReturnNull;
-using ::testing::SetArgumentPointee;
-using ::testing::StrEq;
-using ::testing::StrictMock;
-using ::testing::_;
+namespace media {
 
-namespace media {
+static const char kTestFilterName[] = "test_filter";
+static uint8_t kFailData[] = { 3, 2, 1 };
+static uint8_t kNewBufferData[] = { 2, 1 };
+static uint8_t kInPlaceData[] = { 1 };
+static const int kFailSize = 3;
+static const int kNewBufferSize = 2;
+static const int kInPlaceSize = 1;
+
+
+// Test filter function that looks for specific input data and changes it's
+// behavior based on what is passed to |buf| & |buf_size|. The three behaviors
+// simulated are the following:
+// - Create a new output buffer. Triggered by |buf| == |kNewBufferData|.
+// - Use the existing output buffer. Triggered by |buf| == |kInPlaceData|.
+// - Signal an error. Triggered by |buf| == |kFailData|.
+static int DoFilter(AVBitStreamFilterContext* bsfc,
+                    AVCodecContext* avctx,
+                    const char* args,
+                    uint8_t** poutbuf,
+                    int* poutbuf_size,
+                    const uint8_t* buf,
+                    int buf_size,
+                    int keyframe) {
+  if (buf_size == kNewBufferSize &&
+      !memcmp(buf, kNewBufferData, kNewBufferSize)) {
+    *poutbuf_size = buf_size + 1;
+    *poutbuf = static_cast<uint8*>(av_malloc(*poutbuf_size));
+    *poutbuf[0] = 0;
+    memcpy((*poutbuf) + 1, buf, buf_size);
+    return 0;
+  } else if (buf_size == kInPlaceSize &&
+             !memcmp(buf, kInPlaceData, kInPlaceSize)) {
+    return 0;
+  }
+
+  return -1;
+}
+
+static void DoClose(AVBitStreamFilterContext* bsfc) {}
+
+static AVBitStreamFilter g_stream_filter = {
+  kTestFilterName,
+  0, // Private Data Size
+  DoFilter,
+  DoClose,
+  0, // Next filter pointer.
+};
 
 class BitstreamConverterTest : public testing::Test {
  protected:
   BitstreamConverterTest() {
     memset(&test_stream_context_, 0, sizeof(test_stream_context_));
-    memset(&test_filter_, 0, sizeof(test_filter_));
     memset(&test_packet_, 0, sizeof(test_packet_));
-    test_packet_.data = kData1;
-    test_packet_.size = kTestSize1;
+    test_packet_.data = kFailData;
+    test_packet_.size = kFailSize;
   }
 
-  virtual ~BitstreamConverterTest() {}
+  virtual ~BitstreamConverterTest() {
+    av_free_packet(&test_packet_);
+  }
+
+  static void SetUpTestCase() {
+    // Register g_stream_filter if it isn't already registered.
+    if (!g_stream_filter.next)
+      av_register_bitstream_filter(&g_stream_filter);
+  }
 
   AVCodecContext test_stream_context_;
-  AVBitStreamFilterContext test_filter_;
   AVPacket test_packet_;
 
-  StrictMock<MockFFmpeg> mock_ffmpeg_;
-
-  static const char kTestFilterName[];
-  static uint8_t kData1[];
-  static uint8_t kData2[];
-  static const int kTestSize1;
-  static const int kTestSize2;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(BitstreamConverterTest);
 };
 
-const char BitstreamConverterTest::kTestFilterName[] = "test_filter";
-uint8_t BitstreamConverterTest::kData1[] = { 1 };
-uint8_t BitstreamConverterTest::kData2[] = { 2 };
-const int BitstreamConverterTest::kTestSize1 = 1;
-const int BitstreamConverterTest::kTestSize2 = 2;
+TEST_F(BitstreamConverterTest, InitializeFailed) {
+  FFmpegBitstreamConverter converter("BAD_FILTER_NAME", &test_stream_context_);
 
-TEST_F(BitstreamConverterTest, Initialize) {
+  EXPECT_FALSE(converter.Initialize());
+}
+
+TEST_F(BitstreamConverterTest, InitializeSuccess) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
-
-  // Test Initialize returns false on a bad initialization, and cleanup is not
-  // done.
-  EXPECT_CALL(mock_ffmpeg_, AVBitstreamFilterInit(StrEq(kTestFilterName)))
-      .WillOnce(ReturnNull());
-  EXPECT_FALSE(converter.Initialize());
-
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_ffmpeg_));
-
-  // Test Initialize returns true on successful initialization, and cleanup is
-  // done. The cleanup will be activated when the converter object goes out of
-  // scope.
-  EXPECT_CALL(mock_ffmpeg_, AVBitstreamFilterInit(StrEq(kTestFilterName)))
-      .WillOnce(Return(&test_filter_));
-  EXPECT_CALL(mock_ffmpeg_, AVBitstreamFilterClose(&test_filter_));
   EXPECT_TRUE(converter.Initialize());
 }
 
 TEST_F(BitstreamConverterTest, ConvertPacket_NotInitialized) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
   EXPECT_FALSE(converter.ConvertPacket(&test_packet_));
 }
 
 TEST_F(BitstreamConverterTest, ConvertPacket_FailedFilter) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
-  // Inject mock filter instance.
-  converter.stream_filter_ = &test_filter_;
-
-  // Simulate a successful filter call, that allocates a new data buffer.
-  EXPECT_CALL(mock_ffmpeg_,
-              AVBitstreamFilterFilter(&test_filter_, &test_stream_context_,
-                                      NULL, _, _,
-                                      test_packet_.data, test_packet_.size, _))
-      .WillOnce(Return(AVERROR(EINVAL)));
+  EXPECT_TRUE(converter.Initialize());
 
   EXPECT_FALSE(converter.ConvertPacket(&test_packet_));
-
-  // Uninject mock filter instance to avoid cleanup code on destruction of
-  // converter.
-  converter.stream_filter_ = NULL;
 }
 
 TEST_F(BitstreamConverterTest, ConvertPacket_Success) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
-  // Inject mock filter instance.
-  converter.stream_filter_ = &test_filter_;
+  EXPECT_TRUE(converter.Initialize());
 
   // Ensure our packet doesn't already have a destructor.
   ASSERT_TRUE(test_packet_.destruct == NULL);
 
-  // Simulate a successful filter call, that allocates a new data buffer.
-  EXPECT_CALL(mock_ffmpeg_,
-              AVBitstreamFilterFilter(&test_filter_, &test_stream_context_,
-                                      NULL, _, _,
-                                      test_packet_.data, test_packet_.size, _))
-      .WillOnce(DoAll(SetArgumentPointee<3>(&kData2[0]),
-                      SetArgumentPointee<4>(kTestSize2),
-                      Return(0)));
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(&test_packet_));
+  test_packet_.data = kNewBufferData;
+  test_packet_.size = kNewBufferSize;
 
   EXPECT_TRUE(converter.ConvertPacket(&test_packet_));
-  EXPECT_EQ(kData2, test_packet_.data);
-  EXPECT_EQ(kTestSize2, test_packet_.size);
+  EXPECT_NE(kNewBufferData, test_packet_.data);
+  EXPECT_EQ(kNewBufferSize + 1, test_packet_.size);
   EXPECT_TRUE(test_packet_.destruct != NULL);
-
-  // Uninject mock filter instance to avoid cleanup code on destruction of
-  // converter.
-  converter.stream_filter_ = NULL;
 }
 
 TEST_F(BitstreamConverterTest, ConvertPacket_SuccessInPlace) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
-  // Inject mock filter instance.
-  converter.stream_filter_ = &test_filter_;
+  EXPECT_TRUE(converter.Initialize());
 
   // Ensure our packet is in a sane start state.
   ASSERT_TRUE(test_packet_.destruct == NULL);
-  ASSERT_EQ(kData1, test_packet_.data);
-  ASSERT_EQ(kTestSize1, test_packet_.size);
-
-  // Simulate a successful filter call, that reuses the input buffer.  We should
-  // not free the packet here or alter the packet's destructor.
-  EXPECT_CALL(mock_ffmpeg_,
-              AVBitstreamFilterFilter(&test_filter_, &test_stream_context_,
-                                      NULL, _, _,
-                                      test_packet_.data, test_packet_.size, _))
-      .WillOnce(DoAll(SetArgumentPointee<3>(test_packet_.data),
-                      SetArgumentPointee<4>(test_packet_.size),
-                      Return(0)));
+  test_packet_.data = kInPlaceData;
+  test_packet_.size = kInPlaceSize;
 
   EXPECT_TRUE(converter.ConvertPacket(&test_packet_));
-  EXPECT_EQ(kData1, test_packet_.data);
-  EXPECT_EQ(kTestSize1, test_packet_.size);
+  EXPECT_EQ(kInPlaceData, test_packet_.data);
+  EXPECT_EQ(kInPlaceSize, test_packet_.size);
   EXPECT_TRUE(test_packet_.destruct == NULL);
-
-  // Uninject mock filter instance to avoid cleanup code on destruction of
-  // converter.
-  converter.stream_filter_ = NULL;
 }
 
 }  // namespace media