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

webrtc/media/base/videoadapter_unittest.cc

 /*
  *  Copyright (c) 2010 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 <limits.h>  // For INT_MAX
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/media/base/fakevideocapturer.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/media/base/videoadapter.h"
 
 namespace cricket {
+namespace {
+const int kDefaultFps = 30;
+}  // namespace
 
 class VideoAdapterTest : public testing::Test {
  public:
   virtual void SetUp() {
     capturer_.reset(new FakeVideoCapturer);
     capture_format_ = capturer_->GetSupportedFormats()->at(0);
-    capture_format_.interval = VideoFormat::FpsToInterval(30);
+    capture_format_.interval = VideoFormat::FpsToInterval(kDefaultFps);
 
     listener_.reset(new VideoCapturerListener(&adapter_));
     capturer_->AddOrUpdateSink(listener_.get(), rtc::VideoSinkWants());
   }
 
   virtual void TearDown() {
     // Explicitly disconnect the VideoCapturer before to avoid data races
     // (frames delivered to VideoCapturerListener while it's being destructed).
     capturer_->RemoveSink(listener_.get());
   }
@@ skipping 241 matching lines @@
     capturer_->CaptureFrame();
 
   // Verify no frame drop.
   EXPECT_EQ(0, listener_->GetStats().dropped_frames);
 }
 
 // After the first timestamp, add a big offset to the timestamps. Expect that
 // the adapter is conservative and resets to the new offset and does not drop
 // any frame.
 TEST_F(VideoAdapterTest, AdaptFramerateTimestampOffset) {
-  const int64_t capture_interval = VideoFormat::FpsToInterval(30);
+  const int64_t capture_interval = VideoFormat::FpsToInterval(kDefaultFps);
   adapter_.OnOutputFormatRequest(
       VideoFormat(640, 480, capture_interval, cricket::FOURCC_ANY));
 
   const int64_t first_timestamp = 0;
   adapter_.AdaptFrameResolution(640, 480, first_timestamp,
                                 &cropped_width_, &cropped_height_,
                                 &out_width_, &out_height_);
   EXPECT_GT(out_width_, 0);
   EXPECT_GT(out_height_, 0);
 
   const int64_t big_offset = -987654321LL * 1000;
   const int64_t second_timestamp = big_offset;
   adapter_.AdaptFrameResolution(640, 480, second_timestamp,
                                 &cropped_width_, &cropped_height_,
                                 &out_width_, &out_height_);
   EXPECT_GT(out_width_, 0);
   EXPECT_GT(out_height_, 0);
 
   const int64_t third_timestamp = big_offset + capture_interval;
   adapter_.AdaptFrameResolution(640, 480, third_timestamp,
                                 &cropped_width_, &cropped_height_,
                                 &out_width_, &out_height_);
   EXPECT_GT(out_width_, 0);
   EXPECT_GT(out_height_, 0);
 }
 
 // Request 30 fps and send 30 fps with jitter. Expect that no frame is dropped.
 TEST_F(VideoAdapterTest, AdaptFramerateTimestampJitter) {
-  const int64_t capture_interval = VideoFormat::FpsToInterval(30);
+  const int64_t capture_interval = VideoFormat::FpsToInterval(kDefaultFps);
   adapter_.OnOutputFormatRequest(
       VideoFormat(640, 480, capture_interval, cricket::FOURCC_ANY));
 
   adapter_.AdaptFrameResolution(640, 480, capture_interval * 0 / 10,
                                 &cropped_width_, &cropped_height_,
                                 &out_width_, &out_height_);
   EXPECT_GT(out_width_, 0);
   EXPECT_GT(out_height_, 0);
 
   adapter_.AdaptFrameResolution(640, 480, capture_interval * 10 / 10 - 1,
@@ skipping 44 matching lines @@
   request_format.interval *= 2;
   adapter_.OnOutputFormatRequest(request_format);
 
   for (int i = 0; i < 20; ++i)
     capturer_->CaptureFrame();
 
   // Verify frame drop after adaptation.
   EXPECT_GT(listener_->GetStats().dropped_frames, 0);
 }
 
+// Do not adapt the frame rate or the resolution. Expect no frame drop, no
+// cropping, and no resolution change.
+TEST_F(VideoAdapterTest, OnFramerateRequestMax) {
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
+                                        std::numeric_limits<int>::max(),
+                                        std::numeric_limits<int>::max());
+
+  EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
+  for (int i = 0; i < 10; ++i)
+    capturer_->CaptureFrame();
+
+  // Verify no frame drop and no resolution change.
+  VideoCapturerListener::Stats stats = listener_->GetStats();
+  EXPECT_GE(stats.captured_frames, 10);
+  EXPECT_EQ(0, stats.dropped_frames);
+  VerifyAdaptedResolution(stats, capture_format_.width, capture_format_.height,
+                          capture_format_.width, capture_format_.height);
+  EXPECT_TRUE(stats.last_adapt_was_no_op);
+}
+
+TEST_F(VideoAdapterTest, OnFramerateRequestZero) {
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
+                                        std::numeric_limits<int>::max(), 0);
+  EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
+  for (int i = 0; i < 10; ++i)
+    capturer_->CaptureFrame();
+
+  // Verify no crash and that frames aren't dropped.
+  VideoCapturerListener::Stats stats = listener_->GetStats();
+  EXPECT_GE(stats.captured_frames, 10);
+  EXPECT_EQ(10, stats.dropped_frames);
+}
+
+// Adapt the frame rate to be half of the capture rate at the beginning. Expect
+// the number of dropped frames to be half of the number the captured frames.
+TEST_F(VideoAdapterTest, OnFramerateRequestHalf) {
+  adapter_.OnResolutionFramerateRequest(
+      rtc::Optional<int>(), std::numeric_limits<int>::max(), kDefaultFps / 2);
+  EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
+  for (int i = 0; i < 10; ++i)
+    capturer_->CaptureFrame();
+
+  // Verify no crash and that frames aren't dropped.
+  VideoCapturerListener::Stats stats = listener_->GetStats();
+  EXPECT_GE(stats.captured_frames, 10);
+  EXPECT_EQ(5, stats.dropped_frames);
+  VerifyAdaptedResolution(stats, capture_format_.width, capture_format_.height,
+                          capture_format_.width, capture_format_.height);
+}
+
 // Set a very high output pixel resolution. Expect no cropping or resolution
 // change.
 TEST_F(VideoAdapterTest, AdaptFrameResolutionHighLimit) {
   VideoFormat output_format = capture_format_;
   output_format.width *= 10;
   output_format.height *= 10;
   adapter_.OnOutputFormatRequest(output_format);
   EXPECT_TRUE(adapter_.AdaptFrameResolution(
       capture_format_.width, capture_format_.height, 0,
       &cropped_width_, &cropped_height_,
@@ skipping 292 matching lines @@
 TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 
   // Adapt down one step.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(1280 * 720 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 1280 * 720 - 1,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(960, out_width_);
   EXPECT_EQ(540, out_height_);
 
   // Adapt down one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(960 * 540 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 960 * 540 - 1,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 
   // Adapt down one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 360 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
   // Adapt up one step.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360),
-                               rtc::Optional<int>(960 * 540));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(640 * 360),
+                                        960 * 540,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 
   // Adapt up one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(960 * 540),
-                               rtc::Optional<int>(1280 * 720));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(960 * 540),
+                                        1280 * 720,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(960, out_width_);
   EXPECT_EQ(540, out_height_);
 
   // Adapt up one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(1280 * 720),
-                               rtc::Optional<int>(1920 * 1080));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(1280 * 720),
+                                        1920 * 1080,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestOnResolutionRequestMaxZero) {
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 
-  adapter_.OnResolutionRequest(rtc::Optional<int>(), rtc::Optional<int>(0));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 0,
+                                        std::numeric_limits<int>::max());
   EXPECT_FALSE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                              &cropped_width_, &cropped_height_,
                                              &out_width_, &out_height_));
 }
 
 TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) {
   // Large step down.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 360 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
   // Large step up.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(1280 * 720),
-                               rtc::Optional<int>(1920 * 1080));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(1280 * 720),
+                                        1920 * 1080,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution) {
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 360 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
   VideoFormat new_format(640, 360, 0, FOURCC_I420);
   adapter_.OnOutputFormatRequest(new_format);
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(960 * 720));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 960 * 720,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestOnResolutionRequestReset) {
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 360 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
-  adapter_.OnResolutionRequest(rtc::Optional<int>(), rtc::Optional<int>());
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
+                                        std::numeric_limits<int>::max(),
+                                        std::numeric_limits<int>::max());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
   // Ask for 640x360 (16:9 aspect).
   adapter_.OnOutputFormatRequest(VideoFormat(640, 360, 0, FOURCC_I420));
   // Send 640x480 (4:3 aspect).
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   // Expect cropping to 16:9 format and no scaling.
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 
   // Adapt down one step.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 360 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
+                                        std::numeric_limits<int>::max());
   // Expect cropping to 16:9 format and 3/4 scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
   // Adapt down one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(480 * 270 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 480 * 270 - 1,
+                                        std::numeric_limits<int>::max());
   // Expect cropping to 16:9 format and 1/2 scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(320, out_width_);
   EXPECT_EQ(180, out_height_);
 
   // Adapt up one step.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(480 * 270),
-                               rtc::Optional<int>(640 * 360));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(480 * 270),
+                                        640 * 360,
+                                        std::numeric_limits<int>::max());
   // Expect cropping to 16:9 format and 3/4 scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(480, out_width_);
   EXPECT_EQ(270, out_height_);
 
   // Adapt up one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360),
-                               rtc::Optional<int>(960 * 540));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(640 * 360),
+                                        960 * 540,
+                                        std::numeric_limits<int>::max());
   // Expect cropping to 16:9 format and no scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 
   // Try to adapt up one step more.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(960 * 540),
-                               rtc::Optional<int>(1280 * 720));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(960 * 540),
+                                        1280 * 720,
+                                        std::numeric_limits<int>::max());
   // Expect cropping to 16:9 format and no scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestCroppingOddResolution) {
   // Ask for 640x360 (16:9 aspect), with 3/16 scaling.
   adapter_.OnOutputFormatRequest(
       VideoFormat(640, 360, 0, FOURCC_I420));
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 360 * 3 / 16 * 3 / 16));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
+                                        640 * 360 * 3 / 16 * 3 / 16,
+                                        std::numeric_limits<int>::max());
 
   // Send 640x480 (4:3 aspect).
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
 
   // Instead of getting the exact aspect ratio with cropped resolution 640x360,
   // the resolution should be adjusted to get a perfect scale factor instead.
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(368, cropped_height_);
   EXPECT_EQ(120, out_width_);
   EXPECT_EQ(69, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestAdaptToVerySmallResolution) {
   // Ask for 1920x1080 (16:9 aspect), with 1/16 scaling.
   const int w = 1920;
   const int h = 1080;
   adapter_.OnOutputFormatRequest(VideoFormat(w, h, 0, FOURCC_I420));
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(w * h * 1 / 16 * 1 / 16));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
+                                        w * h * 1 / 16 * 1 / 16,
+                                        std::numeric_limits<int>::max());
 
   // Send 1920x1080 (16:9 aspect).
   EXPECT_TRUE(adapter_.AdaptFrameResolution(
       w, h, 0, &cropped_width_, &cropped_height_, &out_width_, &out_height_));
 
   // Instead of getting the exact aspect ratio with cropped resolution 1920x1080
   // the resolution should be adjusted to get a perfect scale factor instead.
   EXPECT_EQ(1920, cropped_width_);
   EXPECT_EQ(1072, cropped_height_);
   EXPECT_EQ(120, out_width_);
   EXPECT_EQ(67, out_height_);
 
   // Adapt back up one step to 3/32.
-  adapter_.OnResolutionRequest(rtc::Optional<int>(w * h * 3 / 32 * 3 / 32),
-                               rtc::Optional<int>(w * h * 1 / 8 * 1 / 8));
+  adapter_.OnResolutionFramerateRequest(
+      rtc::Optional<int>(w * h * 3 / 32 * 3 / 32), w * h * 1 / 8 * 1 / 8,
+      std::numeric_limits<int>::max());
 
   // Send 1920x1080 (16:9 aspect).
   EXPECT_TRUE(adapter_.AdaptFrameResolution(
       w, h, 0, &cropped_width_, &cropped_height_, &out_width_, &out_height_));
 
   EXPECT_EQ(180, out_width_);
   EXPECT_EQ(99, out_height_);
 }
 
 TEST_F(VideoAdapterTest, AdaptFrameResolutionDropWithResolutionRequest) {
   VideoFormat output_format = capture_format_;
   output_format.width = 0;
   output_format.height = 0;
   adapter_.OnOutputFormatRequest(output_format);
   EXPECT_FALSE(adapter_.AdaptFrameResolution(
       capture_format_.width, capture_format_.height, 0,
       &cropped_width_, &cropped_height_,
       &out_width_, &out_height_));
 
-  adapter_.OnResolutionRequest(rtc::Optional<int>(960 * 540),
-                               rtc::Optional<int>());
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(960 * 540),
+                                        std::numeric_limits<int>::max(),
+                                        std::numeric_limits<int>::max());
 
   // Still expect all frames to be dropped
   EXPECT_FALSE(adapter_.AdaptFrameResolution(
       capture_format_.width, capture_format_.height, 0,
       &cropped_width_, &cropped_height_,
       &out_width_, &out_height_));
 
-  adapter_.OnResolutionRequest(rtc::Optional<int>(),
-                               rtc::Optional<int>(640 * 480 - 1));
+  adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 480 - 1,
+                                        std::numeric_limits<int>::max());
 
   // Still expect all frames to be dropped
   EXPECT_FALSE(adapter_.AdaptFrameResolution(
       capture_format_.width, capture_format_.height, 0,
       &cropped_width_, &cropped_height_,
       &out_width_, &out_height_));
 }
 
 // Test that we will adapt to max given a target pixel count close to max.
 TEST_F(VideoAdapterTest, TestAdaptToMax) {
   adapter_.OnOutputFormatRequest(VideoFormat(640, 360, 0, FOURCC_I420));
-  adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1) /* target */,
-                               rtc::Optional<int>());
+  adapter_.OnResolutionFramerateRequest(
+      rtc::Optional<int>(640 * 360 - 1) /* target */,
+      std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
 
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 360, 0, &cropped_width_,
                                             &cropped_height_, &out_width_,
                                             &out_height_));
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 }
-
 }  // namespace cricket