Revert of Add framerate to VideoSinkWants and ability to signal on overuse

webrtc/call/call_perf_tests.cc

Index: webrtc/call/call_perf_tests.cc
diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc
index bc84097699cb385e25a9bff92236107fd9b39e02..bd5ab0ff253a63d319a02d336432ac54bb53185c 100644
--- a/webrtc/call/call_perf_tests.cc
+++ b/webrtc/call/call_perf_tests.cc
@@ -473,16 +473,13 @@
 }
 
 TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
-  // Set fake encoder delay to 150% (3/2) of time limit when simulating overuse.
-  const int kOveruseFrameIntervalMs = (3 * 1000) / (2 * kDefaultFramerate);
-
   class LoadObserver : public test::SendTest,
                        public test::FrameGeneratorCapturer::SinkWantsObserver {
    public:
     LoadObserver()
         : SendTest(kLongTimeoutMs),
-          test_phase_(TestPhase::kStart),
-          encoder_(Clock::GetRealTimeClock(), kOveruseFrameIntervalMs) {}
+          expect_lower_resolution_wants_(true),
+          encoder_(Clock::GetRealTimeClock(), 60 /* delay_ms */) {}
 
     void OnFrameGeneratorCapturerCreated(
         test::FrameGeneratorCapturer* frame_generator_capturer) override {
@@ -493,44 +490,24 @@
 
     // OnSinkWantsChanged is called when FrameGeneratorCapturer::AddOrUpdateSink
     // is called.
-    // TODO(sprang): Add integration test for maintain-framerate mode?
     void OnSinkWantsChanged(rtc::VideoSinkInterface<VideoFrame>* sink,
                             const rtc::VideoSinkWants& wants) override {
       // First expect CPU overuse. Then expect CPU underuse when the encoder
       // delay has been decreased.
-      switch (test_phase_) {
-        case TestPhase::kStart:
-          if (wants.max_pixel_count < std::numeric_limits<int>::max()) {
-            // On adapting down, ViEEncoder::VideoSourceProxy will set only the
-            // max pixel count, leaving the target unset.
-            test_phase_ = TestPhase::kAdaptedDown;
-            encoder_.SetDelay(2);
-          } else {
-            ADD_FAILURE() << "Got unexpected adaptation request, max res = "
-                          << wants.max_pixel_count << ", target res = "
-                          << wants.target_pixel_count.value_or(-1)
-                          << ", max fps = " << wants.max_framerate_fps;
-          }
-          break;
-        case TestPhase::kAdaptedDown:
-          // On adapting up, the adaptation counter will again be at zero, and
-          // so all constraints will be reset.
-          if (wants.max_pixel_count == std::numeric_limits<int>::max() &&
-              !wants.target_pixel_count) {
-            test_phase_ = TestPhase::kAdaptedUp;
-            observation_complete_.Set();
-          } else {
-            ADD_FAILURE() << "Got unexpected adaptation request, max res = "
-                          << wants.max_pixel_count << ", target res = "
-                          << wants.target_pixel_count.value_or(-1)
-                          << ", max fps = " << wants.max_framerate_fps;
-          }
-          break;
-        case TestPhase::kAdaptedUp:
-          ADD_FAILURE() << "Got unexpected adaptation request, max res = "
-                        << wants.max_pixel_count << ", target res = "
-                        << wants.target_pixel_count.value_or(-1)
-                        << ", max fps = " << wants.max_framerate_fps;
+      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.
+        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);
       }
     }
 
@@ -545,7 +522,7 @@
       EXPECT_TRUE(Wait()) << "Timed out before receiving an overuse callback.";
     }
 
-    enum class TestPhase { kStart, kAdaptedDown, kAdaptedUp } test_phase_;
+    bool expect_lower_resolution_wants_;
     test::DelayedEncoder encoder_;
   } test;