Update sink wants with ranges for both pixel count and frame rate.

webrtc/call/call_perf_tests.cc

 /*
  *  Copyright (c) 2013 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 453 matching lines @@
   const int kRunTimeMs = 20000;
   TestCaptureNtpTime(net_config, kThresholdMs, kStartTimeMs, kRunTimeMs);
 }
 #if defined(WEBRTC_ANDROID)
 // This test is disabled on android as it does not update
 // sinkWants below 320x180, the starting resolution for these
 // tests.
 #define ReceivesCpuOveruseAndUnderuse DISABLED_ReceivesCpuOveruseAndUnderuse
 #endif
 TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
+  static const int kFrameRateFps = 30;
+
   class LoadObserver : public test::SendTest,
                        public test::FrameGeneratorCapturer::SinkWantsObserver {
    public:
     LoadObserver()
         : SendTest(kLongTimeoutMs),
           expect_lower_resolution_wants_(true),
-          encoder_(Clock::GetRealTimeClock(), 35 /* delay_ms */) {}
+          encoder_(Clock::GetRealTimeClock(),
+                   2 * (1000 / kFrameRateFps) /* delay = 200% utilization */),
+          start_pixel_count_(0) {}
 
     void OnFrameGeneratorCapturerCreated(
         test::FrameGeneratorCapturer* frame_generator_capturer) override {
       frame_generator_capturer->SetSinkWantsObserver(this);
     }
 
     // OnSinkWantsChanged is called when FrameGeneratorCapturer::AddOrUpdateSink
     // is called.
     void OnSinkWantsChanged(rtc::VideoSinkInterface<VideoFrame>* sink,
                             const rtc::VideoSinkWants& wants) override {
+      RTC_DCHECK_GT(start_pixel_count_, 0);
       // First expect CPU overuse. Then expect CPU underuse when the encoder
       // delay has been decreased.
-      if (wants.target_pixel_count &&
-          *wants.target_pixel_count <
-              wants.max_pixel_count.value_or(std::numeric_limits<int>::max())) {
-        // On adapting up, ViEEncoder::VideoSourceProxy will set the target
-        // pixel count to a step up from the current and the max value to
-        // something higher than the target.
+      if (wants.pixel_count &&
+          wants.pixel_count->max ==
+              static_cast<uint32_t>(start_pixel_count_ - 1)) {
+        // On adapting down, ViEEncoder::VideoSourceProxy will set the max one
+        // step below the current resolution.
+        EXPECT_TRUE(expect_lower_resolution_wants_);
+        expect_lower_resolution_wants_ = false;
+        encoder_.SetDelay(2);  // Reduce fake high utilization.
+      } else if (wants.pixel_count &&
+                 wants.pixel_count->min ==
+                     static_cast<uint32_t>(start_pixel_count_ + 1)) {
+        // On adapting up, ViEEncoder::VideoSourceProxy will set the min pixel
+        // count one step higher than the current. Since this test doesn't
+        // include an adapter to actually scale down the input, this will still
+        // be the start resolution.
         EXPECT_FALSE(expect_lower_resolution_wants_);
         observation_complete_.Set();
-      } else if (wants.max_pixel_count) {
-        // On adapting down, ViEEncoder::VideoSourceProxy will set only the max
-        // pixel count, leaving the target unset.
-        EXPECT_TRUE(expect_lower_resolution_wants_);
-        expect_lower_resolution_wants_ = false;
-        encoder_.SetDelay(2);
       }
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = &encoder_;
     }
 
+    void ModifyVideoCaptureStartResolution(int* width,
+                                           int* heigt,
+                                           int* frame_rate) override {
+      RTC_DCHECK_EQ(0, start_pixel_count_);
+      start_pixel_count_ = *width * *heigt;
+      *frame_rate = kFrameRateFps;
+    }
+
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out before receiving an overuse callback.";
     }
 
     bool expect_lower_resolution_wants_;
     test::DelayedEncoder encoder_;
+    int start_pixel_count_;
   } test;
 
   RunBaseTest(&test);
 }
 
 void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
   static const int kMaxEncodeBitrateKbps = 30;
   static const int kMinTransmitBitrateBps = 150000;
   static const int kMinAcceptableTransmitBitrate = 130;
   static const int kMaxAcceptableTransmitBitrate = 170;
@@ skipping 202 matching lines @@
     uint32_t last_set_bitrate_kbps_;
     VideoSendStream* send_stream_;
     test::FrameGeneratorCapturer* frame_generator_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc