video/video_stream_encoder_unittest.cc - src - Git at Google


 /*
  *  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 "video/video_stream_encoder.h"

 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <tuple>
 #include <utility>

 #include "absl/memory/memory.h"
 #include "api/field_trials_view.h"
 #include "api/rtp_parameters.h"
 #include "api/task_queue/default_task_queue_factory.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "api/test/mock_fec_controller_override.h"
 #include "api/test/mock_video_encoder.h"
 #include "api/test/mock_video_encoder_factory.h"
 #include "api/units/data_rate.h"
 #include "api/units/time_delta.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/i420_buffer.h"
 #include "api/video/nv12_buffer.h"
 #include "api/video/video_adaptation_reason.h"
 #include "api/video/video_bitrate_allocation.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/vp8_temporal_layers.h"
 #include "api/video_codecs/vp8_temporal_layers_factory.h"
 #include "call/adaptation/test/fake_adaptation_constraint.h"
 #include "call/adaptation/test/fake_resource.h"
 #include "common_video/h264/h264_common.h"
 #include "common_video/include/video_frame_buffer.h"
 #include "media/base/video_adapter.h"
 #include "media/engine/webrtc_video_engine.h"
 #include "modules/video_coding/codecs/av1/libaom_av1_encoder.h"
 #include "modules/video_coding/codecs/h264/include/h264.h"
 #include "modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h"
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "modules/video_coding/codecs/vp9/include/vp9.h"
 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
 #include "modules/video_coding/codecs/vp9/svc_config.h"
 #include "modules/video_coding/utility/quality_scaler.h"
 #include "modules/video_coding/utility/simulcast_rate_allocator.h"
 #include "modules/video_coding/utility/vp8_constants.h"
 #include "rtc_base/event.h"
 #include "rtc_base/experiments/encoder_info_settings.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/ref_counted_object.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "system_wrappers/include/metrics.h"
 #include "test/encoder_settings.h"
 #include "test/fake_encoder.h"
 #include "test/frame_forwarder.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 #include "test/mappable_native_buffer.h"
 #include "test/scoped_key_value_config.h"
 #include "test/time_controller/simulated_time_controller.h"
 #include "test/video_encoder_nullable_proxy_factory.h"
 #include "test/video_encoder_proxy_factory.h"
 #include "video/config/encoder_stream_factory.h"
 #include "video/frame_cadence_adapter.h"
 #include "video/send_statistics_proxy.h"

 namespace webrtc {

 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Eq;
 using ::testing::Field;
 using ::testing::Ge;
 using ::testing::Gt;
 using ::testing::Invoke;
 using ::testing::Le;
 using ::testing::Lt;
 using ::testing::Matcher;
 using ::testing::Mock;
 using ::testing::NiceMock;
 using ::testing::Optional;
 using ::testing::Return;
 using ::testing::SizeIs;
 using ::testing::StrictMock;

 namespace {
 const int kMinPixelsPerFrame = 320 * 180;
 const int kQpLow = 1;
 const int kQpHigh = 2;
 const int kMinFramerateFps = 2;
 const int kMinBalancedFramerateFps = 7;
 constexpr TimeDelta kFrameTimeout = TimeDelta::Millis(100);
 const size_t kMaxPayloadLength = 1440;
 const DataRate kTargetBitrate = DataRate::KilobitsPerSec(1000);
 const DataRate kLowTargetBitrate = DataRate::KilobitsPerSec(100);
 const DataRate kStartBitrate = DataRate::KilobitsPerSec(600);
 const DataRate kSimulcastTargetBitrate = DataRate::KilobitsPerSec(3150);
 const int kMaxInitialFramedrop = 4;
 const int kDefaultFramerate = 30;
 const int64_t kFrameIntervalMs = rtc::kNumMillisecsPerSec / kDefaultFramerate;
 const int64_t kProcessIntervalMs = 1000;
 const VideoEncoder::ResolutionBitrateLimits
     kEncoderBitrateLimits540p(960 * 540, 100 * 1000, 100 * 1000, 2000 * 1000);
 const VideoEncoder::ResolutionBitrateLimits
     kEncoderBitrateLimits720p(1280 * 720, 200 * 1000, 200 * 1000, 4000 * 1000);

 uint8_t kOptimalSps[] = {0,    0,    0,    1,    H264::NaluType::kSps,
                          0x00, 0x00, 0x03, 0x03, 0xF4,
                          0x05, 0x03, 0xC7, 0xE0, 0x1B,
                          0x41, 0x10, 0x8D, 0x00};

 const uint8_t kCodedFrameVp8Qp25[] = {
     0x10, 0x02, 0x00, 0x9d, 0x01, 0x2a, 0x10, 0x00, 0x10, 0x00,
     0x02, 0x47, 0x08, 0x85, 0x85, 0x88, 0x85, 0x84, 0x88, 0x0c,
     0x82, 0x00, 0x0c, 0x0d, 0x60, 0x00, 0xfe, 0xfc, 0x5c, 0xd0};

 VideoFrame CreateSimpleNV12Frame() {
   return VideoFrame::Builder()
       .set_video_frame_buffer(rtc::make_ref_counted<NV12Buffer>(
           /*width=*/16, /*height=*/16))
       .build();
 }

 void PassAFrame(
     TaskQueueBase* encoder_queue,
     FrameCadenceAdapterInterface::Callback* video_stream_encoder_callback,
     int64_t ntp_time_ms) {
   encoder_queue->PostTask([video_stream_encoder_callback, ntp_time_ms] {
     video_stream_encoder_callback->OnFrame(Timestamp::Millis(ntp_time_ms),
                                            false, CreateSimpleNV12Frame());
   });
 }

 class TestBuffer : public webrtc::I420Buffer {
  public:
   TestBuffer(rtc::Event* event, int width, int height)
       : I420Buffer(width, height), event_(event) {}

  private:
   friend class rtc::RefCountedObject<TestBuffer>;
   ~TestBuffer() override {
     if (event_)
       event_->Set();
   }
   rtc::Event* const event_;
 };

 // A fake native buffer that can't be converted to I420. Upon scaling, it
 // produces another FakeNativeBuffer.
 class FakeNativeBuffer : public webrtc::VideoFrameBuffer {
  public:
   FakeNativeBuffer(rtc::Event* event, int width, int height)
       : event_(event), width_(width), height_(height) {}
   webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; }
   int width() const override { return width_; }
   int height() const override { return height_; }
   rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override {
     return nullptr;
   }
   rtc::scoped_refptr<VideoFrameBuffer> CropAndScale(
       int offset_x,
       int offset_y,
       int crop_width,
       int crop_height,
       int scaled_width,
       int scaled_height) override {
     return rtc::make_ref_counted<FakeNativeBuffer>(nullptr, scaled_width,
                                                    scaled_height);
   }

  private:
   friend class rtc::RefCountedObject<FakeNativeBuffer>;
   ~FakeNativeBuffer() override {
     if (event_)
       event_->Set();
   }
   rtc::Event* const event_;
   const int width_;
   const int height_;
 };

 // A fake native buffer that is backed by an NV12 buffer.
 class FakeNV12NativeBuffer : public webrtc::VideoFrameBuffer {
  public:
   FakeNV12NativeBuffer(rtc::Event* event, int width, int height)
       : nv12_buffer_(NV12Buffer::Create(width, height)), event_(event) {}

   webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; }
   int width() const override { return nv12_buffer_->width(); }
   int height() const override { return nv12_buffer_->height(); }
   rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override {
     return nv12_buffer_->ToI420();
   }
   rtc::scoped_refptr<VideoFrameBuffer> GetMappedFrameBuffer(
       rtc::ArrayView<VideoFrameBuffer::Type> types) override {
     if (absl::c_find(types, Type::kNV12) != types.end()) {
       return nv12_buffer_;
     }
     return nullptr;
   }
   const NV12BufferInterface* GetNV12() const { return nv12_buffer_.get(); }

  private:
   friend class rtc::RefCountedObject<FakeNV12NativeBuffer>;
   ~FakeNV12NativeBuffer() override {
     if (event_)
       event_->Set();
   }
   rtc::scoped_refptr<NV12Buffer> nv12_buffer_;
   rtc::Event* const event_;
 };

 class CpuOveruseDetectorProxy : public OveruseFrameDetector {
  public:
   explicit CpuOveruseDetectorProxy(CpuOveruseMetricsObserver* metrics_observer)
       : OveruseFrameDetector(metrics_observer),
         last_target_framerate_fps_(-1),
         framerate_updated_event_(true /* manual_reset */,
                                  false /* initially_signaled */) {}
   virtual ~CpuOveruseDetectorProxy() {}

   void OnTargetFramerateUpdated(int framerate_fps) override {
     MutexLock lock(&lock_);
     last_target_framerate_fps_ = framerate_fps;
     OveruseFrameDetector::OnTargetFramerateUpdated(framerate_fps);
     framerate_updated_event_.Set();
   }

   int GetLastTargetFramerate() {
     MutexLock lock(&lock_);
     return last_target_framerate_fps_;
   }

   CpuOveruseOptions GetOptions() { return options_; }

   rtc::Event* framerate_updated_event() { return &framerate_updated_event_; }

  private:
   Mutex lock_;
   int last_target_framerate_fps_ RTC_GUARDED_BY(lock_);
   rtc::Event framerate_updated_event_;
 };

 class FakeVideoSourceRestrictionsListener
     : public VideoSourceRestrictionsListener {
  public:
   FakeVideoSourceRestrictionsListener()
       : was_restrictions_updated_(false), restrictions_updated_event_() {}
   ~FakeVideoSourceRestrictionsListener() override {
     RTC_DCHECK(was_restrictions_updated_);
   }

   rtc::Event* restrictions_updated_event() {
     return &restrictions_updated_event_;
   }

   // VideoSourceRestrictionsListener implementation.
   void OnVideoSourceRestrictionsUpdated(
       VideoSourceRestrictions restrictions,
       const VideoAdaptationCounters& adaptation_counters,
       rtc::scoped_refptr<Resource> reason,
       const VideoSourceRestrictions& unfiltered_restrictions) override {
     was_restrictions_updated_ = true;
     restrictions_updated_event_.Set();
   }

  private:
   bool was_restrictions_updated_;
   rtc::Event restrictions_updated_event_;
 };

 auto WantsFps(Matcher<int> fps_matcher) {
   return Field("max_framerate_fps", &rtc::VideoSinkWants::max_framerate_fps,
                fps_matcher);
 }

 auto WantsMaxPixels(Matcher<int> max_pixel_matcher) {
   return Field("max_pixel_count", &rtc::VideoSinkWants::max_pixel_count,
                AllOf(max_pixel_matcher, Gt(0)));
 }

 auto ResolutionMax() {
   return AllOf(
       WantsMaxPixels(Eq(std::numeric_limits<int>::max())),
       Field("target_pixel_count", &rtc::VideoSinkWants::target_pixel_count,
             Eq(absl::nullopt)));
 }

 auto FpsMax() {
   return WantsFps(Eq(kDefaultFramerate));
 }

 auto FpsUnlimited() {
   return WantsFps(Eq(std::numeric_limits<int>::max()));
 }

 auto FpsMatchesResolutionMax(Matcher<int> fps_matcher) {
   return AllOf(WantsFps(fps_matcher), ResolutionMax());
 }

 auto FpsMaxResolutionMatches(Matcher<int> pixel_matcher) {
   return AllOf(FpsMax(), WantsMaxPixels(pixel_matcher));
 }

 auto FpsMaxResolutionMax() {
   return AllOf(FpsMax(), ResolutionMax());
 }

 auto UnlimitedSinkWants() {
   return AllOf(FpsUnlimited(), ResolutionMax());
 }

 auto FpsInRangeForPixelsInBalanced(int last_frame_pixels) {
   Matcher<int> fps_range_matcher;

   if (last_frame_pixels <= 320 * 240) {
     fps_range_matcher = AllOf(Ge(7), Le(10));
   } else if (last_frame_pixels <= 480 * 360) {
     fps_range_matcher = AllOf(Ge(10), Le(15));
   } else if (last_frame_pixels <= 640 * 480) {
     fps_range_matcher = Ge(15);
   } else {
     fps_range_matcher = Eq(kDefaultFramerate);
   }
   return Field("max_framerate_fps", &rtc::VideoSinkWants::max_framerate_fps,
                fps_range_matcher);
 }

 auto FpsEqResolutionEqTo(const rtc::VideoSinkWants& other_wants) {
   return AllOf(WantsFps(Eq(other_wants.max_framerate_fps)),
                WantsMaxPixels(Eq(other_wants.max_pixel_count)));
 }

 auto FpsMaxResolutionLt(const rtc::VideoSinkWants& other_wants) {
   return AllOf(FpsMax(), WantsMaxPixels(Lt(other_wants.max_pixel_count)));
 }

 auto FpsMaxResolutionGt(const rtc::VideoSinkWants& other_wants) {
   return AllOf(FpsMax(), WantsMaxPixels(Gt(other_wants.max_pixel_count)));
 }

 auto FpsLtResolutionEq(const rtc::VideoSinkWants& other_wants) {
   return AllOf(WantsFps(Lt(other_wants.max_framerate_fps)),
                WantsMaxPixels(Eq(other_wants.max_pixel_count)));
 }

 auto FpsGtResolutionEq(const rtc::VideoSinkWants& other_wants) {
   return AllOf(WantsFps(Gt(other_wants.max_framerate_fps)),
                WantsMaxPixels(Eq(other_wants.max_pixel_count)));
 }

 auto FpsEqResolutionLt(const rtc::VideoSinkWants& other_wants) {
   return AllOf(WantsFps(Eq(other_wants.max_framerate_fps)),
                WantsMaxPixels(Lt(other_wants.max_pixel_count)));
 }

 auto FpsEqResolutionGt(const rtc::VideoSinkWants& other_wants) {
   return AllOf(WantsFps(Eq(other_wants.max_framerate_fps)),
                WantsMaxPixels(Gt(other_wants.max_pixel_count)));
 }

 class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
  public:
   VideoStreamEncoderUnderTest(
       TimeController* time_controller,
       std::unique_ptr<FrameCadenceAdapterInterface> cadence_adapter,
       std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>
           encoder_queue,
       SendStatisticsProxy* stats_proxy,
       const VideoStreamEncoderSettings& settings,
       VideoStreamEncoder::BitrateAllocationCallbackType
           allocation_callback_type,
       const FieldTrialsView& field_trials,
       int num_cores)
       : VideoStreamEncoder(time_controller->GetClock(),
                            num_cores,
                            stats_proxy,
                            settings,
                            std::unique_ptr<OveruseFrameDetector>(
                                overuse_detector_proxy_ =
                                    new CpuOveruseDetectorProxy(stats_proxy)),
                            std::move(cadence_adapter),
                            std::move(encoder_queue),
                            allocation_callback_type,
                            field_trials),
         time_controller_(time_controller),
         fake_cpu_resource_(FakeResource::Create("FakeResource[CPU]")),
         fake_quality_resource_(FakeResource::Create("FakeResource[QP]")),
         fake_adaptation_constraint_("FakeAdaptationConstraint") {
     InjectAdaptationResource(fake_quality_resource_,
                              VideoAdaptationReason::kQuality);
     InjectAdaptationResource(fake_cpu_resource_, VideoAdaptationReason::kCpu);
     InjectAdaptationConstraint(&fake_adaptation_constraint_);
   }

   void SetSourceAndWaitForRestrictionsUpdated(
       rtc::VideoSourceInterface<VideoFrame>* source,
       const DegradationPreference& degradation_preference) {
     FakeVideoSourceRestrictionsListener listener;
     AddRestrictionsListenerForTesting(&listener);
     SetSource(source, degradation_preference);
     listener.restrictions_updated_event()->Wait(TimeDelta::Seconds(5));
     RemoveRestrictionsListenerForTesting(&listener);
   }

   void SetSourceAndWaitForFramerateUpdated(
       rtc::VideoSourceInterface<VideoFrame>* source,
       const DegradationPreference& degradation_preference) {
     overuse_detector_proxy_->framerate_updated_event()->Reset();
     SetSource(source, degradation_preference);
     overuse_detector_proxy_->framerate_updated_event()->Wait(
         TimeDelta::Seconds(5));
   }

   void OnBitrateUpdatedAndWaitForManagedResources(
       DataRate target_bitrate,
       DataRate stable_target_bitrate,
       DataRate link_allocation,
       uint8_t fraction_lost,
       int64_t round_trip_time_ms,
       double cwnd_reduce_ratio) {
     OnBitrateUpdated(target_bitrate, stable_target_bitrate, link_allocation,
                      fraction_lost, round_trip_time_ms, cwnd_reduce_ratio);
     // Bitrate is updated on the encoder queue.
     WaitUntilTaskQueueIsIdle();
   }

   // This is used as a synchronisation mechanism, to make sure that the
   // encoder queue is not blocked before we start sending it frames.
   void WaitUntilTaskQueueIsIdle() {
     time_controller_->AdvanceTime(TimeDelta::Zero());
   }

   // Triggers resource usage measurements on the fake CPU resource.
   void TriggerCpuOveruse() {
     rtc::Event event;
     encoder_queue()->PostTask([this, &event] {
       fake_cpu_resource_->SetUsageState(ResourceUsageState::kOveruse);
       event.Set();
     });
     ASSERT_TRUE(event.Wait(TimeDelta::Seconds(5)));
     time_controller_->AdvanceTime(TimeDelta::Zero());
   }

   void TriggerCpuUnderuse() {
     rtc::Event event;
     encoder_queue()->PostTask([this, &event] {
       fake_cpu_resource_->SetUsageState(ResourceUsageState::kUnderuse);
       event.Set();
     });
     ASSERT_TRUE(event.Wait(TimeDelta::Seconds(5)));
     time_controller_->AdvanceTime(TimeDelta::Zero());
   }

   // Triggers resource usage measurements on the fake quality resource.
   void TriggerQualityLow() {
     rtc::Event event;
     encoder_queue()->PostTask([this, &event] {
       fake_quality_resource_->SetUsageState(ResourceUsageState::kOveruse);
       event.Set();
     });
     ASSERT_TRUE(event.Wait(TimeDelta::Seconds(5)));
     time_controller_->AdvanceTime(TimeDelta::Zero());
   }
   void TriggerQualityHigh() {
     rtc::Event event;
     encoder_queue()->PostTask([this, &event] {
       fake_quality_resource_->SetUsageState(ResourceUsageState::kUnderuse);
       event.Set();
     });
     ASSERT_TRUE(event.Wait(TimeDelta::Seconds(5)));
     time_controller_->AdvanceTime(TimeDelta::Zero());
   }

   TimeController* const time_controller_;
   CpuOveruseDetectorProxy* overuse_detector_proxy_;
   rtc::scoped_refptr<FakeResource> fake_cpu_resource_;
   rtc::scoped_refptr<FakeResource> fake_quality_resource_;
   FakeAdaptationConstraint fake_adaptation_constraint_;
 };

 // Simulates simulcast behavior and makes highest stream resolutions divisible
 // by 4.
 class CroppingVideoStreamFactory
     : public VideoEncoderConfig::VideoStreamFactoryInterface {
  public:
   CroppingVideoStreamFactory() {}

  private:
   std::vector<VideoStream> CreateEncoderStreams(
       int frame_width,
       int frame_height,
       const VideoEncoderConfig& encoder_config) override {
     std::vector<VideoStream> streams = test::CreateVideoStreams(
         frame_width - frame_width % 4, frame_height - frame_height % 4,
         encoder_config);
     return streams;
   }
 };

 class AdaptingFrameForwarder : public test::FrameForwarder {
  public:
   explicit AdaptingFrameForwarder(TimeController* time_controller)
       : time_controller_(time_controller), adaptation_enabled_(false) {}
   ~AdaptingFrameForwarder() override {}

   void set_adaptation_enabled(bool enabled) {
     MutexLock lock(&mutex_);
     adaptation_enabled_ = enabled;
   }

   bool adaption_enabled() const {
     MutexLock lock(&mutex_);
     return adaptation_enabled_;
   }

   // The "last wants" is a snapshot of the previous rtc::VideoSinkWants where
   // the resolution or frame rate was different than it is currently. If
   // something else is modified, such as encoder resolutions, but the resolution
   // and frame rate stays the same, last wants is not updated.
   rtc::VideoSinkWants last_wants() const {
     MutexLock lock(&mutex_);
     return last_wants_;
   }

   absl::optional<int> last_sent_width() const { return last_width_; }
   absl::optional<int> last_sent_height() const { return last_height_; }

   void IncomingCapturedFrame(const VideoFrame& video_frame) override {
     RTC_DCHECK(time_controller_->GetMainThread()->IsCurrent());
     time_controller_->AdvanceTime(TimeDelta::Zero());

     int cropped_width = 0;
     int cropped_height = 0;
     int out_width = 0;
     int out_height = 0;
     if (adaption_enabled()) {
       RTC_DLOG(LS_INFO) << "IncomingCapturedFrame: AdaptFrameResolution()"
                         << "w=" << video_frame.width()
                         << "h=" << video_frame.height();
       if (adapter_.AdaptFrameResolution(
               video_frame.width(), video_frame.height(),
               video_frame.timestamp_us() * 1000, &cropped_width,
               &cropped_height, &out_width, &out_height)) {
         VideoFrame adapted_frame =
             VideoFrame::Builder()
                 .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
                     nullptr, out_width, out_height))
                 .set_ntp_time_ms(video_frame.ntp_time_ms())
                 .set_timestamp_ms(99)
                 .set_rotation(kVideoRotation_0)
                 .build();
         if (video_frame.has_update_rect()) {
           adapted_frame.set_update_rect(
               video_frame.update_rect().ScaleWithFrame(
                   video_frame.width(), video_frame.height(), 0, 0,
                   video_frame.width(), video_frame.height(), out_width,
                   out_height));
         }
         test::FrameForwarder::IncomingCapturedFrame(adapted_frame);
         last_width_.emplace(adapted_frame.width());
         last_height_.emplace(adapted_frame.height());
       } else {
         last_width_ = absl::nullopt;
         last_height_ = absl::nullopt;
       }
     } else {
       RTC_DLOG(LS_INFO) << "IncomingCapturedFrame: adaptation not enabled";
       test::FrameForwarder::IncomingCapturedFrame(video_frame);
       last_width_.emplace(video_frame.width());
       last_height_.emplace(video_frame.height());
     }
   }

   void OnOutputFormatRequest(int width, int height) {
     absl::optional<std::pair<int, int>> target_aspect_ratio =
         std::make_pair(width, height);
     absl::optional<int> max_pixel_count = width * height;
     absl::optional<int> max_fps;
     adapter_.OnOutputFormatRequest(target_aspect_ratio, max_pixel_count,
                                    max_fps);
   }

   void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override {
     MutexLock lock(&mutex_);
     rtc::VideoSinkWants prev_wants = sink_wants_locked();
     bool did_adapt =
         prev_wants.max_pixel_count != wants.max_pixel_count ||
         prev_wants.target_pixel_count != wants.target_pixel_count ||
         prev_wants.max_framerate_fps != wants.max_framerate_fps;
     if (did_adapt) {
       last_wants_ = prev_wants;
     }
     adapter_.OnSinkWants(wants);
     test::FrameForwarder::AddOrUpdateSinkLocked(sink, wants);
   }

   void RequestRefreshFrame() override { ++refresh_frames_requested_; }

   TimeController* const time_controller_;
   cricket::VideoAdapter adapter_;
   bool adaptation_enabled_ RTC_GUARDED_BY(mutex_);
   rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(mutex_);
   absl::optional<int> last_width_;
   absl::optional<int> last_height_;
   int refresh_frames_requested_{0};
 };

 // TODO(nisse): Mock only VideoStreamEncoderObserver.
 class MockableSendStatisticsProxy : public SendStatisticsProxy {
  public:
   MockableSendStatisticsProxy(Clock* clock,
                               const VideoSendStream::Config& config,
                               VideoEncoderConfig::ContentType content_type,
                               const FieldTrialsView& field_trials)
       : SendStatisticsProxy(clock, config, content_type, field_trials) {}

   VideoSendStream::Stats GetStats() override {
     MutexLock lock(&lock_);
     if (mock_stats_)
       return *mock_stats_;
     return SendStatisticsProxy::GetStats();
   }

   int GetInputFrameRate() const override {
     MutexLock lock(&lock_);
     if (mock_stats_)
       return mock_stats_->input_frame_rate;
     return SendStatisticsProxy::GetInputFrameRate();
   }
   void SetMockStats(const VideoSendStream::Stats& stats) {
     MutexLock lock(&lock_);
     mock_stats_.emplace(stats);
   }

   void ResetMockStats() {
     MutexLock lock(&lock_);
     mock_stats_.reset();
   }

   void SetDroppedFrameCallback(std::function<void(DropReason)> callback) {
     on_frame_dropped_ = std::move(callback);
   }

  private:
   void OnFrameDropped(DropReason reason) override {
     SendStatisticsProxy::OnFrameDropped(reason);
     if (on_frame_dropped_)
       on_frame_dropped_(reason);
   }

   mutable Mutex lock_;
   absl::optional<VideoSendStream::Stats> mock_stats_ RTC_GUARDED_BY(lock_);
   std::function<void(DropReason)> on_frame_dropped_;
 };

 class SimpleVideoStreamEncoderFactory {
  public:
   class AdaptedVideoStreamEncoder : public VideoStreamEncoder {
    public:
     using VideoStreamEncoder::VideoStreamEncoder;
     ~AdaptedVideoStreamEncoder() { Stop(); }
   };

   class MockFakeEncoder : public test::FakeEncoder {
    public:
     using FakeEncoder::FakeEncoder;
     MOCK_METHOD(CodecSpecificInfo,
                 EncodeHook,
                 (EncodedImage & encoded_image,
                  rtc::scoped_refptr<EncodedImageBuffer> buffer),
                 (override));
   };

   SimpleVideoStreamEncoderFactory() {
     encoder_settings_.encoder_factory = &encoder_factory_;
     encoder_settings_.bitrate_allocator_factory =
         bitrate_allocator_factory_.get();
   }

   std::unique_ptr<AdaptedVideoStreamEncoder> CreateWithEncoderQueue(
       std::unique_ptr<FrameCadenceAdapterInterface> zero_hertz_adapter,
       std::unique_ptr<TaskQueueBase, TaskQueueDeleter> encoder_queue,
       const FieldTrialsView* field_trials = nullptr) {
     auto result = std::make_unique<AdaptedVideoStreamEncoder>(
         time_controller_.GetClock(),
         /*number_of_cores=*/1,
         /*stats_proxy=*/stats_proxy_.get(), encoder_settings_,
         std::make_unique<CpuOveruseDetectorProxy>(
             /*stats_proxy=*/nullptr),
         std::move(zero_hertz_adapter), std::move(encoder_queue),
         VideoStreamEncoder::BitrateAllocationCallbackType::
             kVideoBitrateAllocation,
         field_trials ? *field_trials : field_trials_);
     result->SetSink(&sink_, /*rotation_applied=*/false);
     return result;
   }

   std::unique_ptr<AdaptedVideoStreamEncoder> Create(
       std::unique_ptr<FrameCadenceAdapterInterface> zero_hertz_adapter,
       TaskQueueBase** encoder_queue_ptr = nullptr) {
     auto encoder_queue =
         time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
             "EncoderQueue", TaskQueueFactory::Priority::NORMAL);
     if (encoder_queue_ptr)
       *encoder_queue_ptr = encoder_queue.get();
     return CreateWithEncoderQueue(std::move(zero_hertz_adapter),
                                   std::move(encoder_queue));
   }

   void DepleteTaskQueues() { time_controller_.AdvanceTime(TimeDelta::Zero()); }
   MockFakeEncoder& GetMockFakeEncoder() { return mock_fake_encoder_; }

   GlobalSimulatedTimeController* GetTimeController() {
     return &time_controller_;
   }

  private:
   class NullEncoderSink : public VideoStreamEncoderInterface::EncoderSink {
    public:
     ~NullEncoderSink() override = default;
     void OnEncoderConfigurationChanged(
         std::vector<VideoStream> streams,
         bool is_svc,
         VideoEncoderConfig::ContentType content_type,
         int min_transmit_bitrate_bps) override {}
     void OnBitrateAllocationUpdated(
         const VideoBitrateAllocation& allocation) override {}
     void OnVideoLayersAllocationUpdated(
         VideoLayersAllocation allocation) override {}
     Result OnEncodedImage(
         const EncodedImage& encoded_image,
         const CodecSpecificInfo* codec_specific_info) override {
       return Result(EncodedImageCallback::Result::OK);
     }
   };

   test::ScopedKeyValueConfig field_trials_;
   GlobalSimulatedTimeController time_controller_{Timestamp::Zero()};
   std::unique_ptr<TaskQueueFactory> task_queue_factory_{
       time_controller_.CreateTaskQueueFactory()};
   std::unique_ptr<MockableSendStatisticsProxy> stats_proxy_ =
       std::make_unique<MockableSendStatisticsProxy>(
           time_controller_.GetClock(),
           VideoSendStream::Config(nullptr),
           webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
           field_trials_);
   std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_ =
       CreateBuiltinVideoBitrateAllocatorFactory();
   VideoStreamEncoderSettings encoder_settings_{
       VideoEncoder::Capabilities(/*loss_notification=*/false)};
   MockFakeEncoder mock_fake_encoder_{time_controller_.GetClock()};
   test::VideoEncoderProxyFactory encoder_factory_{&mock_fake_encoder_};
   NullEncoderSink sink_;
 };

 class MockFrameCadenceAdapter : public FrameCadenceAdapterInterface {
  public:
   MOCK_METHOD(void, Initialize, (Callback * callback), (override));
   MOCK_METHOD(void,
               SetZeroHertzModeEnabled,
               (absl::optional<ZeroHertzModeParams>),
               (override));
   MOCK_METHOD(void, OnFrame, (const VideoFrame&), (override));
   MOCK_METHOD(absl::optional<uint32_t>, GetInputFrameRateFps, (), (override));
   MOCK_METHOD(void, UpdateFrameRate, (), (override));
   MOCK_METHOD(void,
               UpdateLayerQualityConvergence,
               (size_t spatial_index, bool converged),
               (override));
   MOCK_METHOD(void,
               UpdateLayerStatus,
               (size_t spatial_index, bool enabled),
               (override));
   MOCK_METHOD(void,
               UpdateVideoSourceRestrictions,
               (absl::optional<double>),
               (override));
   MOCK_METHOD(void, ProcessKeyFrameRequest, (), (override));
 };

 class MockEncoderSelector
     : public VideoEncoderFactory::EncoderSelectorInterface {
  public:
   MOCK_METHOD(void,
               OnCurrentEncoder,
               (const SdpVideoFormat& format),
               (override));
   MOCK_METHOD(absl::optional<SdpVideoFormat>,
               OnAvailableBitrate,
               (const DataRate& rate),
               (override));
   MOCK_METHOD(absl::optional<SdpVideoFormat>,
               OnResolutionChange,
               (const RenderResolution& resolution),
               (override));
   MOCK_METHOD(absl::optional<SdpVideoFormat>, OnEncoderBroken, (), (override));
 };

 class MockVideoSourceInterface : public rtc::VideoSourceInterface<VideoFrame> {
  public:
   MOCK_METHOD(void,
               AddOrUpdateSink,
               (rtc::VideoSinkInterface<VideoFrame>*,
                const rtc::VideoSinkWants&),
               (override));
   MOCK_METHOD(void,
               RemoveSink,
               (rtc::VideoSinkInterface<VideoFrame>*),
               (override));
   MOCK_METHOD(void, RequestRefreshFrame, (), (override));
 };

 }  // namespace

 class VideoStreamEncoderTest : public ::testing::Test {
  public:
   static constexpr TimeDelta kDefaultTimeout = TimeDelta::Seconds(1);

   VideoStreamEncoderTest()
       : video_send_config_(VideoSendStream::Config(nullptr)),
         codec_width_(320),
         codec_height_(240),
         max_framerate_(kDefaultFramerate),
         fake_encoder_(&time_controller_),
         encoder_factory_(&fake_encoder_),
         stats_proxy_(new MockableSendStatisticsProxy(
             time_controller_.GetClock(),
             video_send_config_,
             webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo,
             field_trials_)),
         sink_(&time_controller_, &fake_encoder_) {}

   void SetUp() override {
     metrics::Reset();
     video_send_config_ = VideoSendStream::Config(nullptr);
     video_send_config_.encoder_settings.encoder_factory = &encoder_factory_;
     video_send_config_.encoder_settings.bitrate_allocator_factory =
         &bitrate_allocator_factory_;
     video_send_config_.rtp.payload_name = "FAKE";
     video_send_config_.rtp.payload_type = 125;

     VideoEncoderConfig video_encoder_config;
     test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
     EXPECT_EQ(1u, video_encoder_config.simulcast_layers.size());
     video_encoder_config.simulcast_layers[0].num_temporal_layers = 1;
     video_encoder_config.simulcast_layers[0].max_framerate = max_framerate_;
     video_encoder_config_ = video_encoder_config.Copy();

     ConfigureEncoder(std::move(video_encoder_config));
   }

   void ConfigureEncoder(
       VideoEncoderConfig video_encoder_config,
       VideoStreamEncoder::BitrateAllocationCallbackType
           allocation_callback_type =
               VideoStreamEncoder::BitrateAllocationCallbackType::
                   kVideoBitrateAllocationWhenScreenSharing,
       int num_cores = 1) {
     if (video_stream_encoder_)
       video_stream_encoder_->Stop();

     auto encoder_queue = GetTaskQueueFactory()->CreateTaskQueue(
         "EncoderQueue", TaskQueueFactory::Priority::NORMAL);
     TaskQueueBase* encoder_queue_ptr = encoder_queue.get();
     std::unique_ptr<FrameCadenceAdapterInterface> cadence_adapter =
         FrameCadenceAdapterInterface::Create(time_controller_.GetClock(),
                                              encoder_queue_ptr, field_trials_);
     video_stream_encoder_ = std::make_unique<VideoStreamEncoderUnderTest>(
         &time_controller_, std::move(cadence_adapter), std::move(encoder_queue),
         stats_proxy_.get(), video_send_config_.encoder_settings,
         allocation_callback_type, field_trials_, num_cores);
     video_stream_encoder_->SetSink(&sink_, /*rotation_applied=*/false);
     video_stream_encoder_->SetSource(
         &video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
     video_stream_encoder_->SetStartBitrate(kTargetBitrate.bps());
     video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                             kMaxPayloadLength, nullptr);
     video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   }

   void ResetEncoder(const std::string& payload_name,
                     size_t num_streams,
                     size_t num_temporal_layers,
                     unsigned char num_spatial_layers,
                     bool screenshare,
                     VideoStreamEncoder::BitrateAllocationCallbackType
                         allocation_callback_type =
                             VideoStreamEncoder::BitrateAllocationCallbackType::
                                 kVideoBitrateAllocationWhenScreenSharing,
                     int num_cores = 1) {
     video_send_config_.rtp.payload_name = payload_name;

     VideoEncoderConfig video_encoder_config;
     test::FillEncoderConfiguration(PayloadStringToCodecType(payload_name),
                                    num_streams, &video_encoder_config);
     for (auto& layer : video_encoder_config.simulcast_layers) {
       layer.num_temporal_layers = num_temporal_layers;
       layer.max_framerate = kDefaultFramerate;
     }
     video_encoder_config.max_bitrate_bps =
         num_streams == 1 ? kTargetBitrate.bps() : kSimulcastTargetBitrate.bps();
     video_encoder_config.content_type =
         screenshare ? VideoEncoderConfig::ContentType::kScreen
                     : VideoEncoderConfig::ContentType::kRealtimeVideo;
     if (payload_name == "VP9") {
       VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
       vp9_settings.numberOfSpatialLayers = num_spatial_layers;
       vp9_settings.automaticResizeOn = num_spatial_layers <= 1;
       video_encoder_config.encoder_specific_settings =
           rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>(
               vp9_settings);
     }
     ConfigureEncoder(std::move(video_encoder_config), allocation_callback_type,
                      num_cores);
   }

   VideoFrame CreateFrame(int64_t ntp_time_ms,
                          rtc::Event* destruction_event) const {
     return VideoFrame::Builder()
         .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
             destruction_event, codec_width_, codec_height_))
         .set_ntp_time_ms(ntp_time_ms)
         .set_timestamp_ms(99)
         .set_rotation(kVideoRotation_0)
         .build();
   }

   VideoFrame CreateFrameWithUpdatedPixel(int64_t ntp_time_ms,
                                          rtc::Event* destruction_event,
                                          int offset_x) const {
     return VideoFrame::Builder()
         .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>(
             destruction_event, codec_width_, codec_height_))
         .set_ntp_time_ms(ntp_time_ms)
         .set_timestamp_ms(99)
         .set_rotation(kVideoRotation_0)
         .set_update_rect(VideoFrame::UpdateRect{offset_x, 0, 1, 1})
         .build();
   }

   VideoFrame CreateFrame(int64_t ntp_time_ms, int width, int height) const {
     auto buffer = rtc::make_ref_counted<TestBuffer>(nullptr, width, height);
     I420Buffer::SetBlack(buffer.get());
     return VideoFrame::Builder()
         .set_video_frame_buffer(std::move(buffer))
         .set_ntp_time_ms(ntp_time_ms)
         .set_timestamp_ms(ntp_time_ms)
         .set_rotation(kVideoRotation_0)
         .build();
   }

   VideoFrame CreateNV12Frame(int64_t ntp_time_ms, int width, int height) const {
     return VideoFrame::Builder()
         .set_video_frame_buffer(NV12Buffer::Create(width, height))
         .set_ntp_time_ms(ntp_time_ms)
         .set_timestamp_ms(ntp_time_ms)
         .set_rotation(kVideoRotation_0)
         .build();
   }

   VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms,
                                    rtc::Event* destruction_event,
                                    int width,
                                    int height) const {
     return VideoFrame::Builder()
         .set_video_frame_buffer(rtc::make_ref_counted<FakeNativeBuffer>(
             destruction_event, width, height))
         .set_ntp_time_ms(ntp_time_ms)
         .set_timestamp_ms(99)
         .set_rotation(kVideoRotation_0)
         .build();
   }

   VideoFrame CreateFakeNV12NativeFrame(int64_t ntp_time_ms,
                                        rtc::Event* destruction_event,
                                        int width,
                                        int height) const {
     return VideoFrame::Builder()
         .set_video_frame_buffer(rtc::make_ref_counted<FakeNV12NativeBuffer>(
             destruction_event, width, height))
         .set_ntp_time_ms(ntp_time_ms)
         .set_timestamp_ms(99)
         .set_rotation(kVideoRotation_0)
         .build();
   }

   VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms,
                                    rtc::Event* destruction_event) const {
     return CreateFakeNativeFrame(ntp_time_ms, destruction_event, codec_width_,
                                  codec_height_);
   }

   void VerifyAllocatedBitrate(const VideoBitrateAllocation& expected_bitrate) {
     video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
         kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

     video_source_.IncomingCapturedFrame(
         CreateFrame(1, codec_width_, codec_height_));
     WaitForEncodedFrame(1);
     EXPECT_EQ(expected_bitrate, sink_.GetLastVideoBitrateAllocation());
   }

   void WaitForEncodedFrame(int64_t expected_ntp_time) {
     sink_.WaitForEncodedFrame(expected_ntp_time);
     AdvanceTime(TimeDelta::Seconds(1) / max_framerate_);
   }

   bool TimedWaitForEncodedFrame(int64_t expected_ntp_time, TimeDelta timeout) {
     bool ok = sink_.TimedWaitForEncodedFrame(expected_ntp_time, timeout);
     AdvanceTime(TimeDelta::Seconds(1) / max_framerate_);
     return ok;
   }

   void WaitForEncodedFrame(uint32_t expected_width, uint32_t expected_height) {
     sink_.WaitForEncodedFrame(expected_width, expected_height);
     AdvanceTime(TimeDelta::Seconds(1) / max_framerate_);
   }

   void ExpectDroppedFrame() {
     sink_.ExpectDroppedFrame();
     AdvanceTime(TimeDelta::Seconds(1) / max_framerate_);
   }

   bool WaitForFrame(TimeDelta timeout) {
     bool ok = sink_.WaitForFrame(timeout);
     AdvanceTime(TimeDelta::Seconds(1) / max_framerate_);
     return ok;
   }

   class TestEncoder : public test::FakeEncoder {
    public:
     explicit TestEncoder(TimeController* time_controller)
         : FakeEncoder(time_controller->GetClock()),
           time_controller_(time_controller) {
       RTC_DCHECK(time_controller_);
     }

     VideoEncoder::EncoderInfo GetEncoderInfo() const override {
       MutexLock lock(&local_mutex_);
       EncoderInfo info = FakeEncoder::GetEncoderInfo();
       if (initialized_ == EncoderState::kInitialized) {
         if (quality_scaling_) {
           info.scaling_settings = VideoEncoder::ScalingSettings(
               kQpLow, kQpHigh, kMinPixelsPerFrame);
         }
         info.is_hardware_accelerated = is_hardware_accelerated_;
         for (int i = 0; i < kMaxSpatialLayers; ++i) {
           if (temporal_layers_supported_[i]) {
             info.fps_allocation[i].clear();
             int num_layers = temporal_layers_supported_[i].value() ? 2 : 1;
             for (int tid = 0; tid < num_layers; ++tid)
               info.fps_allocation[i].push_back(255 / (num_layers - tid));
           }
         }
       }

       info.resolution_bitrate_limits = resolution_bitrate_limits_;
       info.requested_resolution_alignment = requested_resolution_alignment_;
       info.apply_alignment_to_all_simulcast_layers =
           apply_alignment_to_all_simulcast_layers_;
       info.preferred_pixel_formats = preferred_pixel_formats_;
       if (is_qp_trusted_.has_value()) {
         info.is_qp_trusted = is_qp_trusted_;
       }
       return info;
     }

     int32_t RegisterEncodeCompleteCallback(
         EncodedImageCallback* callback) override {
       MutexLock lock(&local_mutex_);
       encoded_image_callback_ = callback;
       return FakeEncoder::RegisterEncodeCompleteCallback(callback);
     }

     void ContinueEncode() { continue_encode_event_.Set(); }

     void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                   uint32_t timestamp) const {
       MutexLock lock(&local_mutex_);
       EXPECT_EQ(timestamp_, timestamp);
       EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
     }

     void SetQualityScaling(bool b) {
       MutexLock lock(&local_mutex_);
       quality_scaling_ = b;
     }

     void SetRequestedResolutionAlignment(
         uint32_t requested_resolution_alignment) {
       MutexLock lock(&local_mutex_);
       requested_resolution_alignment_ = requested_resolution_alignment;
     }

     void SetApplyAlignmentToAllSimulcastLayers(bool b) {
       MutexLock lock(&local_mutex_);
       apply_alignment_to_all_simulcast_layers_ = b;
     }

     void SetIsHardwareAccelerated(bool is_hardware_accelerated) {
       MutexLock lock(&local_mutex_);
       is_hardware_accelerated_ = is_hardware_accelerated;
     }

     void SetTemporalLayersSupported(size_t spatial_idx, bool supported) {
       RTC_DCHECK_LT(spatial_idx, kMaxSpatialLayers);
       MutexLock lock(&local_mutex_);
       temporal_layers_supported_[spatial_idx] = supported;
     }

     void SetResolutionBitrateLimits(
         std::vector<ResolutionBitrateLimits> thresholds) {
       MutexLock lock(&local_mutex_);
       resolution_bitrate_limits_ = thresholds;
     }

     void ForceInitEncodeFailure(bool force_failure) {
       MutexLock lock(&local_mutex_);
       force_init_encode_failed_ = force_failure;
     }

     void SimulateOvershoot(double rate_factor) {
       MutexLock lock(&local_mutex_);
       rate_factor_ = rate_factor;
     }

     uint32_t GetLastFramerate() const {
       MutexLock lock(&local_mutex_);
       return last_framerate_;
     }

     VideoFrame::UpdateRect GetLastUpdateRect() const {
       MutexLock lock(&local_mutex_);
       return last_update_rect_;
     }

     const std::vector<VideoFrameType>& LastFrameTypes() const {
       MutexLock lock(&local_mutex_);
       return last_frame_types_;
     }

     void InjectFrame(const VideoFrame& input_image, bool keyframe) {
       const std::vector<VideoFrameType> frame_type = {
           keyframe ? VideoFrameType::kVideoFrameKey
                    : VideoFrameType::kVideoFrameDelta};
       {
         MutexLock lock(&local_mutex_);
         last_frame_types_ = frame_type;
       }
       FakeEncoder::Encode(input_image, &frame_type);
     }

     void InjectEncodedImage(const EncodedImage& image,
                             const CodecSpecificInfo* codec_specific_info) {
       MutexLock lock(&local_mutex_);
       encoded_image_callback_->OnEncodedImage(image, codec_specific_info);
     }

     void SetEncodedImageData(
         rtc::scoped_refptr<EncodedImageBufferInterface> encoded_image_data) {
       MutexLock lock(&local_mutex_);
       encoded_image_data_ = encoded_image_data;
     }

     void ExpectNullFrame() {
       MutexLock lock(&local_mutex_);
       expect_null_frame_ = true;
     }

     absl::optional<VideoEncoder::RateControlParameters>
     GetAndResetLastRateControlSettings() {
       auto settings = last_rate_control_settings_;
       last_rate_control_settings_.reset();
       return settings;
     }

     int GetLastInputWidth() const {
       MutexLock lock(&local_mutex_);
       return last_input_width_;
     }

     int GetLastInputHeight() const {
       MutexLock lock(&local_mutex_);
       return last_input_height_;
     }

     absl::optional<VideoFrameBuffer::Type> GetLastInputPixelFormat() {
       MutexLock lock(&local_mutex_);
       return last_input_pixel_format_;
     }

     int GetNumSetRates() const {
       MutexLock lock(&local_mutex_);
       return num_set_rates_;
     }

     void SetPreferredPixelFormats(
         absl::InlinedVector<VideoFrameBuffer::Type, kMaxPreferredPixelFormats>
             pixel_formats) {
       MutexLock lock(&local_mutex_);
       preferred_pixel_formats_ = std::move(pixel_formats);
     }

     void SetIsQpTrusted(absl::optional<bool> trusted) {
       MutexLock lock(&local_mutex_);
       is_qp_trusted_ = trusted;
     }

     VideoCodecComplexity LastEncoderComplexity() {
       MutexLock lock(&local_mutex_);
       return last_encoder_complexity_;
     }

    private:
     int32_t Encode(const VideoFrame& input_image,
                    const std::vector<VideoFrameType>* frame_types) override {
       {
         MutexLock lock(&local_mutex_);
         if (expect_null_frame_) {
           EXPECT_EQ(input_image.timestamp(), 0u);
           EXPECT_EQ(input_image.width(), 1);
           last_frame_types_ = *frame_types;
           expect_null_frame_ = false;
         } else {
           EXPECT_GT(input_image.timestamp(), timestamp_);
           EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_);
           EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90);
         }

         timestamp_ = input_image.timestamp();
         ntp_time_ms_ = input_image.ntp_time_ms();
         last_input_width_ = input_image.width();
         last_input_height_ = input_image.height();
         last_update_rect_ = input_image.update_rect();
         last_frame_types_ = *frame_types;
         last_input_pixel_format_ = input_image.video_frame_buffer()->type();
       }
       int32_t result = FakeEncoder::Encode(input_image, frame_types);
       return result;
     }

     CodecSpecificInfo EncodeHook(
         EncodedImage& encoded_image,
         rtc::scoped_refptr<EncodedImageBuffer> buffer) override {
       CodecSpecificInfo codec_specific;
       {
         MutexLock lock(&mutex_);
         codec_specific.codecType = config_.codecType;
       }
       MutexLock lock(&local_mutex_);
       if (encoded_image_data_) {
         encoded_image.SetEncodedData(encoded_image_data_);
       }
       return codec_specific;
     }

     int32_t InitEncode(const VideoCodec* config,
                        const Settings& settings) override {
       int res = FakeEncoder::InitEncode(config, settings);

       MutexLock lock(&local_mutex_);
       EXPECT_EQ(initialized_, EncoderState::kUninitialized);

       if (config->codecType == kVideoCodecVP8) {
         // Simulate setting up temporal layers, in order to validate the life
         // cycle of these objects.
         Vp8TemporalLayersFactory factory;
         frame_buffer_controller_ =
             factory.Create(*config, settings, &fec_controller_override_);
       }

       last_encoder_complexity_ = config->GetVideoEncoderComplexity();

       if (force_init_encode_failed_) {
         initialized_ = EncoderState::kInitializationFailed;
         return -1;
       }

       initialized_ = EncoderState::kInitialized;
       return res;
     }

     int32_t Release() override {
       MutexLock lock(&local_mutex_);
       EXPECT_NE(initialized_, EncoderState::kUninitialized);
       initialized_ = EncoderState::kUninitialized;
       return FakeEncoder::Release();
     }

     void SetRates(const RateControlParameters& parameters) {
       MutexLock lock(&local_mutex_);
       num_set_rates_++;
       VideoBitrateAllocation adjusted_rate_allocation;
       for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
         for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
           if (parameters.bitrate.HasBitrate(si, ti)) {
             adjusted_rate_allocation.SetBitrate(
                 si, ti,
                 static_cast<uint32_t>(parameters.bitrate.GetBitrate(si, ti) *
                                       rate_factor_));
           }
         }
       }
       last_framerate_ = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
       last_rate_control_settings_ = parameters;
       RateControlParameters adjusted_paramters = parameters;
       adjusted_paramters.bitrate = adjusted_rate_allocation;
       FakeEncoder::SetRates(adjusted_paramters);
     }

     TimeController* const time_controller_;
     mutable Mutex local_mutex_;
     enum class EncoderState {
       kUninitialized,
       kInitializationFailed,
       kInitialized
     } initialized_ RTC_GUARDED_BY(local_mutex_) = EncoderState::kUninitialized;
     rtc::Event continue_encode_event_;
     uint32_t timestamp_ RTC_GUARDED_BY(local_mutex_) = 0;
     int64_t ntp_time_ms_ RTC_GUARDED_BY(local_mutex_) = 0;
     int last_input_width_ RTC_GUARDED_BY(local_mutex_) = 0;
     int last_input_height_ RTC_GUARDED_BY(local_mutex_) = 0;
     bool quality_scaling_ RTC_GUARDED_BY(local_mutex_) = true;
     uint32_t requested_resolution_alignment_ RTC_GUARDED_BY(local_mutex_) = 1;
     bool apply_alignment_to_all_simulcast_layers_ RTC_GUARDED_BY(local_mutex_) =
         false;
     bool is_hardware_accelerated_ RTC_GUARDED_BY(local_mutex_) = false;
     rtc::scoped_refptr<EncodedImageBufferInterface> encoded_image_data_
         RTC_GUARDED_BY(local_mutex_);
     std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
         RTC_GUARDED_BY(local_mutex_);
     absl::optional<bool>
         temporal_layers_supported_[kMaxSpatialLayers] RTC_GUARDED_BY(
             local_mutex_);
     bool force_init_encode_failed_ RTC_GUARDED_BY(local_mutex_) = false;
     double rate_factor_ RTC_GUARDED_BY(local_mutex_) = 1.0;
     uint32_t last_framerate_ RTC_GUARDED_BY(local_mutex_) = 0;
     absl::optional<VideoEncoder::RateControlParameters>
         last_rate_control_settings_;
     VideoFrame::UpdateRect last_update_rect_ RTC_GUARDED_BY(local_mutex_) = {
         0, 0, 0, 0};
     std::vector<VideoFrameType> last_frame_types_;
     bool expect_null_frame_ = false;
     EncodedImageCallback* encoded_image_callback_ RTC_GUARDED_BY(local_mutex_) =
         nullptr;
     NiceMock<MockFecControllerOverride> fec_controller_override_;
     std::vector<ResolutionBitrateLimits> resolution_bitrate_limits_
         RTC_GUARDED_BY(local_mutex_);
     int num_set_rates_ RTC_GUARDED_BY(local_mutex_) = 0;
     absl::optional<VideoFrameBuffer::Type> last_input_pixel_format_
         RTC_GUARDED_BY(local_mutex_);
     absl::InlinedVector<VideoFrameBuffer::Type, kMaxPreferredPixelFormats>
         preferred_pixel_formats_ RTC_GUARDED_BY(local_mutex_);
     absl::optional<bool> is_qp_trusted_ RTC_GUARDED_BY(local_mutex_);
     VideoCodecComplexity last_encoder_complexity_ RTC_GUARDED_BY(local_mutex_){
         VideoCodecComplexity::kComplexityNormal};
   };

   class TestSink : public VideoStreamEncoder::EncoderSink {
    public:
     TestSink(TimeController* time_controller, TestEncoder* test_encoder)
         : time_controller_(time_controller), test_encoder_(test_encoder) {
       RTC_DCHECK(time_controller_);
     }

     void WaitForEncodedFrame(int64_t expected_ntp_time) {
       EXPECT_TRUE(TimedWaitForEncodedFrame(expected_ntp_time, kDefaultTimeout));
     }

     bool TimedWaitForEncodedFrame(int64_t expected_ntp_time,
                                   TimeDelta timeout) {
       uint32_t timestamp = 0;
       if (!WaitForFrame(timeout))
         return false;
       {
         MutexLock lock(&mutex_);
         timestamp = last_timestamp_;
       }
       test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp);
       return true;
     }

     void WaitForEncodedFrame(uint32_t expected_width,
                              uint32_t expected_height) {
       EXPECT_TRUE(WaitForFrame(kDefaultTimeout));
       CheckLastFrameSizeMatches(expected_width, expected_height);
     }

     void CheckLastFrameSizeMatches(uint32_t expected_width,
                                    uint32_t expected_height) {
       uint32_t width = 0;
       uint32_t height = 0;
       {
         MutexLock lock(&mutex_);
         width = last_width_;
         height = last_height_;
       }
       EXPECT_EQ(expected_height, height);
       EXPECT_EQ(expected_width, width);
     }

     void CheckLastFrameRotationMatches(VideoRotation expected_rotation) {
       VideoRotation rotation;
       {
         MutexLock lock(&mutex_);
         rotation = last_rotation_;
       }
       EXPECT_EQ(expected_rotation, rotation);
     }

     void ExpectDroppedFrame() {
       EXPECT_FALSE(WaitForFrame(TimeDelta::Millis(100)));
     }

     bool WaitForFrame(TimeDelta timeout) {
       RTC_DCHECK(time_controller_->GetMainThread()->IsCurrent());
       time_controller_->AdvanceTime(TimeDelta::Zero());
       bool ret = encoded_frame_event_.Wait(timeout);
       time_controller_->AdvanceTime(TimeDelta::Zero());
       return ret;
     }

     void SetExpectNoFrames() {
       MutexLock lock(&mutex_);
       expect_frames_ = false;
     }

     int number_of_reconfigurations() const {
       MutexLock lock(&mutex_);
       return number_of_reconfigurations_;
     }

     int last_min_transmit_bitrate() const {
       MutexLock lock(&mutex_);
       return min_transmit_bitrate_bps_;
     }

     void SetNumExpectedLayers(size_t num_layers) {
       MutexLock lock(&mutex_);
       num_expected_layers_ = num_layers;
     }

     int64_t GetLastCaptureTimeMs() const {
       MutexLock lock(&mutex_);
       return last_capture_time_ms_;
     }

     const EncodedImage& GetLastEncodedImage() {
       MutexLock lock(&mutex_);
       return last_encoded_image_;
     }

     std::vector<uint8_t> GetLastEncodedImageData() {
       MutexLock lock(&mutex_);
       return std::move(last_encoded_image_data_);
     }

     VideoBitrateAllocation GetLastVideoBitrateAllocation() {
       MutexLock lock(&mutex_);
       return last_bitrate_allocation_;
     }

     int number_of_bitrate_allocations() const {
       MutexLock lock(&mutex_);
       return number_of_bitrate_allocations_;
     }

     VideoLayersAllocation GetLastVideoLayersAllocation() {
       MutexLock lock(&mutex_);
       return last_layers_allocation_;
     }

     int number_of_layers_allocations() const {
       MutexLock lock(&mutex_);
       return number_of_layers_allocations_;
     }

    private:
     Result OnEncodedImage(
         const EncodedImage& encoded_image,
         const CodecSpecificInfo* codec_specific_info) override {
       MutexLock lock(&mutex_);
       EXPECT_TRUE(expect_frames_);
       last_encoded_image_ = EncodedImage(encoded_image);
       last_encoded_image_data_ = std::vector<uint8_t>(
           encoded_image.data(), encoded_image.data() + encoded_image.size());
       uint32_t timestamp = encoded_image.RtpTimestamp();
       if (last_timestamp_ != timestamp) {
         num_received_layers_ = 1;
         last_width_ = encoded_image._encodedWidth;
         last_height_ = encoded_image._encodedHeight;
       } else {
         ++num_received_layers_;
         last_width_ = std::max(encoded_image._encodedWidth, last_width_);
         last_height_ = std::max(encoded_image._encodedHeight, last_height_);
       }
       last_timestamp_ = timestamp;
       last_capture_time_ms_ = encoded_image.capture_time_ms_;
       last_rotation_ = encoded_image.rotation_;
       if (num_received_layers_ == num_expected_layers_) {
         encoded_frame_event_.Set();
       }
       return Result(Result::OK, last_timestamp_);
     }

     void OnEncoderConfigurationChanged(
         std::vector<VideoStream> streams,
         bool is_svc,
         VideoEncoderConfig::ContentType content_type,
         int min_transmit_bitrate_bps) override {
       MutexLock lock(&mutex_);
       ++number_of_reconfigurations_;
       min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
     }

     void OnBitrateAllocationUpdated(
         const VideoBitrateAllocation& allocation) override {
       MutexLock lock(&mutex_);
       ++number_of_bitrate_allocations_;
       last_bitrate_allocation_ = allocation;
     }

     void OnVideoLayersAllocationUpdated(
         VideoLayersAllocation allocation) override {
       MutexLock lock(&mutex_);
       ++number_of_layers_allocations_;
       last_layers_allocation_ = allocation;
       rtc::StringBuilder log;
       for (const auto& layer : allocation.active_spatial_layers) {
         log << layer.width << "x" << layer.height << "@" << layer.frame_rate_fps
             << "[";
         for (const auto target_bitrate :
              layer.target_bitrate_per_temporal_layer) {
           log << target_bitrate.kbps() << ",";
         }
         log << "]";
       }
       RTC_DLOG(LS_INFO) << "OnVideoLayersAllocationUpdated " << log.str();
     }

     TimeController* const time_controller_;
     mutable Mutex mutex_;
     TestEncoder* test_encoder_;
     rtc::Event encoded_frame_event_;
     EncodedImage last_encoded_image_;
     std::vector<uint8_t> last_encoded_image_data_;
     uint32_t last_timestamp_ = 0;
     int64_t last_capture_time_ms_ = 0;
     uint32_t last_height_ = 0;
     uint32_t last_width_ = 0;
     VideoRotation last_rotation_ = kVideoRotation_0;
     size_t num_expected_layers_ = 1;
     size_t num_received_layers_ = 0;
     bool expect_frames_ = true;
     int number_of_reconfigurations_ = 0;
     int min_transmit_bitrate_bps_ = 0;
     VideoBitrateAllocation last_bitrate_allocation_ RTC_GUARDED_BY(&mutex_);
     int number_of_bitrate_allocations_ RTC_GUARDED_BY(&mutex_) = 0;
     VideoLayersAllocation last_layers_allocation_ RTC_GUARDED_BY(&mutex_);
     int number_of_layers_allocations_ RTC_GUARDED_BY(&mutex_) = 0;
   };

   class VideoBitrateAllocatorProxyFactory
       : public VideoBitrateAllocatorFactory {
    public:
     VideoBitrateAllocatorProxyFactory()
         : bitrate_allocator_factory_(
               CreateBuiltinVideoBitrateAllocatorFactory()) {}

     std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
         const VideoCodec& codec) override {
       MutexLock lock(&mutex_);
       codec_config_ = codec;
       return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec);
     }

     VideoCodec codec_config() const {
       MutexLock lock(&mutex_);
       return codec_config_;
     }

    private:
     std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;

     mutable Mutex mutex_;
     VideoCodec codec_config_ RTC_GUARDED_BY(mutex_);
   };

   Clock* clock() { return time_controller_.GetClock(); }
   void AdvanceTime(TimeDelta duration) {
     time_controller_.AdvanceTime(duration);
   }

   int64_t CurrentTimeMs() { return clock()->CurrentTime().ms(); }

  protected:
   virtual TaskQueueFactory* GetTaskQueueFactory() {
     return time_controller_.GetTaskQueueFactory();
   }

   test::ScopedKeyValueConfig field_trials_;
   GlobalSimulatedTimeController time_controller_{Timestamp::Micros(1234)};
   VideoSendStream::Config video_send_config_;
   VideoEncoderConfig video_encoder_config_;
   int codec_width_;
   int codec_height_;
   int max_framerate_;
   TestEncoder fake_encoder_;
   test::VideoEncoderProxyFactory encoder_factory_;
   VideoBitrateAllocatorProxyFactory bitrate_allocator_factory_;
   std::unique_ptr<MockableSendStatisticsProxy> stats_proxy_;
   TestSink sink_;
   AdaptingFrameForwarder video_source_{&time_controller_};
   std::unique_ptr<VideoStreamEncoderUnderTest> video_stream_encoder_;
 };

 TEST_F(VideoStreamEncoderTest, EncodeOneFrame) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
   WaitForEncodedFrame(1);
   EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeout));
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
   // Dropped since no target bitrate has been set.
   rtc::Event frame_destroyed_event;
   // The encoder will cache up to one frame for a short duration. Adding two
   // frames means that the first frame will be dropped and the second frame will
   // be sent when the encoder is enabled.
   video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
   AdvanceTime(TimeDelta::Millis(10));
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   AdvanceTime(TimeDelta::Zero());
   EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeout));

   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   // The pending frame should be received.
   WaitForEncodedFrame(2);
   video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));

   WaitForEncodedFrame(3);
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, DropsFramesWhenRateSetToZero) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);

   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       DataRate::Zero(), DataRate::Zero(), DataRate::Zero(), 0, 0, 0);

   // The encoder will cache up to one frame for a short duration. Adding two
   // frames means that the first frame will be dropped and the second frame will
   // be sent when the encoder is resumed.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));

   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   WaitForEncodedFrame(3);
   video_source_.IncomingCapturedFrame(CreateFrame(4, nullptr));
   WaitForEncodedFrame(4);
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);

   // This frame will be dropped since it has the same ntp timestamp.
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));

   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, DropsFrameAfterStop) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);

   video_stream_encoder_->Stop();
   sink_.SetExpectNoFrames();
   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event));
   EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeout));
 }

 TEST_F(VideoStreamEncoderTest, DropsPendingFramesOnSlowEncode) {
   test::FrameForwarder source;
   video_stream_encoder_->SetSource(&source,
                                    DegradationPreference::MAINTAIN_FRAMERATE);
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   int dropped_count = 0;
   stats_proxy_->SetDroppedFrameCallback(
       [&dropped_count](VideoStreamEncoderObserver::DropReason) {
         ++dropped_count;
       });

   source.IncomingCapturedFrame(CreateFrame(1, nullptr));
   source.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   video_stream_encoder_->Stop();
   EXPECT_EQ(1, dropped_count);
 }

 TEST_F(VideoStreamEncoderTest, NativeFrameWithoutI420SupportGetsDelivered) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(
       CreateFakeNativeFrame(1, &frame_destroyed_event));
   WaitForEncodedFrame(1);
   EXPECT_EQ(VideoFrameBuffer::Type::kNative,
             fake_encoder_.GetLastInputPixelFormat());
   EXPECT_EQ(fake_encoder_.config().width, fake_encoder_.GetLastInputWidth());
   EXPECT_EQ(fake_encoder_.config().height, fake_encoder_.GetLastInputHeight());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        NativeFrameWithoutI420SupportGetsCroppedIfNecessary) {
   // Use the cropping factory.
   video_encoder_config_.video_stream_factory =
       rtc::make_ref_counted<CroppingVideoStreamFactory>();
   video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config_),
                                           kMaxPayloadLength);
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();

   // Capture a frame at codec_width_/codec_height_.
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);
   // The encoder will have been configured once.
   EXPECT_EQ(1, sink_.number_of_reconfigurations());
   EXPECT_EQ(codec_width_, fake_encoder_.config().width);
   EXPECT_EQ(codec_height_, fake_encoder_.config().height);

   // Now send in a fake frame that needs to be cropped as the width/height
   // aren't divisible by 4 (see CreateEncoderStreams above).
   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFakeNativeFrame(
       2, &frame_destroyed_event, codec_width_ + 1, codec_height_ + 1));
   WaitForEncodedFrame(2);
   EXPECT_EQ(VideoFrameBuffer::Type::kNative,
             fake_encoder_.GetLastInputPixelFormat());
   EXPECT_EQ(fake_encoder_.config().width, fake_encoder_.GetLastInputWidth());
   EXPECT_EQ(fake_encoder_.config().height, fake_encoder_.GetLastInputHeight());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, NonI420FramesShouldNotBeConvertedToI420) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   video_source_.IncomingCapturedFrame(
       CreateNV12Frame(1, codec_width_, codec_height_));
   WaitForEncodedFrame(1);
   EXPECT_EQ(VideoFrameBuffer::Type::kNV12,
             fake_encoder_.GetLastInputPixelFormat());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, NativeFrameGetsDelivered_NoFrameTypePreference) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   fake_encoder_.SetPreferredPixelFormats({});

   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
       1, &frame_destroyed_event, codec_width_, codec_height_));
   WaitForEncodedFrame(1);
   EXPECT_EQ(VideoFrameBuffer::Type::kNative,
             fake_encoder_.GetLastInputPixelFormat());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        NativeFrameGetsDelivered_PixelFormatPreferenceMatches) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   fake_encoder_.SetPreferredPixelFormats({VideoFrameBuffer::Type::kNV12});

   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
       1, &frame_destroyed_event, codec_width_, codec_height_));
   WaitForEncodedFrame(1);
   EXPECT_EQ(VideoFrameBuffer::Type::kNative,
             fake_encoder_.GetLastInputPixelFormat());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, NativeFrameGetsDelivered_MappingIsNotFeasible) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   // Fake NV12 native frame does not allow mapping to I444.
   fake_encoder_.SetPreferredPixelFormats({VideoFrameBuffer::Type::kI444});

   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
       1, &frame_destroyed_event, codec_width_, codec_height_));
   WaitForEncodedFrame(1);
   EXPECT_EQ(VideoFrameBuffer::Type::kNative,
             fake_encoder_.GetLastInputPixelFormat());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, NativeFrameGetsDelivered_BackedByNV12) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   rtc::Event frame_destroyed_event;
   video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame(
       1, &frame_destroyed_event, codec_width_, codec_height_));
   WaitForEncodedFrame(1);
   EXPECT_EQ(VideoFrameBuffer::Type::kNative,
             fake_encoder_.GetLastInputPixelFormat());
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, DropsFramesWhenCongestionWindowPushbackSet) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);

   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0.5);
   // The congestion window pushback is set to 0.5, which will drop 1/2 of
   // frames. Adding two frames means that the first frame will be dropped and
   // the second frame will be sent to the encoder.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
   WaitForEncodedFrame(3);
   video_source_.IncomingCapturedFrame(CreateFrame(4, nullptr));
   video_source_.IncomingCapturedFrame(CreateFrame(5, nullptr));
   WaitForEncodedFrame(5);
   EXPECT_EQ(2u, stats_proxy_->GetStats().frames_dropped_by_congestion_window);
   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        ConfigureEncoderTriggersOnEncoderConfigurationChanged) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   EXPECT_EQ(0, sink_.number_of_reconfigurations());

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);
   // The encoder will have been configured once when the first frame is
   // received.
   EXPECT_EQ(1, sink_.number_of_reconfigurations());

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.min_transmit_bitrate_bps = 9999;
   video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                           kMaxPayloadLength);

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   EXPECT_EQ(2, sink_.number_of_reconfigurations());
   EXPECT_EQ(9999, sink_.last_min_transmit_bitrate());

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, FrameResolutionChangeReconfigureEncoder) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);
   // The encoder will have been configured once.
   EXPECT_EQ(1, sink_.number_of_reconfigurations());
   EXPECT_EQ(codec_width_, fake_encoder_.config().width);
   EXPECT_EQ(codec_height_, fake_encoder_.config().height);

   codec_width_ *= 2;
   codec_height_ *= 2;
   // Capture a frame with a higher resolution and wait for it to synchronize
   // with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   EXPECT_EQ(codec_width_, fake_encoder_.config().width);
   EXPECT_EQ(codec_height_, fake_encoder_.config().height);
   EXPECT_EQ(2, sink_.number_of_reconfigurations());

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderInstanceDestroyedBeforeAnotherInstanceCreated) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   // Changing the max payload data length recreates encoder.
   video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                           kMaxPayloadLength / 2);

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   EXPECT_EQ(1, encoder_factory_.GetMaxNumberOfSimultaneousEncoderInstances());

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, BitrateLimitsChangeReconfigureRateAllocator) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.max_bitrate_bps = kTargetBitrate.bps();
   video_stream_encoder_->SetStartBitrate(kStartBitrate.bps());
   video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
                                           kMaxPayloadLength);

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);
   // The encoder will have been configured once when the first frame is
   // received.
   EXPECT_EQ(1, sink_.number_of_reconfigurations());
   EXPECT_EQ(kTargetBitrate.bps(),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
   EXPECT_EQ(kStartBitrate.bps(),
             bitrate_allocator_factory_.codec_config().startBitrate * 1000);

   test::FillEncoderConfiguration(kVideoCodecVP8, 1,
                                  &video_encoder_config);  //???
   video_encoder_config.max_bitrate_bps = kTargetBitrate.bps() * 2;
   video_stream_encoder_->SetStartBitrate(kStartBitrate.bps() * 2);
   video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                           kMaxPayloadLength);

   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   EXPECT_EQ(2, sink_.number_of_reconfigurations());
   // Bitrate limits have changed - rate allocator should be reconfigured,
   // encoder should not be reconfigured.
   EXPECT_EQ(kTargetBitrate.bps() * 2,
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
   EXPECT_EQ(kStartBitrate.bps() * 2,
             bitrate_allocator_factory_.codec_config().startBitrate * 1000);
   EXPECT_EQ(1, fake_encoder_.GetNumInitializations());

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        IntersectionOfEncoderAndAppBitrateLimitsUsedWhenBothProvided) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   const uint32_t kMinEncBitrateKbps = 100;
   const uint32_t kMaxEncBitrateKbps = 1000;
   const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits(
       /*frame_size_pixels=*/codec_width_ * codec_height_,
       /*min_start_bitrate_bps=*/0,
       /*min_bitrate_bps=*/kMinEncBitrateKbps * 1000,
       /*max_bitrate_bps=*/kMaxEncBitrateKbps * 1000);
   fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits});

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.max_bitrate_bps = (kMaxEncBitrateKbps + 1) * 1000;
   video_encoder_config.simulcast_layers[0].min_bitrate_bps =
       (kMinEncBitrateKbps + 1) * 1000;
   video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
                                           kMaxPayloadLength);

   // When both encoder and app provide bitrate limits, the intersection of
   // provided sets should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);
   EXPECT_EQ(kMaxEncBitrateKbps,
             bitrate_allocator_factory_.codec_config().maxBitrate);
   EXPECT_EQ(kMinEncBitrateKbps + 1,
             bitrate_allocator_factory_.codec_config().minBitrate);

   video_encoder_config.max_bitrate_bps = (kMaxEncBitrateKbps - 1) * 1000;
   video_encoder_config.simulcast_layers[0].min_bitrate_bps =
       (kMinEncBitrateKbps - 1) * 1000;
   video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
                                           kMaxPayloadLength);
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
   WaitForEncodedFrame(2);
   EXPECT_EQ(kMaxEncBitrateKbps - 1,
             bitrate_allocator_factory_.codec_config().maxBitrate);
   EXPECT_EQ(kMinEncBitrateKbps,
             bitrate_allocator_factory_.codec_config().minBitrate);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderAndAppLimitsDontIntersectEncoderLimitsIgnored) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   const uint32_t kMinAppBitrateKbps = 100;
   const uint32_t kMaxAppBitrateKbps = 200;
   const uint32_t kMinEncBitrateKbps = kMaxAppBitrateKbps + 1;
   const uint32_t kMaxEncBitrateKbps = kMaxAppBitrateKbps * 2;
   const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits(
       /*frame_size_pixels=*/codec_width_ * codec_height_,
       /*min_start_bitrate_bps=*/0,
       /*min_bitrate_bps=*/kMinEncBitrateKbps * 1000,
       /*max_bitrate_bps=*/kMaxEncBitrateKbps * 1000);
   fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits});

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.max_bitrate_bps = kMaxAppBitrateKbps * 1000;
   video_encoder_config.simulcast_layers[0].min_bitrate_bps =
       kMinAppBitrateKbps * 1000;
   video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
                                           kMaxPayloadLength);

   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   WaitForEncodedFrame(1);
   EXPECT_EQ(kMaxAppBitrateKbps,
             bitrate_allocator_factory_.codec_config().maxBitrate);
   EXPECT_EQ(kMinAppBitrateKbps,
             bitrate_allocator_factory_.codec_config().minBitrate);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderRecommendedMaxAndMinBitratesUsedForGivenResolution) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_270p(
       480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000);
   const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_360p(
       640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000);
   fake_encoder_.SetResolutionBitrateLimits(
       {encoder_bitrate_limits_270p, encoder_bitrate_limits_360p});

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.max_bitrate_bps = 0;
   video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
                                           kMaxPayloadLength);

   // 270p. The bitrate limits recommended by encoder for 270p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270));
   WaitForEncodedFrame(1);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.min_bitrate_bps),
             bitrate_allocator_factory_.codec_config().minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);

   // 360p. The bitrate limits recommended by encoder for 360p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360));
   WaitForEncodedFrame(2);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.min_bitrate_bps),
             bitrate_allocator_factory_.codec_config().minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);

   // Resolution between 270p and 360p. The bitrate limits recommended by
   // encoder for 360p should be used.
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2));
   WaitForEncodedFrame(3);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.min_bitrate_bps),
             bitrate_allocator_factory_.codec_config().minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);

   // Resolution higher than 360p. The caps recommended by encoder should be
   // ignored.
   video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540));
   WaitForEncodedFrame(4);
   EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_270p.min_bitrate_bps),
             bitrate_allocator_factory_.codec_config().minBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_360p.min_bitrate_bps),
             bitrate_allocator_factory_.codec_config().minBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);

   // Resolution lower than 270p. The max bitrate limit recommended by encoder
   // for 270p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(5, 320, 180));
   WaitForEncodedFrame(5);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.min_bitrate_bps),
             bitrate_allocator_factory_.codec_config().minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps),
             bitrate_allocator_factory_.codec_config().maxBitrate * 1000);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, EncoderRecommendedMaxBitrateCapsTargetBitrate) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);

   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
   video_encoder_config.max_bitrate_bps = 0;
   video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
                                           kMaxPayloadLength);

   // Encode 720p frame to get the default encoder target bitrate.
   video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720));
   WaitForEncodedFrame(1);
   const uint32_t kDefaultTargetBitrateFor720pKbps =
       bitrate_allocator_factory_.codec_config()
           .simulcastStream[0]
           .targetBitrate;

   // Set the max recommended encoder bitrate to something lower than the default
   // target bitrate.
   const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits(
       1280 * 720, 10 * 1000, 10 * 1000,
       kDefaultTargetBitrateFor720pKbps / 2 * 1000);
   fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits});

   // Change resolution to trigger encoder reinitialization.
   video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360));
   WaitForEncodedFrame(2);
   video_source_.IncomingCapturedFrame(CreateFrame(3, 1280, 720));
   WaitForEncodedFrame(3);

   // Ensure the target bitrate is capped by the max bitrate.
   EXPECT_EQ(bitrate_allocator_factory_.codec_config().maxBitrate * 1000,
             static_cast<uint32_t>(encoder_bitrate_limits.max_bitrate_bps));
   EXPECT_EQ(bitrate_allocator_factory_.codec_config()
                     .simulcastStream[0]
                     .targetBitrate *
                 1000,
             static_cast<uint32_t>(encoder_bitrate_limits.max_bitrate_bps));

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderMaxAndMinBitratesUsedForTwoStreamsHighestActive) {
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p(
       480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000);
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p(
       640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000);
   fake_encoder_.SetResolutionBitrateLimits(
       {kEncoderLimits270p, kEncoderLimits360p});

   // Two streams, highest stream active.
   VideoEncoderConfig config;
   webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 2;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.max_bitrate_bps = 0;
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
   config.video_stream_factory =
       rtc::make_ref_counted<cricket::EncoderStreamFactory>(
           "VP8", /*max qp*/ 56, /*screencast*/ false,
           /*screenshare enabled*/ false, encoder_info);
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);

   // The encoder bitrate limits for 270p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(fake_encoder_.config().numberOfSimulcastStreams, kNumStreams);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // The encoder bitrate limits for 360p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // Resolution b/w 270p and 360p. The encoder limits for 360p should be used.
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // Resolution higher than 360p. Encoder limits should be ignored.
   video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // Resolution lower than 270p. The encoder limits for 270p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(5, 320, 180));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        DefaultEncoderMaxAndMinBitratesUsedForTwoStreamsHighestActive) {
   // Two streams, highest stream active.
   VideoEncoderConfig config;
   webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 2;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.max_bitrate_bps = 0;
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
   config.video_stream_factory =
       rtc::make_ref_counted<cricket::EncoderStreamFactory>(
           "VP8", /*max qp*/ 56, /*screencast*/ false,
           /*screenshare enabled*/ false, encoder_info);
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);

   // Default bitrate limits for 270p should be used.
   const absl::optional<VideoEncoder::ResolutionBitrateLimits>
       kDefaultLimits270p =
           EncoderInfoSettings::GetDefaultSinglecastBitrateLimitsForResolution(
               kVideoCodecVP8, 480 * 270);
   video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(fake_encoder_.config().numberOfSimulcastStreams, kNumStreams);
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits270p->min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits270p->max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // Default bitrate limits for 360p should be used.
   const absl::optional<VideoEncoder::ResolutionBitrateLimits>
       kDefaultLimits360p =
           EncoderInfoSettings::GetDefaultSinglecastBitrateLimitsForResolution(
               kVideoCodecVP8, 640 * 360);
   video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // Resolution b/w 270p and 360p. The default limits for 360p should be used.
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // Default bitrate limits for 540p should be used.
   const absl::optional<VideoEncoder::ResolutionBitrateLimits>
       kDefaultLimits540p =
           EncoderInfoSettings::GetDefaultSinglecastBitrateLimitsForResolution(
               kVideoCodecVP8, 960 * 540);
   video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits540p->min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits540p->max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderMaxAndMinBitratesUsedForThreeStreamsMiddleActive) {
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p(
       480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000);
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p(
       640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000);
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits720p(
       1280 * 720, 54 * 1000, 31 * 1000, 3456 * 1000);
   fake_encoder_.SetResolutionBitrateLimits(
       {kEncoderLimits270p, kEncoderLimits360p, kEncoderLimits720p});

   // Three streams, middle stream active.
   VideoEncoderConfig config;
   webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 3;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
   config.simulcast_layers[2].active = false;
   config.video_stream_factory =
       rtc::make_ref_counted<cricket::EncoderStreamFactory>(
           "VP8", /*max qp*/ 56, /*screencast*/ false,
           /*screenshare enabled*/ false, encoder_info);
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);

   // The encoder bitrate limits for 360p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(fake_encoder_.config().numberOfSimulcastStreams, kNumStreams);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // The encoder bitrate limits for 270p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(2, 960, 540));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderMaxAndMinBitratesNotUsedForThreeStreamsLowestActive) {
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p(
       480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000);
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p(
       640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000);
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits720p(
       1280 * 720, 54 * 1000, 31 * 1000, 3456 * 1000);
   fake_encoder_.SetResolutionBitrateLimits(
       {kEncoderLimits270p, kEncoderLimits360p, kEncoderLimits720p});

   // Three streams, lowest stream active.
   VideoEncoderConfig config;
   webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 3;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.simulcast_layers[0].active = true;
   config.simulcast_layers[1].active = false;
   config.simulcast_layers[2].active = false;
   config.video_stream_factory =
       rtc::make_ref_counted<cricket::EncoderStreamFactory>(
           "VP8", /*max qp*/ 56, /*screencast*/ false,
           /*screenshare enabled*/ false, encoder_info);
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);

   // Resolution on lowest stream lower than 270p. The encoder limits not applied
   // on lowest stream, limits for 270p should not be used
   video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(fake_encoder_.config().numberOfSimulcastStreams, kNumStreams);
   EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        EncoderMaxBitrateCappedByConfigForTwoStreamsHighestActive) {
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p(
       480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000);
   const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p(
       640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000);
   fake_encoder_.SetResolutionBitrateLimits(
       {kEncoderLimits270p, kEncoderLimits360p});
   const int kMaxBitrateBps = kEncoderLimits360p.max_bitrate_bps - 100 * 1000;

   // Two streams, highest stream active.
   VideoEncoderConfig config;
   webrtc::VideoEncoder::EncoderInfo encoder_info;
   const int kNumStreams = 2;
   test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
   config.simulcast_layers[0].active = false;
   config.simulcast_layers[1].active = true;
   config.simulcast_layers[1].max_bitrate_bps = kMaxBitrateBps;
   config.video_stream_factory =
       rtc::make_ref_counted<cricket::EncoderStreamFactory>(
           "VP8", /*max qp*/ 56, /*screencast*/ false,
           /*screenshare enabled*/ false, encoder_info);
   video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);

   // The encoder bitrate limits for 270p should be used.
   video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(fake_encoder_.config().numberOfSimulcastStreams, kNumStreams);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   // The max configured bitrate is less than the encoder limit for 360p.
   video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360));
   video_stream_encoder_->WaitUntilTaskQueueIsIdle();
   EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps),
             fake_encoder_.config().simulcastStream[1].minBitrate * 1000);
   EXPECT_EQ(static_cast<uint32_t>(kMaxBitrateBps),
             fake_encoder_.config().simulcastStream[1].maxBitrate * 1000);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, SwitchSourceDeregisterEncoderAsSink) {
   EXPECT_TRUE(video_source_.has_sinks());
   test::FrameForwarder new_video_source;
   video_stream_encoder_->SetSource(
       &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
   EXPECT_FALSE(video_source_.has_sinks());
   EXPECT_TRUE(new_video_source.has_sinks());

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, SinkWantsRotationApplied) {
   EXPECT_FALSE(video_source_.sink_wants().rotation_applied);
   video_stream_encoder_->SetSink(&sink_, true /*rotation_applied*/);
   EXPECT_TRUE(video_source_.sink_wants().rotation_applied);
   video_stream_encoder_->Stop();
 }

 class ResolutionAlignmentTest
     : public VideoStreamEncoderTest,
       public ::testing::WithParamInterface<
           ::testing::tuple<int, std::vector<double>>> {
  public:
   ResolutionAlignmentTest()
       : requested_alignment_(::testing::get<0>(GetParam())),
         scale_factors_(::testing::get<1>(GetParam())) {}

  protected:
   const uint32_t requested_alignment_;
   const std::vector<double> scale_factors_;
 };

 INSTANTIATE_TEST_SUITE_P(
     AlignmentAndScaleFactors,
     ResolutionAlignmentTest,
     ::testing::Combine(
         ::testing::Values(1, 2, 3, 4, 5, 6, 16, 22),  // requested_alignment_
         ::testing::Values(std::vector<double>{-1.0},  // scale_factors_
                           std::vector<double>{-1.0, -1.0},
                           std::vector<double>{-1.0, -1.0, -1.0},
                           std::vector<double>{4.0, 2.0, 1.0},
                           std::vector<double>{9999.0, -1.0, 1.0},
                           std::vector<double>{3.99, 2.01, 1.0},
                           std::vector<double>{4.9, 1.7, 1.25},
                           std::vector<double>{10.0, 4.0, 3.0},
                           std::vector<double>{1.75, 3.5},
                           std::vector<double>{1.5, 2.5},
                           std::vector<double>{1.3, 1.0})));

 TEST_P(ResolutionAlignmentTest, SinkWantsAlignmentApplied) {
   // Set requested resolution alignment.
   video_source_.set_adaptation_enabled(true);
   fake_encoder_.SetRequestedResolutionAlignment(requested_alignment_);
   fake_encoder_.SetApplyAlignmentToAllSimulcastLayers(true);

   // Fill config with the scaling factor by which to reduce encoding size.
   const int num_streams = scale_factors_.size();
   VideoEncoderConfig config;
   webrtc::VideoEncoder::EncoderInfo encoder_info;
   test::FillEncoderConfiguration(kVideoCodecVP8, num_streams, &config);
   for (int i = 0; i < num_streams; ++i) {
     config.simulcast_layers[i].scale_resolution_down_by = scale_factors_[i];
   }
   config.video_stream_factory =
       rtc::make_ref_counted<cricket::EncoderStreamFactory>(
           "VP8", /*max qp*/ 56, /*screencast*/ false,
           /*screenshare enabled*/ false, encoder_info);
   video_stream_encoder_->ConfigureEncoder(std::move(config), kMaxPayloadLength);

   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
       0, 0, 0);
   // Wait for all layers before triggering event.
   sink_.SetNumExpectedLayers(num_streams);

   // On the 1st frame, we should have initialized the encoder and
   // asked for its resolution requirements.
   int64_t timestamp_ms = kFrameIntervalMs;
   video_source_.IncomingCapturedFrame(CreateFrame(timestamp_ms, 1280, 720));
   WaitForEncodedFrame(timestamp_ms);
   EXPECT_EQ(1, fake_encoder_.GetNumInitializations());

   // On the 2nd frame, we should be receiving a correctly aligned resolution.
   // (It's up the to the encoder to potentially drop the previous frame,
   // to avoid coding back-to-back keyframes.)
   timestamp_ms += kFrameIntervalMs;
   video_source_.IncomingCapturedFrame(CreateFrame(timestamp_ms, 1280, 720));
   WaitForEncodedFrame(timestamp_ms);
   EXPECT_GE(fake_encoder_.GetNumInitializations(), 1);

   VideoCodec codec = fake_encoder_.config();
   EXPECT_EQ(codec.numberOfSimulcastStreams, num_streams);
   // Frame size should be a multiple of the requested alignment.
   for (int i = 0; i < codec.numberOfSimulcastStreams; ++i) {
     EXPECT_EQ(codec.simulcastStream[i].width % requested_alignment_, 0u);
     EXPECT_EQ(codec.simulcastStream[i].height % requested_alignment_, 0u);
     // Aspect ratio should match.
     EXPECT_EQ(codec.width * codec.simulcastStream[i].height,
               codec.height * codec.simulcastStream[i].width);
   }

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, TestCpuDowngrades_BalancedMode) {
   const int kFramerateFps = 30;
   const int kWidth = 1280;
   const int kHeight = 720;

   // We rely on the automatic resolution adaptation, but we handle framerate
   // adaptation manually by mocking the stats proxy.
   video_source_.set_adaptation_enabled(true);

   // Enable BALANCED preference, no initial limitation.
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   video_stream_encoder_->SetSource(&video_source_,
                                    webrtc::DegradationPreference::BALANCED);
   EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants());
   EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);

   // Adapt down as far as possible.
   rtc::VideoSinkWants last_wants;
   int64_t t = 1;
   int loop_count = 0;
   do {
     ++loop_count;
     last_wants = video_source_.sink_wants();

     // Simulate the framerate we've been asked to adapt to.
     const int fps = std::min(kFramerateFps, last_wants.max_framerate_fps);
     const int frame_interval_ms = rtc::kNumMillisecsPerSec / fps;
     VideoSendStream::Stats mock_stats = stats_proxy_->GetStats();
     mock_stats.input_frame_rate = fps;
     stats_proxy_->SetMockStats(mock_stats);

     video_source_.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight));
     sink_.WaitForEncodedFrame(t);
     t += frame_interval_ms;

     video_stream_encoder_->TriggerCpuOveruse();
     EXPECT_THAT(
         video_source_.sink_wants(),
         FpsInRangeForPixelsInBalanced(*video_source_.last_sent_width() *
                                       *video_source_.last_sent_height()));
   } while (video_source_.sink_wants().max_pixel_count <
                last_wants.max_pixel_count ||
            video_source_.sink_wants().max_framerate_fps <
                last_wants.max_framerate_fps);

   // Verify that we've adapted all the way down.
   stats_proxy_->ResetMockStats();
   EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_EQ(loop_count - 1,
             stats_proxy_->GetStats().number_of_cpu_adapt_changes);
   EXPECT_EQ(kMinPixelsPerFrame, *video_source_.last_sent_width() *
                                     *video_source_.last_sent_height());
   EXPECT_EQ(kMinBalancedFramerateFps,
             video_source_.sink_wants().max_framerate_fps);

   // Adapt back up the same number of times we adapted down.
   for (int i = 0; i < loop_count - 1; ++i) {
     last_wants = video_source_.sink_wants();

     // Simulate the framerate we've been asked to adapt to.
     const int fps = std::min(kFramerateFps, last_wants.max_framerate_fps);
     const int frame_interval_ms = rtc::kNumMillisecsPerSec / fps;
     VideoSendStream::Stats mock_stats = stats_proxy_->GetStats();
     mock_stats.input_frame_rate = fps;
     stats_proxy_->SetMockStats(mock_stats);

     video_source_.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight));
     sink_.WaitForEncodedFrame(t);
     t += frame_interval_ms;

     video_stream_encoder_->TriggerCpuUnderuse();
     EXPECT_THAT(
         video_source_.sink_wants(),
         FpsInRangeForPixelsInBalanced(*video_source_.last_sent_width() *
                                       *video_source_.last_sent_height()));
     EXPECT_TRUE(video_source_.sink_wants().max_pixel_count >
                     last_wants.max_pixel_count ||
                 video_source_.sink_wants().max_framerate_fps >
                     last_wants.max_framerate_fps);
   }

   EXPECT_THAT(video_source_.sink_wants(), FpsMaxResolutionMax());
   stats_proxy_->ResetMockStats();
   EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
   EXPECT_EQ((loop_count - 1) * 2,
             stats_proxy_->GetStats().number_of_cpu_adapt_changes);

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest,
        SinkWantsNotChangedByResourceLimitedBeforeDegradationPreferenceChange) {
   video_stream_encoder_->OnBitrateUpdated(kTargetBitrate, kTargetBitrate,
                                           kTargetBitrate, 0, 0, 0);
   EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants());

   const int kFrameWidth = 1280;
   const int kFrameHeight = 720;

   int64_t ntp_time = kFrameIntervalMs;

   // Force an input frame rate to be available, or the adaptation call won't
   // know what framerate to adapt form.
   const int kInputFps = 30;
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   stats.input_frame_rate = kInputFps;
   stats_proxy_->SetMockStats(stats);

   video_source_.set_adaptation_enabled(true);
   video_stream_encoder_->SetSource(
       &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
   EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants());
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;

   // Trigger CPU overuse.
   video_stream_encoder_->TriggerCpuOveruse();
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;

   EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   EXPECT_EQ(std::numeric_limits<int>::max(),
             video_source_.sink_wants().max_pixel_count);
   // Some framerate constraint should be set.
   int restricted_fps = video_source_.sink_wants().max_framerate_fps;
   EXPECT_LT(restricted_fps, kInputFps);
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += 100;

   video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated(
       &video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
   // Give the encoder queue time to process the change in degradation preference
   // by waiting for an encoded frame.
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;

   video_stream_encoder_->TriggerQualityLow();
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;

   // Some resolution constraint should be set.
   EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   EXPECT_LT(video_source_.sink_wants().max_pixel_count,
             kFrameWidth * kFrameHeight);
   EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, kInputFps);

   int pixel_count = video_source_.sink_wants().max_pixel_count;
   // Triggering a CPU underuse should not change the sink wants since it has
   // not been overused for resolution since we changed degradation preference.
   video_stream_encoder_->TriggerCpuUnderuse();
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;
   EXPECT_EQ(video_source_.sink_wants().max_pixel_count, pixel_count);
   EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, kInputFps);

   // Change the degradation preference back. CPU underuse should not adapt since
   // QP is most limited.
   video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated(
       &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += 100;
   // Resolution adaptations is gone after changing degradation preference.
   EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   EXPECT_EQ(std::numeric_limits<int>::max(),
             video_source_.sink_wants().max_pixel_count);
   // The fps adaptation from above is now back.
   EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, restricted_fps);

   // Trigger CPU underuse.
   video_stream_encoder_->TriggerCpuUnderuse();
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;
   EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, restricted_fps);

   // Trigger QP underuse, fps should return to normal.
   video_stream_encoder_->TriggerQualityHigh();
   video_source_.IncomingCapturedFrame(
       CreateFrame(ntp_time, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(ntp_time);
   ntp_time += kFrameIntervalMs;
   EXPECT_THAT(video_source_.sink_wants(), FpsMax());

   video_stream_encoder_->Stop();
 }

 TEST_F(VideoStreamEncoderTest, SinkWantsStoredByDegradationPreference) {
   video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
       kTargetBitrate, kTargetBitrate, kTargetBitrate, 0, 0, 0);
   EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants());

   const