Handle HW decode failures in RTCVideoDecoder

content/renderer/media/rtc_video_decoder_unittest.cc

 // Copyright 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 <stdint.h>
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "content/renderer/media/rtc_video_decoder.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/renderers/mock_gpu_video_accelerator_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::Values;
 using ::testing::WithArgs;
 
 namespace content {
 
-// TODO(wuchengli): add MockSharedMemroy so more functions can be tested.
-class RTCVideoDecoderTest : public ::testing::Test,
-                            webrtc::DecodedImageCallback {
+namespace {
+
+static const int kMinResolutionWidth = 16;
+static const int kMinResolutionHeight = 16;
+static const int kMaxResolutionWidth = 1920;
+static const int kMaxResolutionHeight = 1088;
+
+}  // namespace
+
+// TODO(wuchengli): add MockSharedMemory so more functions can be tested.
+class RTCVideoDecoderTest
+    : public ::testing::TestWithParam<webrtc::VideoCodecType>,
+      webrtc::DecodedImageCallback {
  public:
   RTCVideoDecoderTest()
       : mock_gpu_factories_(
             new media::MockGpuVideoAcceleratorFactories(nullptr)),
         vda_thread_("vda_thread"),
         idle_waiter_(false, false) {
     memset(&codec_, 0, sizeof(codec_));
   }
 
   void SetUp() override {
     ASSERT_TRUE(vda_thread_.Start());
     vda_task_runner_ = vda_thread_.task_runner();
     mock_vda_ = new media::MockVideoDecodeAccelerator;
 
     media::VideoDecodeAccelerator::SupportedProfile supported_profile;
-    supported_profile.min_resolution.SetSize(16, 16);
-    supported_profile.max_resolution.SetSize(1920, 1088);
+    supported_profile.min_resolution.SetSize(kMinResolutionWidth,
+                                             kMinResolutionHeight);
+    supported_profile.max_resolution.SetSize(kMaxResolutionWidth,
+                                             kMaxResolutionHeight);
     supported_profile.profile = media::H264PROFILE_MAIN;
     capabilities_.supported_profiles.push_back(supported_profile);
     supported_profile.profile = media::VP8PROFILE_ANY;
     capabilities_.supported_profiles.push_back(supported_profile);
 
     EXPECT_CALL(*mock_gpu_factories_.get(), GetTaskRunner())
         .WillRepeatedly(Return(vda_task_runner_));
     EXPECT_CALL(*mock_gpu_factories_.get(),
                 GetVideoDecodeAcceleratorCapabilities())
         .WillRepeatedly(Return(capabilities_));
@@ skipping 36 matching lines @@
   }
 
   void NotifyResetDone() {
     DVLOG(2) << "NotifyResetDone";
     vda_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::NotifyResetDone,
                    base::Unretained(rtc_decoder_.get())));
   }
 
+  void NotifyError(media::VideoDecodeAccelerator::Error error) {
+    DVLOG(2) << "NotifyError";
+    vda_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&RTCVideoDecoder::NotifyError,
+                   base::Unretained(rtc_decoder_.get()), error));
+  }
+
   void RunUntilIdle() {
     DVLOG(2) << "RunUntilIdle";
     vda_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&base::WaitableEvent::Signal,
                                           base::Unretained(&idle_waiter_)));
     idle_waiter_.Wait();
   }
 
+  void SetUpResetVDA() {
+    mock_vda_after_reset_ = new media::MockVideoDecodeAccelerator;
+    EXPECT_CALL(*mock_gpu_factories_.get(), DoCreateVideoDecodeAccelerator())
+        .WillRepeatedly(Return(mock_vda_after_reset_));
+    EXPECT_CALL(*mock_vda_after_reset_, Initialize(_, _))
+        .Times(1)
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_vda_after_reset_, Destroy()).Times(1);
+  }
+
  protected:
   scoped_ptr<media::MockGpuVideoAcceleratorFactories> mock_gpu_factories_;
   media::MockVideoDecodeAccelerator* mock_vda_;
+  media::MockVideoDecodeAccelerator* mock_vda_after_reset_;
   scoped_ptr<RTCVideoDecoder> rtc_decoder_;
   webrtc::VideoCodec codec_;
   base::Thread vda_thread_;
   media::VideoDecodeAccelerator::Capabilities capabilities_;
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> vda_task_runner_;
 
   base::Lock lock_;
   base::WaitableEvent idle_waiter_;
 };
 
 TEST_F(RTCVideoDecoderTest, CreateReturnsNullOnUnsupportedCodec) {
   CreateDecoder(webrtc::kVideoCodecVP8);
   scoped_ptr<RTCVideoDecoder> null_rtc_decoder(RTCVideoDecoder::Create(
       webrtc::kVideoCodecI420, mock_gpu_factories_.get()));
   EXPECT_EQ(NULL, null_rtc_decoder.get());
 }
 
-TEST_F(RTCVideoDecoderTest, CreateAndInitSucceedsForH264Codec) {
-  CreateDecoder(webrtc::kVideoCodecH264);
+TEST_P(RTCVideoDecoderTest, CreateAndInitSucceeds) {
+  const webrtc::VideoCodecType codec_type = GetParam();
+  CreateDecoder(codec_type);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->InitDecode(&codec_, 1));
 }
 
 TEST_F(RTCVideoDecoderTest, InitDecodeReturnsErrorOnFeedbackMode) {
   CreateDecoder(webrtc::kVideoCodecVP8);
   codec_.codecSpecific.VP8.feedbackModeOn = true;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR, rtc_decoder_->InitDecode(&codec_, 1));
 }
 
 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorWithoutInitDecode) {
   CreateDecoder(webrtc::kVideoCodecVP8);
   webrtc::EncodedImage input_image;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
-            rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
+            rtc_decoder_->Decode(input_image, false, nullptr, nullptr, 0));
 }
 
 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnIncompleteFrame) {
   CreateDecoder(webrtc::kVideoCodecVP8);
   Initialize();
   webrtc::EncodedImage input_image;
   input_image._completeFrame = false;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
-            rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
+            rtc_decoder_->Decode(input_image, false, nullptr, nullptr, 0));
 }
 
 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnMissingFrames) {
   CreateDecoder(webrtc::kVideoCodecVP8);
   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));
+  EXPECT_EQ(
+      WEBRTC_VIDEO_CODEC_ERROR,
+      rtc_decoder_->Decode(input_image, missingFrames, nullptr, nullptr, 0));
 }
 
 TEST_F(RTCVideoDecoderTest, ReleaseReturnsOk) {
   CreateDecoder(webrtc::kVideoCodecVP8);
   Initialize();
   EXPECT_CALL(*mock_vda_, Reset())
       .WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
 }
 
@@ skipping 51 matching lines @@
       RTCVideoDecoder::ID_HALF + 2, RTCVideoDecoder::ID_HALF));
 
   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                      RTCVideoDecoder::ID_LAST));
   EXPECT_TRUE(
       rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_LAST));
   EXPECT_FALSE(
       rtc_decoder_->IsFirstBufferAfterReset(1, RTCVideoDecoder::ID_LAST));
 }
 
+
+TEST_P(RTCVideoDecoderTest, DecodeResetsAfterError) {
+  const webrtc::VideoCodecType codec_type = GetParam();
+  CreateDecoder(codec_type);
+  Initialize();
+
+  webrtc::EncodedImage input_image;
+  input_image._completeFrame = true;
+  input_image._encodedWidth = kMinResolutionWidth;
+  input_image._encodedHeight = kMaxResolutionHeight;
+  input_image._frameType = webrtc::kVideoFrameDelta;
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
+            rtc_decoder_->Decode(input_image, false, nullptr, nullptr, 0));
+  RunUntilIdle();
+
+  // Notify the decoder about a platform error.
+  NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+  RunUntilIdle();
+
+  // Expect decode call to reset decoder, and set up a new VDA to track it.
+  SetUpResetVDA();
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
+            rtc_decoder_->Decode(input_image, false, nullptr, nullptr, 0));
+}
+
+INSTANTIATE_TEST_CASE_P(CodecProfiles,
+                        RTCVideoDecoderTest,
+                        Values(webrtc::kVideoCodecVP8,
+                               webrtc::kVideoCodecH264));
+
 }  // content