Add number of quality adapt changes to VideoSendStream stats.

webrtc/video/vie_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 113 matching lines @@
       stream.temporal_layer_thresholds_bps.resize(num_temporal_layers_ - 1);
     }
     return streams;
   }
   const size_t num_temporal_layers_;
 };
 
 class AdaptingFrameForwarder : public test::FrameForwarder {
  public:
   AdaptingFrameForwarder() : adaptation_enabled_(false) {}
-  virtual ~AdaptingFrameForwarder() {}
+  ~AdaptingFrameForwarder() override {}
 
   void set_adaptation_enabled(bool enabled) {
     rtc::CritScope cs(&crit_);
     adaptation_enabled_ = enabled;
   }
 
-  bool adaption_enabled() {
+  bool adaption_enabled() const {
     rtc::CritScope cs(&crit_);
     return adaptation_enabled_;
   }
 
   void IncomingCapturedFrame(const VideoFrame& video_frame) override {
     int cropped_width = 0;
     int cropped_height = 0;
     int out_width = 0;
     int out_height = 0;
     if (adaption_enabled()) {
@@ skipping 131 matching lines @@
     frame.set_timestamp_us(ntp_time_ms * 1000);
     return frame;
   }
 
   class TestEncoder : public test::FakeEncoder {
    public:
     TestEncoder()
         : FakeEncoder(Clock::GetRealTimeClock()),
           continue_encode_event_(false, false) {}
 
-    VideoCodec codec_config() {
+    VideoCodec codec_config() const {
       rtc::CritScope lock(&crit_sect_);
       return config_;
     }
 
     void BlockNextEncode() {
       rtc::CritScope lock(&local_crit_sect_);
       block_next_encode_ = true;
     }
 
     VideoEncoder::ScalingSettings GetScalingSettings() const override {
@@ skipping 120 matching lines @@
 
     bool WaitForFrame(int64_t timeout_ms) {
       return encoded_frame_event_.Wait(timeout_ms);
     }
 
     void SetExpectNoFrames() {
       rtc::CritScope lock(&crit_);
       expect_frames_ = false;
     }
 
-    int number_of_reconfigurations() {
+    int number_of_reconfigurations() const {
       rtc::CritScope lock(&crit_);
       return number_of_reconfigurations_;
     }
 
-    int last_min_transmit_bitrate() {
+    int last_min_transmit_bitrate() const {
       rtc::CritScope lock(&crit_);
       return min_transmit_bitrate_bps_;
     }
 
    private:
     Result OnEncodedImage(
         const EncodedImage& encoded_image,
         const CodecSpecificInfo* codec_specific_info,
         const RTPFragmentationHeader* fragmentation) override {
       rtc::CritScope lock(&crit_);
@@ skipping 417 matching lines @@
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
   EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
   EXPECT_EQ(std::numeric_limits<int>::max(),
             new_video_source.sink_wants().max_pixel_count);
   EXPECT_TRUE(new_video_source.sink_wants().max_framerate_fps);
 
   vie_encoder_->Stop();
 }
 
-TEST_F(ViEEncoderTest, StatsTracksAdaptationStats) {
+TEST_F(ViEEncoderTest, StatsTracksQualityAdaptationStats) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  int frame_width = 1280;
-  int frame_height = 720;
+  const int kWidth = 1280;
+  const int kHeight = 720;
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(1);
+  VideoSendStream::Stats stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.bw_limited_resolution);
+  EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
+
+  // Trigger adapt down.
+  vie_encoder_->TriggerQualityLow();
+  video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(2);
+
+  stats = stats_proxy_->GetStats();
+  EXPECT_TRUE(stats.bw_limited_resolution);
+  EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
+
+  // Trigger adapt up.
+  vie_encoder_->TriggerQualityHigh();
+  video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
+  sink_.WaitForEncodedFrame(3);
+
+  stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.bw_limited_resolution);
+  EXPECT_EQ(2, stats.number_of_quality_adapt_changes);
+  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+
+  vie_encoder_->Stop();
+}
+
+TEST_F(ViEEncoderTest, StatsTracksCpuAdaptationStats) {
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  const int kWidth = 1280;
+  const int kHeight = 720;
+
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   sink_.WaitForEncodedFrame(1);
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
 
   // Trigger CPU overuse.
   vie_encoder_->TriggerCpuOveruse();
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(2, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
   sink_.WaitForEncodedFrame(2);
 
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Trigger CPU normal use.
   vie_encoder_->TriggerCpuNormalUsage();
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(3, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
   sink_.WaitForEncodedFrame(3);
 
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
+  EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, SwitchingSourceKeepsCpuAdaptation) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  int frame_width = 1280;
-  int frame_height = 720;
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  const int kWidth = 1280;
+  const int kHeight = 720;
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   sink_.WaitForEncodedFrame(1);
-
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
 
+  // Trigger CPU overuse.
   vie_encoder_->TriggerCpuOveruse();
-
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(2, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
   sink_.WaitForEncodedFrame(2);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set new source with adaptation still enabled.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainFramerate);
 
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(3, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
   sink_.WaitForEncodedFrame(3);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set adaptation disabled.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kDegradationDisabled);
 
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(4, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
   sink_.WaitForEncodedFrame(4);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set adaptation back to enabled.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainFramerate);
 
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(5, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight));
   sink_.WaitForEncodedFrame(5);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
+  // Trigger CPU normal use.
   vie_encoder_->TriggerCpuNormalUsage();
-
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(6, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(6, kWidth, kHeight));
   sink_.WaitForEncodedFrame(6);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, SwitchingSourceKeepsQualityAdaptation) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  int frame_width = 1280;
-  int frame_height = 720;
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  const int kWidth = 1280;
+  const int kHeight = 720;
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   sink_.WaitForEncodedFrame(1);
-
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_FALSE(stats.bw_limited_resolution);
-  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+  EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
 
   // Set new source with adaptation still enabled.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(&new_video_source,
                           VideoSendStream::DegradationPreference::kBalanced);
 
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(2, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
   sink_.WaitForEncodedFrame(2);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_FALSE(stats.bw_limited_resolution);
-  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
+  EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
 
+  // Trigger adapt down.
   vie_encoder_->TriggerQualityLow();
-
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(3, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
   sink_.WaitForEncodedFrame(3);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_TRUE(stats.bw_limited_resolution);
+  EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
 
+  // Set new source with adaptation still enabled.
   vie_encoder_->SetSource(&new_video_source,
                           VideoSendStream::DegradationPreference::kBalanced);
 
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(4, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
   sink_.WaitForEncodedFrame(4);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_TRUE(stats.bw_limited_resolution);
+  EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
 
   // Set adaptation disabled.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
 
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(5, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight));
   sink_.WaitForEncodedFrame(5);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_FALSE(stats.bw_limited_resolution);
+  EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
+  EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, QualityAdaptationStatsAreResetWhenScalerIsDisabled) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   const int kWidth = 1280;
   const int kHeight = 720;
   video_source_.set_adaptation_enabled(true);
@@ skipping 30 matching lines @@
   EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
   EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
   EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStatsWhenSwitchingSource) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  int frame_width = 1280;
-  int frame_height = 720;
+  int kWidth = 1280;
+  int kHeight = 720;
   int sequence = 1;
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
 
   // Trigger CPU overuse again, should now adapt down.
   vie_encoder_->TriggerCpuOveruse();
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
 
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set new source with adaptation still enabled.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainFramerate);
 
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+      CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Set cpu adaptation by frame dropping.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+      CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
   stats = stats_proxy_->GetStats();
   // Not adapted at first.
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
 
   // Force an input frame rate to be available, or the adaptation call won't
   // know what framerate to adapt form.
   VideoSendStream::Stats mock_stats = stats_proxy_->GetStats();
   mock_stats.input_frame_rate = 30;
   stats_proxy_->SetMockStats(mock_stats);
   vie_encoder_->TriggerCpuOveruse();
   stats_proxy_->ResetMockStats();
 
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+      CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
 
   // Framerate now adapted.
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   // Disable CPU adaptation.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kDegradationDisabled);
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+      CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
 
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   // Try to trigger overuse. Should not succeed.
   stats_proxy_->SetMockStats(mock_stats);
   vie_encoder_->TriggerCpuOveruse();
   stats_proxy_->ResetMockStats();
 
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   // Switch back the source with resolution adaptation enabled.
   vie_encoder_->SetSource(
       &video_source_,
       VideoSendStream::DegradationPreference::kMaintainFramerate);
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
   stats = stats_proxy_->GetStats();
   EXPECT_TRUE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   // Trigger CPU normal usage.
   vie_encoder_->TriggerCpuNormalUsage();
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(3, stats.number_of_cpu_adapt_changes);
 
   // Back to the source with adaptation off, set it back to maintain-resolution.
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+      CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
   stats = stats_proxy_->GetStats();
   // Disabled, since we previously switched the source too disabled.
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(3, stats.number_of_cpu_adapt_changes);
 
   // Trigger CPU normal usage.
   vie_encoder_->TriggerCpuNormalUsage();
   new_video_source.IncomingCapturedFrame(
-      CreateFrame(sequence, frame_width, frame_height));
+      CreateFrame(sequence, kWidth, kHeight));
   sink_.WaitForEncodedFrame(sequence++);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(4, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, StatsTracksPreferredBitrate) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720));
+  const int kWidth = 1280;
+  const int kHeight = 720;
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   sink_.WaitForEncodedFrame(1);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_EQ(video_encoder_config_.max_bitrate_bps,
             stats.preferred_media_bitrate_bps);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, ScalingUpAndDownDoesNothingWithMaintainResolution) {
-  int frame_width = 1280;
-  int frame_height = 720;
+  const int kWidth = 1280;
+  const int kHeight = 720;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  // Expect no scaling to begin with
+  // Expect no scaling to begin with.
   EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
   EXPECT_EQ(std::numeric_limits<int>::max(),
             video_source_.sink_wants().max_pixel_count);
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   sink_.WaitForEncodedFrame(1);
 
-  // Trigger scale down
+  // Trigger scale down.
   vie_encoder_->TriggerQualityLow();
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(2, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
   sink_.WaitForEncodedFrame(2);
 
   // Expect a scale down.
   EXPECT_TRUE(video_source_.sink_wants().max_pixel_count);
-  EXPECT_LT(video_source_.sink_wants().max_pixel_count,
-            frame_width * frame_height);
+  EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
 
   // Set adaptation disabled.
   test::FrameForwarder new_video_source;
   vie_encoder_->SetSource(
       &new_video_source,
       VideoSendStream::DegradationPreference::kMaintainResolution);
 
-  // Trigger scale down
+  // Trigger scale down.
   vie_encoder_->TriggerQualityLow();
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(3, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
   sink_.WaitForEncodedFrame(3);
 
-  // Expect no scaling
+  // Expect no scaling.
   EXPECT_EQ(std::numeric_limits<int>::max(),
             new_video_source.sink_wants().max_pixel_count);
 
-  // Trigger scale up
+  // Trigger scale up.
   vie_encoder_->TriggerQualityHigh();
-  new_video_source.IncomingCapturedFrame(
-      CreateFrame(4, frame_width, frame_height));
+  new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
   sink_.WaitForEncodedFrame(4);
 
   // Expect nothing to change, still no scaling
   EXPECT_EQ(std::numeric_limits<int>::max(),
             new_video_source.sink_wants().max_pixel_count);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DoesNotScaleBelowSetLimit) {
   int frame_width = 1280;
   int frame_height = 720;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   for (size_t i = 1; i <= 10; i++) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
     sink_.WaitForEncodedFrame(i);
-    // Trigger scale down
+    // Trigger scale down.
     vie_encoder_->TriggerQualityLow();
     EXPECT_GE(video_source_.sink_wants().max_pixel_count, kMinPixelsPerFrame);
   }
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, UMACpuLimitedResolutionInPercent) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
-  int frame_width = 640;
-  int frame_height = 360;
+  const int kWidth = 640;
+  const int kHeight = 360;
 
   for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
-    video_source_.IncomingCapturedFrame(
-        CreateFrame(i, frame_width, frame_height));
+    video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
     sink_.WaitForEncodedFrame(i);
   }
 
   vie_encoder_->TriggerCpuOveruse();
   for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
-    video_source_.IncomingCapturedFrame(
-        CreateFrame(SendStatisticsProxy::kMinRequiredMetricsSamples + i,
-                    frame_width, frame_height));
+    video_source_.IncomingCapturedFrame(CreateFrame(
+        SendStatisticsProxy::kMinRequiredMetricsSamples + i, kWidth, kHeight));
     sink_.WaitForEncodedFrame(SendStatisticsProxy::kMinRequiredMetricsSamples +
                               i);
   }
 
   vie_encoder_->Stop();
   vie_encoder_.reset();
   stats_proxy_.reset();
 
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
@@ skipping 39 matching lines @@
   EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
       .Times(1);
   video_source_.IncomingCapturedFrame(CreateFrame(
       kStartTimeMs + kProcessIntervalMs, codec_width_, codec_height_));
   sink_.WaitForEncodedFrame(kStartTimeMs + kProcessIntervalMs);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DropsFramesAndScalesWhenBitrateIsTooLow) {
-  vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0);
-  int frame_width = 640;
-  int frame_height = 360;
+  const int kTooLowBitrateForFrameSizeBps = 10000;
+  vie_encoder_->OnBitrateUpdated(kTooLowBitrateForFrameSizeBps, 0, 0);
+  const int kWidth = 640;
+  const int kHeight = 360;
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
 
   // Expect to drop this frame, the wait should time out.
   sink_.ExpectDroppedFrame();
 
   // Expect the sink_wants to specify a scaled frame.
   EXPECT_LT(video_source_.sink_wants().max_pixel_count, 1000 * 1000);
 
   int last_pixel_count = video_source_.sink_wants().max_pixel_count;
 
-  // Next frame is scaled
+  // Next frame is scaled.
   video_source_.IncomingCapturedFrame(
-      CreateFrame(2, frame_width * 3 / 4, frame_height * 3 / 4));
+      CreateFrame(2, kWidth * 3 / 4, kHeight * 3 / 4));
 
   // Expect to drop this frame, the wait should time out.
   sink_.ExpectDroppedFrame();
 
   EXPECT_LT(video_source_.sink_wants().max_pixel_count, last_pixel_count);
 
   vie_encoder_->Stop();
 }
 
-TEST_F(ViEEncoderTest, NrOfDroppedFramesLimited) {
-  // 1kbps. This can never be achieved.
-  vie_encoder_->OnBitrateUpdated(1000, 0, 0);
-  int frame_width = 640;
-  int frame_height = 360;
+TEST_F(ViEEncoderTest, NrOfDroppedFramesLimitedWhenBitrateIsTooLow) {
+  const int kTooLowBitrateForFrameSizeBps = 10000;
+  vie_encoder_->OnBitrateUpdated(kTooLowBitrateForFrameSizeBps, 0, 0);
+  const int kWidth = 640;
+  const int kHeight = 360;
 
   // We expect the n initial frames to get dropped.
   int i;
   for (i = 1; i <= kMaxInitialFramedrop; ++i) {
-    video_source_.IncomingCapturedFrame(
-        CreateFrame(i, frame_width, frame_height));
+    video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
     sink_.ExpectDroppedFrame();
   }
   // The n+1th frame should not be dropped, even though it's size is too large.
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(i, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
   sink_.WaitForEncodedFrame(i);
 
   // Expect the sink_wants to specify a scaled frame.
-  EXPECT_LT(video_source_.sink_wants().max_pixel_count, 1000 * 1000);
+  EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, InitialFrameDropOffWithMaintainResolutionPreference) {
-  int frame_width = 640;
-  int frame_height = 360;
+  const int kWidth = 640;
+  const int kHeight = 360;
   vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0);
 
   // Set degradation preference.
   vie_encoder_->SetSource(
       &video_source_,
       VideoSendStream::DegradationPreference::kMaintainResolution);
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   // Frame should not be dropped, even if it's too large.
   sink_.WaitForEncodedFrame(1);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, InitialFrameDropOffWhenEncoderDisabledScaling) {
-  int frame_width = 640;
-  int frame_height = 360;
+  const int kWidth = 640;
+  const int kHeight = 360;
   fake_encoder_.SetQualityScaling(false);
   vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0);
   // Force quality scaler reconfiguration by resetting the source.
   vie_encoder_->SetSource(&video_source_,
                           VideoSendStream::DegradationPreference::kBalanced);
 
-  video_source_.IncomingCapturedFrame(
-      CreateFrame(1, frame_width, frame_height));
+  video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
   // Frame should not be dropped, even if it's too large.
   sink_.WaitForEncodedFrame(1);
 
   vie_encoder_->Stop();
   fake_encoder_.SetQualityScaling(true);
 }
 
 // TODO(sprang): Extend this with fps throttling and any "balanced" extensions.
 TEST_F(ViEEncoderTest, AdaptsResolutionOnOveruse) {
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   const int kFrameWidth = 1280;
   const int kFrameHeight = 720;
   // Enabled default VideoAdapter downscaling. First step is 3/4, not 3/5 as
   // requested by ViEEncoder::VideoSourceProxy::RequestResolutionLowerThan().
   video_source_.set_adaptation_enabled(true);
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
 
   // Trigger CPU overuse, downscale by 3/4.
   vie_encoder_->TriggerCpuOveruse();
   video_source_.IncomingCapturedFrame(
       CreateFrame(2, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame((kFrameWidth * 3) / 4, (kFrameHeight * 3) / 4);
 
-  // Trigger CPU normal use, return to original resolution;
+  // Trigger CPU normal use, return to original resolution.
   vie_encoder_->TriggerCpuNormalUsage();
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, FailingInitEncodeDoesntCauseCrash) {
   fake_encoder_.ForceInitEncodeFailure(true);
@@ skipping 154 matching lines @@
   for (int i = 0; i < 10; ++i) {
     timestamp_ms += kMinFpsFrameInterval;
     fake_clock.AdvanceTimeMicros(kMinFpsFrameInterval * 1000);
     video_source_.IncomingCapturedFrame(
         CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
     sink_.WaitForEncodedFrame(timestamp_ms);
   }
   vie_encoder_->Stop();
 }
 }  // namespace webrtc