Reland #2 of Issue 2434073003: Extract bitrate allocation ...

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 622 matching lines @@
     }
   };
 
   class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
    public:
     BitrateObserver()
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           time_to_reconfigure_(false, false),
           encoder_inits_(0),
-          last_set_bitrate_(0),
-          send_stream_(nullptr) {}
+          last_set_bitrate_kbps_(0),
+          send_stream_(nullptr),
+          frame_generator_(nullptr) {}
 
     int32_t InitEncode(const VideoCodec* config,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       ++encoder_inits_;
       if (encoder_inits_ == 1) {
         // First time initialization. Frame size is known.
         // |expected_bitrate| is affected by bandwidth estimation before the
         // first frame arrives to the encoder.
-        uint32_t expected_bitrate =
-            last_set_bitrate_ > 0 ? last_set_bitrate_ : kInitialBitrateKbps;
+        uint32_t expected_bitrate = last_set_bitrate_kbps_ > 0
+                                        ? last_set_bitrate_kbps_
+                                        : kInitialBitrateKbps;
         EXPECT_EQ(expected_bitrate, config->startBitrate)
             << "Encoder not initialized at expected bitrate.";
         EXPECT_EQ(kDefaultWidth, config->width);
         EXPECT_EQ(kDefaultHeight, config->height);
       } else if (encoder_inits_ == 2) {
         EXPECT_EQ(2 * kDefaultWidth, config->width);
         EXPECT_EQ(2 * kDefaultHeight, config->height);
-        EXPECT_GE(last_set_bitrate_, kReconfigureThresholdKbps);
-        EXPECT_NEAR(config->startBitrate,
-                    last_set_bitrate_,
+        EXPECT_GE(last_set_bitrate_kbps_, kReconfigureThresholdKbps);
+        EXPECT_NEAR(config->startBitrate, last_set_bitrate_kbps_,
                     kPermittedReconfiguredBitrateDiffKbps)
             << "Encoder reconfigured with bitrate too far away from last set.";
         observation_complete_.Set();
       }
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
-    int32_t SetRates(uint32_t new_target_bitrate_kbps,
-                     uint32_t framerate) override {
-      last_set_bitrate_ = new_target_bitrate_kbps;
+    int32_t SetRateAllocation(const BitrateAllocation& rate_allocation,
+                              uint32_t framerate) override {
+      last_set_bitrate_kbps_ = rate_allocation.get_sum_kbps();
       if (encoder_inits_ == 1 &&
-          new_target_bitrate_kbps > kReconfigureThresholdKbps) {
+          rate_allocation.get_sum_kbps() > kReconfigureThresholdKbps) {
         time_to_reconfigure_.Set();
       }
-      return FakeEncoder::SetRates(new_target_bitrate_kbps, framerate);
+      return FakeEncoder::SetRateAllocation(rate_allocation, framerate);
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config = EndToEndTest::GetSenderCallConfig();
       config.event_log = &event_log_;
       config.bitrate_config.start_bitrate_bps = kInitialBitrateKbps * 1000;
       return config;
     }
 
     void ModifyVideoConfigs(
@@ skipping 25 matching lines @@
       frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
       send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
       EXPECT_TRUE(Wait())
           << "Timed out while waiting for a couple of high bitrate estimates "
              "after reconfiguring the send stream.";
     }
 
    private:
     rtc::Event time_to_reconfigure_;
     int encoder_inits_;
-    uint32_t last_set_bitrate_;
+    uint32_t last_set_bitrate_kbps_;
     VideoSendStream* send_stream_;
     test::FrameGeneratorCapturer* frame_generator_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc