Reland "Replace usage of old SetRates/SetRateAllocation methods"

This is a reland of 7ac0d5f348f0b956089c4ed65c46e65bac125508

Original change's description:
> Replace usage of old SetRates/SetRateAllocation methods
>
> This rather large CL replaces all relevant usage of the old
> VideoEncoder::SetRates()/SetRateAllocation() methods in WebRTC.
> API is unchanged to allow downstream projects to update without
> breakage.
>
> Bug: webrtc:10481
> Change-Id: Iab8f292ce6be6c3f5056a239d26361962b14bb38
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/131949
> Commit-Queue: Erik Språng <sprang@webrtc.org>
> Reviewed-by: Per Kjellander <perkj@webrtc.org>
> Reviewed-by: Niels Moller <nisse@webrtc.org>
> Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
> Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#27554}

TBR=brandtr@webrtc.org,sakal@webrtc.org,perkj@webrtc.org

Bug: webrtc:10481
Change-Id: I2978d5c527a18e885b7845c4e53a2424e8ad5b4b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/132551
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27593}
diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc
index ac59dfd..7c24b84 100644
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@@ -51,7 +51,6 @@
 FakeEncoder::FakeEncoder(Clock* clock)
     : clock_(clock),
       callback_(nullptr),
-      configured_input_framerate_(-1),
       max_target_bitrate_kbps_(-1),
       pending_keyframe_(true),
       counter_(0),
@@ -65,7 +64,7 @@
   RTC_DCHECK_GE(max_kbps, -1);  // max_kbps == -1 disables it.
   rtc::CritScope cs(&crit_sect_);
   max_target_bitrate_kbps_ = max_kbps;
-  SetRateAllocation(target_bitrate_, configured_input_framerate_);
+  SetRates(current_rate_settings_);
 }
 
 int32_t FakeEncoder::InitEncode(const VideoCodec* config,
@@ -73,8 +72,8 @@
                                 size_t max_payload_size) {
   rtc::CritScope cs(&crit_sect_);
   config_ = *config;
-  target_bitrate_.SetBitrate(0, 0, config_.startBitrate * 1000);
-  configured_input_framerate_ = config_.maxFramerate;
+  current_rate_settings_.bitrate.SetBitrate(0, 0, config_.startBitrate * 1000);
+  current_rate_settings_.framerate_fps = config_.maxFramerate;
   pending_keyframe_ = true;
   last_frame_info_ = FrameInfo();
   return 0;
@@ -86,8 +85,7 @@
   unsigned char num_simulcast_streams;
   SimulcastStream simulcast_streams[kMaxSimulcastStreams];
   EncodedImageCallback* callback;
-  VideoBitrateAllocation target_bitrate;
-  int framerate;
+  RateControlParameters rates;
   VideoCodecMode mode;
   bool keyframe;
   uint32_t counter;
@@ -99,12 +97,10 @@
       simulcast_streams[i] = config_.simulcastStream[i];
     }
     callback = callback_;
-    target_bitrate = target_bitrate_;
+    rates = current_rate_settings_;
     mode = config_.mode;
-    if (configured_input_framerate_ > 0) {
-      framerate = configured_input_framerate_;
-    } else {
-      framerate = max_framerate;
+    if (rates.framerate_fps <= 0.0) {
+      rates.framerate_fps = max_framerate;
     }
     keyframe = pending_keyframe_;
     pending_keyframe_ = false;
@@ -112,8 +108,8 @@
   }
 
   FrameInfo frame_info =
-      NextFrame(frame_types, keyframe, num_simulcast_streams, target_bitrate,
-                simulcast_streams, framerate);
+      NextFrame(frame_types, keyframe, num_simulcast_streams, rates.bitrate,
+                simulcast_streams, static_cast<int>(rates.framerate_fps + 0.5));
   for (uint8_t i = 0; i < frame_info.layers.size(); ++i) {
     constexpr int kMinPayLoadLength = 14;
     if (frame_info.layers[i].size < kMinPayLoadLength) {
@@ -237,12 +233,10 @@
   return 0;
 }
 
-int32_t FakeEncoder::SetRateAllocation(
-    const VideoBitrateAllocation& rate_allocation,
-    uint32_t framerate) {
+void FakeEncoder::SetRates(const RateControlParameters& parameters) {
   rtc::CritScope cs(&crit_sect_);
-  target_bitrate_ = rate_allocation;
-  int allocated_bitrate_kbps = target_bitrate_.get_sum_kbps();
+  current_rate_settings_ = parameters;
+  int allocated_bitrate_kbps = parameters.bitrate.get_sum_kbps();
 
   // Scale bitrate allocation to not exceed the given max target bitrate.
   if (max_target_bitrate_kbps_ > 0 &&
@@ -251,20 +245,19 @@
          ++spatial_idx) {
       for (uint8_t temporal_idx = 0; temporal_idx < kMaxTemporalStreams;
            ++temporal_idx) {
-        if (target_bitrate_.HasBitrate(spatial_idx, temporal_idx)) {
-          uint32_t bitrate =
-              target_bitrate_.GetBitrate(spatial_idx, temporal_idx);
+        if (current_rate_settings_.bitrate.HasBitrate(spatial_idx,
+                                                      temporal_idx)) {
+          uint32_t bitrate = current_rate_settings_.bitrate.GetBitrate(
+              spatial_idx, temporal_idx);
           bitrate = static_cast<uint32_t>(
               (bitrate * int64_t{max_target_bitrate_kbps_}) /
               allocated_bitrate_kbps);
-          target_bitrate_.SetBitrate(spatial_idx, temporal_idx, bitrate);
+          current_rate_settings_.bitrate.SetBitrate(spatial_idx, temporal_idx,
+                                                    bitrate);
         }
       }
     }
   }
-
-  configured_input_framerate_ = framerate;
-  return 0;
 }
 
 const char* FakeEncoder::kImplementationName = "fake_encoder";
@@ -276,7 +269,7 @@
 
 int FakeEncoder::GetConfiguredInputFramerate() const {
   rtc::CritScope cs(&crit_sect_);
-  return configured_input_framerate_;
+  return static_cast<int>(current_rate_settings_.framerate_fps + 0.5);
 }
 
 FakeH264Encoder::FakeH264Encoder(Clock* clock)