Reland Replace interface VideoCapturerInput with VideoSinkInterface.

webrtc/video/vie_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_encoder.h"
+#include "webrtc/test/frame_generator.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/vie_encoder.h"
 
 namespace webrtc {
 
 class ViEEncoderTest : public ::testing::Test {
  public:
   static const int kDefaultTimeoutMs = 30 * 1000;
 
   ViEEncoderTest()
@@ skipping 10 matching lines @@
     video_send_config_.encoder_settings.payload_name = "FAKE";
     video_send_config_.encoder_settings.payload_type = 125;
 
     video_encoder_config_.streams = test::CreateVideoStreams(1);
 
     vie_encoder_.reset(new ViEEncoder(
         1 /* number_of_cores */, &stats_proxy_,
         video_send_config_.encoder_settings, nullptr /* pre_encode_callback */,
         nullptr /* overuse_callback */, nullptr /* encoder_timing */));
     vie_encoder_->SetSink(&sink_);
+    vie_encoder_->SetSource(&video_source_);
     vie_encoder_->SetStartBitrate(10000);
     vie_encoder_->ConfigureEncoder(video_encoder_config_, 1440);
   }
 
   VideoFrame CreateFrame(int64_t ntp_ts, rtc::Event* destruction_event) const {
     class TestBuffer : public webrtc::I420Buffer {
      public:
       TestBuffer(rtc::Event* event, int width, int height)
           : I420Buffer(width, height), event_(event) {}
 
@@ skipping 33 matching lines @@
         EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90);
 
         timestamp_ = input_image.timestamp();
         ntp_time_ms_ = input_image.ntp_time_ms();
         block_encode = block_next_encode_;
         block_next_encode_ = false;
       }
       int32_t result =
           FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
       if (block_encode)
-        continue_encode_event_.Wait(kDefaultTimeoutMs);
+        EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs));
       return result;
     }
 
     void BlockNextEncode() {
       rtc::CritScope lock(&crit_);
       block_next_encode_ = true;
     }
 
     void ContinueEncode() { continue_encode_event_.Set(); }
 
@@ skipping 22 matching lines @@
                     const RTPFragmentationHeader* fragmentation) override {
       rtc::CritScope lock(&crit_);
       EXPECT_TRUE(expect_frames_);
       timestamp_ = encoded_image._timeStamp;
       encoded_frame_event_.Set();
       return 0;
     }
 
     void WaitForEncodedFrame(int64_t expected_ntp_time) {
       uint32_t timestamp = 0;
-      encoded_frame_event_.Wait(kDefaultTimeoutMs);
+      EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs));
       {
         rtc::CritScope lock(&crit_);
         timestamp = timestamp_;
       }
       test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp);
     }
 
     void SetExpectNoFrames() {
       rtc::CritScope lock(&crit_);
       expect_frames_ = false;
     }
 
    private:
     rtc::CriticalSection crit_;
     TestEncoder* test_encoder_;
     rtc::Event encoded_frame_event_;
     uint32_t timestamp_ = 0;
     bool expect_frames_ = true;
   };
 
   VideoSendStream::Config video_send_config_;
   VideoEncoderConfig video_encoder_config_;
   TestEncoder fake_encoder_;
   SendStatisticsProxy stats_proxy_;
   TestSink sink_;
+  test::FrameForwarder video_source_;
   std::unique_ptr<ViEEncoder> vie_encoder_;
 };
 
 TEST_F(ViEEncoderTest, EncodeOneFrame) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   rtc::Event frame_destroyed_event(false, false);
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
   sink_.WaitForEncodedFrame(1);
-  frame_destroyed_event.Wait(kDefaultTimeoutMs);
+  EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
   // Dropped since no target bitrate has been set.
   rtc::Event frame_destroyed_event(false, false);
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
-  frame_destroyed_event.Wait(kDefaultTimeoutMs);
+  video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
+  EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
 
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(2, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   sink_.WaitForEncodedFrame(2);
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DropsFramesWhenRateSetToZero) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   sink_.WaitForEncodedFrame(1);
 
   vie_encoder_->OnBitrateUpdated(0, 0, 0);
   // Dropped since bitrate is zero.
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(2, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
 
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(3, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
   sink_.WaitForEncodedFrame(3);
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   sink_.WaitForEncodedFrame(1);
 
   // This frame will be dropped since it has the same ntp timestamp.
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
 
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(2, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   sink_.WaitForEncodedFrame(2);
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DropsFrameAfterStop) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   sink_.WaitForEncodedFrame(1);
 
   vie_encoder_->Stop();
   sink_.SetExpectNoFrames();
   rtc::Event frame_destroyed_event(false, false);
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event));
-  frame_destroyed_event.Wait(kDefaultTimeoutMs);
+  video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event));
+  EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
 }
 
 TEST_F(ViEEncoderTest, DropsPendingFramesOnSlowEncode) {
   const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   fake_encoder_.BlockNextEncode();
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(1, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   sink_.WaitForEncodedFrame(1);
   // Here, the encoder thread will be blocked in the TestEncoder waiting for a
   // call to ContinueEncode.
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(2, nullptr));
-  vie_encoder_->IncomingCapturedFrame(CreateFrame(3, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
+  video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
   fake_encoder_.ContinueEncode();
   sink_.WaitForEncodedFrame(3);
 
   vie_encoder_->Stop();
 }
 
 }  // namespace webrtc