Added FakeGlVideoDecodeEngine to exercise the IPC protocol for hardware video decoding

media/video/ffmpeg_video_decode_engine_unittest.cc

 // Copyright (c) 2010 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 "base/scoped_ptr.h"
 #include "media/base/data_buffer.h"
 #include "media/base/mock_ffmpeg.h"
 #include "media/base/mock_task.h"
 #include "media/video/ffmpeg_video_decode_engine.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 67 matching lines @@
         .WillOnce(Return(&codec_));
     EXPECT_CALL(*MockFFmpeg::get(), AVCodecAllocFrame())
         .WillOnce(Return(&yuv_frame_));
     EXPECT_CALL(*MockFFmpeg::get(), AVCodecThreadInit(&codec_context_, 2))
         .WillOnce(Return(0));
     EXPECT_CALL(*MockFFmpeg::get(), AVCodecOpen(&codec_context_, &codec_))
         .WillOnce(Return(0));
     EXPECT_CALL(*MockFFmpeg::get(), AVFree(&yuv_frame_))
         .Times(1);
 
-    config_.codec_ = kCodecH264;
-    config_.opaque_context_ = &stream_;
-    config_.width_ = kWidth;
-    config_.height_ = kHeight;
+    config_.codec = kCodecH264;
+    config_.opaque_context = &stream_;
+    config_.width = kWidth;
+    config_.height = kHeight;
     EXPECT_CALL(*this, OnInitializeComplete(_))
        .WillOnce(SaveInitializeResult(this));
     test_engine_->Initialize(MessageLoop::current(), this, config_);
-    EXPECT_TRUE(info_.success_);
+    EXPECT_TRUE(info_.success);
   }
 
  public:
   MOCK_METHOD1(ConsumeVideoFrame,
                void(scoped_refptr<VideoFrame> video_frame));
   MOCK_METHOD1(ProduceVideoSample,
                void(scoped_refptr<Buffer> buffer));
   MOCK_METHOD1(OnInitializeComplete,
                void(const VideoCodecInfo& info));
   MOCK_METHOD0(OnUninitializeComplete, void());
@@ skipping 24 matching lines @@
 
 TEST_F(FFmpegVideoDecodeEngineTest, Initialize_FindDecoderFails) {
   // Test avcodec_find_decoder() returning NULL.
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecFindDecoder(CODEC_ID_NONE))
       .WillOnce(ReturnNull());
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecAllocFrame())
       .WillOnce(Return(&yuv_frame_));
   EXPECT_CALL(*MockFFmpeg::get(), AVFree(&yuv_frame_))
       .Times(1);
 
-  config_.codec_ = kCodecH264;
-  config_.opaque_context_ = &stream_;
-  config_.width_ = kWidth;
-  config_.height_ = kHeight;
+  config_.codec = kCodecH264;
+  config_.opaque_context = &stream_;
+  config_.width = kWidth;
+  config_.height = kHeight;
   EXPECT_CALL(*this, OnInitializeComplete(_))
      .WillOnce(SaveInitializeResult(this));
   test_engine_->Initialize(MessageLoop::current(), this, config_);
-  EXPECT_FALSE(info_.success_);
+  EXPECT_FALSE(info_.success);
 }
 
 // Note There are 2 threads for FFmpeg-mt.
 TEST_F(FFmpegVideoDecodeEngineTest, Initialize_InitThreadFails) {
   // Test avcodec_thread_init() failing.
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecFindDecoder(CODEC_ID_NONE))
       .WillOnce(Return(&codec_));
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecAllocFrame())
       .WillOnce(Return(&yuv_frame_));
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecThreadInit(&codec_context_, 2))
       .WillOnce(Return(-1));
   EXPECT_CALL(*MockFFmpeg::get(), AVFree(&yuv_frame_))
       .Times(1);
 
-  config_.codec_ = kCodecH264;
-  config_.opaque_context_ = &stream_;
-  config_.width_ = kWidth;
-  config_.height_ = kHeight;
+  config_.codec = kCodecH264;
+  config_.opaque_context = &stream_;
+  config_.width = kWidth;
+  config_.height = kHeight;
   EXPECT_CALL(*this, OnInitializeComplete(_))
      .WillOnce(SaveInitializeResult(this));
   test_engine_->Initialize(MessageLoop::current(), this, config_);
-  EXPECT_FALSE(info_.success_);
+  EXPECT_FALSE(info_.success);
 }
 
 TEST_F(FFmpegVideoDecodeEngineTest, Initialize_OpenDecoderFails) {
   // Test avcodec_open() failing.
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecFindDecoder(CODEC_ID_NONE))
       .WillOnce(Return(&codec_));
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecAllocFrame())
       .WillOnce(Return(&yuv_frame_));
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecThreadInit(&codec_context_, 2))
       .WillOnce(Return(0));
   EXPECT_CALL(*MockFFmpeg::get(), AVCodecOpen(&codec_context_, &codec_))
       .WillOnce(Return(-1));
   EXPECT_CALL(*MockFFmpeg::get(), AVFree(&yuv_frame_))
       .Times(1);
 
-  config_.codec_ = kCodecH264;
-  config_.opaque_context_ = &stream_;
-  config_.width_ = kWidth;
-  config_.height_ = kHeight;
+  config_.codec = kCodecH264;
+  config_.opaque_context = &stream_;
+  config_.width = kWidth;
+  config_.height = kHeight;
   EXPECT_CALL(*this, OnInitializeComplete(_))
      .WillOnce(SaveInitializeResult(this));
   test_engine_->Initialize(MessageLoop::current(), this, config_);
-  EXPECT_FALSE(info_.success_);
+  EXPECT_FALSE(info_.success);
 }
 
 ACTION_P2(DemuxComplete, engine, buffer) {
   engine->ConsumeVideoSample(buffer);
 }
 
 ACTION_P(DecodeComplete, decoder) {
   decoder->video_frame_ = arg0;
 }
 
@@ skipping 80 matching lines @@
   EXPECT_EQ(VideoFrame::YV16, test_engine_->GetSurfaceFormat());
   codec_context_.pix_fmt = PIX_FMT_YUVJ422P;
   EXPECT_EQ(VideoFrame::YV16, test_engine_->GetSurfaceFormat());
 
   // Invalid value.
   codec_context_.pix_fmt = PIX_FMT_NONE;
   EXPECT_EQ(VideoFrame::INVALID, test_engine_->GetSurfaceFormat());
 }
 
 }  // namespace media