Integrate VDA with WebRTC.

content/renderer/media/rtc_video_decoder_unittest.cc

+// Copyright (c) 2013 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/bind.h"
+#include "base/message_loop.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "content/renderer/media/rtc_video_decoder.h"
+#include "media/base/gmock_callback_support.h"
+#include "media/filters/gpu_video_decoder.h"
+#include "media/filters/mock_gpu_video_decoder_factories.h"
+#include "media/video/mock_video_decode_accelerator.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::SaveArg;
+using ::testing::WithArgs;
+
+namespace content {
+
+class RTCVideoDecoderTest
+    : public ::testing::Test,
+      webrtc::DecodedImageCallback {
+ public:
+  RTCVideoDecoderTest()
+      : mock_gpu_factories_(new media::MockGpuVideoDecoderFactories),
+        num_delivered_frames_(0),
+        vda_thread_("vda_thread"),
+        idle_waiter_(false,false) {
+    memset(&codec_, 0, sizeof(codec_));
+  }
+
+  virtual void SetUp() OVERRIDE {
+    ASSERT_TRUE(vda_thread_.Start());
+    vda_loop_proxy_ = vda_thread_.message_loop_proxy();
+    EXPECT_CALL(*mock_gpu_factories_, GetMessageLoop())
+        .WillOnce(Return(vda_loop_proxy_));
+    rtc_decoder_.reset(new RTCVideoDecoder(mock_gpu_factories_));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    vda_thread_.Stop();
+  }
+
+  virtual int32_t Decoded(webrtc::I420VideoFrame& decoded_image)
+      OVERRIDE {
+    EXPECT_EQ(vda_loop_proxy_, base::MessageLoopProxy::current());
+    VLOG(2) << "Decoded";
+    ++num_delivered_frames_;
+    return WEBRTC_VIDEO_CODEC_OK;
+  }
+
+  void Initialize() {
+    VLOG(2) << "Initialize";
+    mock_vda_ = new media::MockVideoDecodeAccelerator;
+    EXPECT_CALL(
+        *mock_gpu_factories_,
+        CreateVideoDecodeAccelerator(media::VP8PROFILE_MAIN, _))
+        .WillOnce(Return(mock_vda_));
+    codec_.codecType = webrtc::kVideoCodecVP8;
+    EXPECT_EQ(true, rtc_decoder_->Initialize(codec_.codecType));
+    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->InitDecode(&codec_, 1));
+    EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
+              rtc_decoder_->RegisterDecodeCompleteCallback(this));
+  }
+
+  void NotifyResetDone() {
+    VLOG(2) << "NotifyResetDone";
+    vda_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&RTCVideoDecoder::NotifyResetDone,
+                   base::Unretained(rtc_decoder_.get())));
+  }
+
+  void RunUntilIdle() {
+    vda_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&RTCVideoDecoderTest::NotifyIdle, base::Unretained(this)));
+   idle_waiter_.Wait();
+  }
+
+  void NotifyIdle() {
+    idle_waiter_.Signal();
+  }
+
+ protected:
+  media::MockGpuVideoDecoderFactories* mock_gpu_factories_;
+  media::MockVideoDecodeAccelerator* mock_vda_;
+  scoped_ptr<RTCVideoDecoder> rtc_decoder_;
+  webrtc::VideoCodec codec_;
+  int num_delivered_frames_;
+
+ private:
+  scoped_refptr<base::MessageLoopProxy> vda_loop_proxy_;
+  base::Thread vda_thread_;
+
+  base::Lock lock_;
+  base::WaitableEvent idle_waiter_;
+};
+
+TEST_F(RTCVideoDecoderTest, InitDecodeReturnsErrorOnFeedbackMode) {
+  codec_.codecType = webrtc::kVideoCodecVP8;
+  codec_.codecSpecific.VP8.feedbackModeOn = true;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR, rtc_decoder_->InitDecode(&codec_, 1));
+}
+
+TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorWithoutInitDecode) {
+  webrtc::EncodedImage input_image;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
+            rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
+}
+
+TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnIncompleteFrame) {
+  Initialize();
+  webrtc::EncodedImage input_image;
+  input_image._completeFrame = false;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
+            rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
+}
+
+TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnMissingFrames) {
+  Initialize();
+  webrtc::EncodedImage input_image;
+  input_image._completeFrame = true;
+  bool missingFrames = true;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
+            rtc_decoder_->Decode(input_image, missingFrames, NULL, NULL, 0));
+}
+
+TEST_F(RTCVideoDecoderTest, ResetReturnsOk) {
+  Initialize();
+  EXPECT_CALL(*mock_vda_, Reset())
+      .WillRepeatedly(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Reset());
+}
+
+TEST_F(RTCVideoDecoderTest, ReleaseReturnsOk) {
+  Initialize();
+  EXPECT_CALL(*mock_vda_, Destroy());
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
+}
+
+}  // content