Let VideoEncoderSoftwareFallbackWrapper own the wrapped encoder

webrtc/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 21 matching lines @@
 const int kDefaultMinPixelsPerFrame = 320 * 180;
 }  // namespace
 
 class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test {
  protected:
   VideoEncoderSoftwareFallbackWrapperTest()
       : VideoEncoderSoftwareFallbackWrapperTest("") {}
   explicit VideoEncoderSoftwareFallbackWrapperTest(
       const std::string& field_trials)
       : override_field_trials_(field_trials),
-        fallback_wrapper_(cricket::VideoCodec("VP8"), &fake_encoder_) {}
+        fake_encoder_(new CountingFakeEncoder()),
+        fallback_wrapper_(cricket::VideoCodec("VP8"),
+                          std::unique_ptr<VideoEncoder>(fake_encoder_)) {}
 
   class CountingFakeEncoder : public VideoEncoder {
    public:
     int32_t InitEncode(const VideoCodec* codec_settings,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       ++init_encode_count_;
       return init_encode_return_code_;
     }
     int32_t Encode(const VideoFrame& frame,
@@ skipping 74 matching lines @@
   void UtilizeFallbackEncoder();
   void FallbackFromEncodeRequest();
   void EncodeFrame();
   void EncodeFrame(int expected_ret);
   void CheckLastEncoderName(const char* expected_name) {
     EXPECT_STREQ(expected_name, callback_.last_codec_name_.c_str());
   }
 
   test::ScopedFieldTrials override_field_trials_;
   FakeEncodedImageCallback callback_;
-  CountingFakeEncoder fake_encoder_;
+  // |fake_encoder_| is owned and released by |fallback_wrapper_|.
+  CountingFakeEncoder* fake_encoder_;
   VideoEncoderSoftwareFallbackWrapper fallback_wrapper_;
   VideoCodec codec_ = {};
   std::unique_ptr<VideoFrame> frame_;
   std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
 };
 
 void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame() {
   EncodeFrame(WEBRTC_VIDEO_CODEC_OK);
 }
 
 void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame(int expected_ret) {
   rtc::scoped_refptr<I420Buffer> buffer =
       I420Buffer::Create(codec_.width, codec_.height);
   I420Buffer::SetBlack(buffer);
   std::vector<FrameType> types(1, kVideoFrameKey);
 
   frame_.reset(new VideoFrame(buffer, 0, 0, webrtc::kVideoRotation_0));
   EXPECT_EQ(expected_ret, fallback_wrapper_.Encode(*frame_, nullptr, &types));
 }
 
 void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() {
   fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
-  EXPECT_EQ(&callback_, fake_encoder_.encode_complete_callback_);
+  EXPECT_EQ(&callback_, fake_encoder_->encode_complete_callback_);
 
   // Register with failing fake encoder. Should succeed with VP8 fallback.
   codec_.codecType = kVideoCodecVP8;
   codec_.maxFramerate = kFramerate;
   codec_.width = kWidth;
   codec_.height = kHeight;
   codec_.VP8()->numberOfTemporalLayers = 1;
   std::unique_ptr<TemporalLayersFactory> tl_factory(
       new TemporalLayersFactory());
   codec_.VP8()->tl_factory = tl_factory.get();
   rate_allocator_.reset(
       new SimulcastRateAllocator(codec_, std::move(tl_factory)));
 
-  fake_encoder_.init_encode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR;
+  fake_encoder_->init_encode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
   EXPECT_EQ(
       WEBRTC_VIDEO_CODEC_OK,
       fallback_wrapper_.SetRateAllocation(
           rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
 
   int callback_count = callback_.callback_count_;
-  int encode_count = fake_encoder_.encode_count_;
+  int encode_count = fake_encoder_->encode_count_;
   EncodeFrame();
-  EXPECT_EQ(encode_count, fake_encoder_.encode_count_);
+  EXPECT_EQ(encode_count, fake_encoder_->encode_count_);
   EXPECT_EQ(callback_count + 1, callback_.callback_count_);
 }
 
 void VideoEncoderSoftwareFallbackWrapperTest::FallbackFromEncodeRequest() {
   fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
   codec_.codecType = kVideoCodecVP8;
   codec_.maxFramerate = kFramerate;
   codec_.width = kWidth;
   codec_.height = kHeight;
   codec_.VP8()->numberOfTemporalLayers = 1;
   std::unique_ptr<TemporalLayersFactory> tl_factory(
       new TemporalLayersFactory());
   codec_.VP8()->tl_factory = tl_factory.get();
   rate_allocator_.reset(
       new SimulcastRateAllocator(codec_, std::move(tl_factory)));
   fallback_wrapper_.InitEncode(&codec_, 2, kMaxPayloadSize);
   EXPECT_EQ(
       WEBRTC_VIDEO_CODEC_OK,
       fallback_wrapper_.SetRateAllocation(
           rate_allocator_->GetAllocation(300000, kFramerate), kFramerate));
-  EXPECT_EQ(1, fake_encoder_.init_encode_count_);
+  EXPECT_EQ(1, fake_encoder_->init_encode_count_);
 
   // Have the non-fallback encoder request a software fallback.
-  fake_encoder_.encode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  fake_encoder_->encode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   int callback_count = callback_.callback_count_;
-  int encode_count = fake_encoder_.encode_count_;
+  int encode_count = fake_encoder_->encode_count_;
   EncodeFrame();
   // Single encode request, which returned failure.
-  EXPECT_EQ(encode_count + 1, fake_encoder_.encode_count_);
+  EXPECT_EQ(encode_count + 1, fake_encoder_->encode_count_);
   EXPECT_EQ(callback_count + 1, callback_.callback_count_);
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest, InitializesEncoder) {
   VideoCodec codec = {};
   fallback_wrapper_.InitEncode(&codec, 2, kMaxPayloadSize);
-  EXPECT_EQ(1, fake_encoder_.init_encode_count_);
+  EXPECT_EQ(1, fake_encoder_->init_encode_count_);
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest, EncodeRequestsFallback) {
   FallbackFromEncodeRequest();
   // After fallback, further encodes shouldn't hit the fake encoder.
-  int encode_count = fake_encoder_.encode_count_;
+  int encode_count = fake_encoder_->encode_count_;
   EncodeFrame();
-  EXPECT_EQ(encode_count, fake_encoder_.encode_count_);
+  EXPECT_EQ(encode_count, fake_encoder_->encode_count_);
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest, CanUtilizeFallbackEncoder) {
   UtilizeFallbackEncoder();
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        InternalEncoderReleasedDuringFallback) {
-  EXPECT_EQ(0, fake_encoder_.release_count_);
+  EXPECT_EQ(0, fake_encoder_->release_count_);
   UtilizeFallbackEncoder();
-  EXPECT_EQ(1, fake_encoder_.release_count_);
+  EXPECT_EQ(1, fake_encoder_->release_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
   // No extra release when the fallback is released.
-  EXPECT_EQ(1, fake_encoder_.release_count_);
+  EXPECT_EQ(1, fake_encoder_->release_count_);
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        InternalEncoderNotEncodingDuringFallback) {
   UtilizeFallbackEncoder();
-  int encode_count = fake_encoder_.encode_count_;
+  int encode_count = fake_encoder_->encode_count_;
   EncodeFrame();
-  EXPECT_EQ(encode_count, fake_encoder_.encode_count_);
+  EXPECT_EQ(encode_count, fake_encoder_->encode_count_);
 
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        CanRegisterCallbackWhileUsingFallbackEncoder) {
   UtilizeFallbackEncoder();
   // Registering an encode-complete callback should still work when fallback
   // encoder is being used.
   FakeEncodedImageCallback callback2;
   fallback_wrapper_.RegisterEncodeCompleteCallback(&callback2);
-  EXPECT_EQ(&callback2, fake_encoder_.encode_complete_callback_);
+  EXPECT_EQ(&callback2, fake_encoder_->encode_complete_callback_);
 
   // Encoding a frame using the fallback should arrive at the new callback.
   std::vector<FrameType> types(1, kVideoFrameKey);
   frame_->set_timestamp(frame_->timestamp() + 1000);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.Encode(*frame_, nullptr, &types));
 
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        SetChannelParametersForwardedDuringFallback) {
   UtilizeFallbackEncoder();
-  EXPECT_EQ(0, fake_encoder_.set_channel_parameters_count_);
+  EXPECT_EQ(0, fake_encoder_->set_channel_parameters_count_);
   fallback_wrapper_.SetChannelParameters(1, 1);
-  EXPECT_EQ(1, fake_encoder_.set_channel_parameters_count_);
+  EXPECT_EQ(1, fake_encoder_->set_channel_parameters_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        SetRatesForwardedDuringFallback) {
   UtilizeFallbackEncoder();
-  EXPECT_EQ(1, fake_encoder_.set_rates_count_);
+  EXPECT_EQ(1, fake_encoder_->set_rates_count_);
   fallback_wrapper_.SetRateAllocation(BitrateAllocation(), 1);
-  EXPECT_EQ(2, fake_encoder_.set_rates_count_);
+  EXPECT_EQ(2, fake_encoder_->set_rates_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        SupportsNativeHandleForwardedWithoutFallback) {
   fallback_wrapper_.SupportsNativeHandle();
-  EXPECT_EQ(1, fake_encoder_.supports_native_handle_count_);
+  EXPECT_EQ(1, fake_encoder_->supports_native_handle_count_);
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        SupportsNativeHandleNotForwardedDuringFallback) {
   UtilizeFallbackEncoder();
   fallback_wrapper_.SupportsNativeHandle();
-  EXPECT_EQ(0, fake_encoder_.supports_native_handle_count_);
+  EXPECT_EQ(0, fake_encoder_->supports_native_handle_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest, ReportsImplementationName) {
   codec_.width = kWidth;
   codec_.height = kHeight;
   fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
   fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize);
   EncodeFrame();
   CheckLastEncoderName("fake-encoder");
@@ skipping 22 matching lines @@
       : VideoEncoderSoftwareFallbackWrapperTest(field_trials) {}
 
   ~ForcedFallbackTest() override {}
 
  protected:
   void SetUp() override {
     clock_.SetTimeMicros(1234);
     ConfigureVp8Codec();
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.InitEncode(
                                          &codec_, kNumCores, kMaxPayloadSize));
-    EXPECT_EQ(1, fake_encoder_.init_encode_count_);
+    EXPECT_EQ(1, fake_encoder_->init_encode_count_);
   }
 
   void TearDown() override {
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
   }
 
   void ConfigureVp8Codec() {
     fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
     std::unique_ptr<TemporalLayersFactory> tl_factory(
         new TemporalLayersFactory());
@@ skipping 145 matching lines @@
     // Duration passed, expect fallback.
     clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
     EncodeFrameAndVerifyLastName("libvpx");
     // Bitrate at high threshold, expect fallback ended.
     SetRateAllocation(kHighKbps);
     EncodeFrameAndVerifyLastName("fake-encoder");
   }
 }
 
 TEST_F(ForcedFallbackTestEnabled, DropsFirstNonNativeFrameAfterFallbackEnds) {
-  fake_encoder_.supports_native_handle_ = true;
+  fake_encoder_->supports_native_handle_ = true;
 
   // Bitrate at low threshold.
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("libvpx");
   // Bitrate at high threshold, fallback should be ended but first non-native
   // frame dropped (i.e. frame not encoded).
   SetRateAllocation(kHighKbps);
   EncodeFrameAndVerifyLastName("libvpx", WEBRTC_VIDEO_CODEC_ERROR);
   // Next frame should be encoded.
   EncodeFrameAndVerifyLastName("fake-encoder");
 }
 
 TEST_F(ForcedFallbackTestEnabled, FallbackIsKeptWhenInitEncodeIsCalled) {
   // Bitrate below low threshold.
   SetRateAllocation(kLowKbps - 1);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("libvpx");
 
   // Re-initialize encoder, still expect fallback.
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(1, fake_encoder_.init_encode_count_);  // No change.
+  EXPECT_EQ(1, fake_encoder_->init_encode_count_);  // No change.
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("libvpx");
 }
 
 TEST_F(ForcedFallbackTestEnabled, FallbackIsEndedWhenResolutionIsTooLarge) {
   // Bitrate below low threshold.
   SetRateAllocation(kLowKbps - 1);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("libvpx");
 
   // Re-initialize encoder with a larger resolution, expect no fallback.
   codec_.width += 1;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(2, fake_encoder_.init_encode_count_);
+  EXPECT_EQ(2, fake_encoder_->init_encode_count_);
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
 }
 
 TEST_F(ForcedFallbackTestEnabled, FallbackIsEndedForNonValidSettings) {
   // Bitrate below low threshold.
   SetRateAllocation(kLowKbps - 1);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("libvpx");
 
   // Re-initialize encoder with invalid setting, expect no fallback.
   codec_.VP8()->numberOfTemporalLayers = 2;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(2, fake_encoder_.init_encode_count_);
+  EXPECT_EQ(2, fake_encoder_->init_encode_count_);
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
 
   // Re-initialize encoder with valid setting but fallback disabled from now on.
   codec_.VP8()->numberOfTemporalLayers = 1;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(3, fake_encoder_.init_encode_count_);
+  EXPECT_EQ(3, fake_encoder_->init_encode_count_);
   // Bitrate at low threshold.
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect no fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("fake-encoder");
 }
 
 TEST_F(ForcedFallbackTestEnabled, GetScaleSettingsWithoutFallback) {
   // Bitrate at low threshold.
@@ skipping 23 matching lines @@
   SetRateAllocation(kLowKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
   // Duration passed, expect fallback.
   clock_.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kMinLowDurationMs));
   EncodeFrameAndVerifyLastName("libvpx");
 
   // Re-initialize encoder with a resolution less than |kMinPixelsStop|.
   codec_.height = kMinPixelsStop / codec_.width - 1;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(1, fake_encoder_.init_encode_count_);  // No change
+  EXPECT_EQ(1, fake_encoder_->init_encode_count_);  // No change
   SetRateAllocation(kHighKbps - 1);
   EncodeFrameAndVerifyLastName("libvpx");
   // Bitrate at high threshold but resolution too small for fallback to end.
   SetRateAllocation(kHighKbps);
   EncodeFrameAndVerifyLastName("libvpx");
 
   // Re-initialize encoder with a resolution equal to |kMinPixelsStop|.
   codec_.height++;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             fallback_wrapper_.InitEncode(&codec_, kNumCores, kMaxPayloadSize));
-  EXPECT_EQ(1, fake_encoder_.init_encode_count_);  // No change
+  EXPECT_EQ(1, fake_encoder_->init_encode_count_);  // No change
   SetRateAllocation(kHighKbps - 1);
   EncodeFrameAndVerifyLastName("libvpx");
   // Bitrate at high threshold and resolution large enough for fallback to end.
   SetRateAllocation(kHighKbps);
   EncodeFrameAndVerifyLastName("fake-encoder");
 }
 
 }  // namespace webrtc