Add PeerConnectionInterface::UpdateCallBitrate.

webrtc/call/call_unittest.cc

Index: webrtc/call/call_unittest.cc
diff --git a/webrtc/call/call_unittest.cc b/webrtc/call/call_unittest.cc
index 06ee2005b1953dac90b724fe5f1f2e47f64610ca..8f0a340e72074d65601b562fd337f7164a445088 100644
--- a/webrtc/call/call_unittest.cc
+++ b/webrtc/call/call_unittest.cc
@@ -320,14 +320,16 @@ TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) {
 
 namespace {
 struct CallBitrateHelper {
-  CallBitrateHelper() : CallBitrateHelper(Call::Config(&event_log_)) {}
-
-  explicit CallBitrateHelper(const Call::Config& config)
-      : mock_cc_(Clock::GetRealTimeClock(), &event_log_, &packet_router_),
-        call_(Call::Create(
-            config,
-            rtc::MakeUnique<FakeRtpTransportControllerSend>(&packet_router_,
-                                                            &mock_cc_))) {}
+  CallBitrateHelper() : CallBitrateHelper(Call::Config::BitrateConfig()) {}
+
+  explicit CallBitrateHelper(const Call::Config::BitrateConfig& bitrate_config)
+      : mock_cc_(Clock::GetRealTimeClock(), &event_log_, &packet_router_) {
+    Call::Config config(&event_log_);
+    config.bitrate_config = bitrate_config;
+    call_.reset(
+        Call::Create(config, rtc::MakeUnique<FakeRtpTransportControllerSend>(
+                                 &packet_router_, &mock_cc_)));
+  }
 
   webrtc::Call* operator->() { return call_.get(); }
   testing::NiceMock<test::MockSendSideCongestionController>& mock_cc() {
@@ -364,7 +366,7 @@ TEST(CallBitrateTest, SetBitrateConfigWithDifferentMinCallsSetBweBitrates) {
   call->SetBitrateConfig(bitrate_config);
 
   bitrate_config.min_bitrate_bps = 11;
-  EXPECT_CALL(call.mock_cc(), SetBweBitrates(11, 20, 30));
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(11, -1, 30));
   call->SetBitrateConfig(bitrate_config);
 }
 
@@ -392,13 +394,12 @@ TEST(CallBitrateTest, SetBitrateConfigWithDifferentMaxCallsSetBweBitrates) {
   call->SetBitrateConfig(bitrate_config);
 
   bitrate_config.max_bitrate_bps = 31;
-  EXPECT_CALL(call.mock_cc(), SetBweBitrates(10, 20, 31));
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(10, -1, 31));
   call->SetBitrateConfig(bitrate_config);
 }
 
 TEST(CallBitrateTest, SetBitrateConfigWithSameConfigElidesSecondCall) {
   CallBitrateHelper call;
-
   Call::Config::BitrateConfig bitrate_config;
   bitrate_config.min_bitrate_bps = 1;
   bitrate_config.start_bitrate_bps = 2;
@@ -489,5 +490,224 @@ TEST(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) {
             rtp_state2.last_timestamp_time_ms);
   EXPECT_EQ(rtp_state1.media_has_been_sent, rtp_state2.media_has_been_sent);
 }
+TEST(CallBitrateTest, BiggerMaskMinUsed) {
+  CallBitrateHelper call;
+  Call::Config::BitrateConfigMask mask;
+  mask.min_bitrate_bps = rtc::Optional<int>(1234);
+
+  EXPECT_CALL(call.mock_cc(),
+              SetBweBitrates(*mask.min_bitrate_bps, testing::_, testing::_));
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, BiggerConfigMinUsed) {
+  CallBitrateHelper call;
+  Call::Config::BitrateConfigMask mask;
+  mask.min_bitrate_bps = rtc::Optional<int>(1000);
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, testing::_));
+  call->SetBitrateConfigMask(mask);
+
+  Call::Config::BitrateConfig config;
+  config.min_bitrate_bps = 1234;
+
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(1234, testing::_, testing::_));
+  call->SetBitrateConfig(config);
+}
+
+// The last call to set start should be used.
+TEST(CallBitrateTest, LatestStartMaskPreferred) {
+  CallBitrateHelper call;
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1300);
+
+  EXPECT_CALL(call.mock_cc(),
+              SetBweBitrates(testing::_, *mask.start_bitrate_bps, testing::_));
+  call->SetBitrateConfigMask(mask);
+
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.start_bitrate_bps = 1200;
+
+  EXPECT_CALL(
+      call.mock_cc(),
+      SetBweBitrates(testing::_, bitrate_config.start_bitrate_bps, testing::_));
+  call->SetBitrateConfig(bitrate_config);
+}
+
+TEST(CallBitrateTest, SmallerMaskMaxUsed) {
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 2000;
+  CallBitrateHelper call(bitrate_config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps =
+      rtc::Optional<int>(bitrate_config.start_bitrate_bps + 1000);
+
+  EXPECT_CALL(call.mock_cc(),
+              SetBweBitrates(testing::_, testing::_, *mask.max_bitrate_bps));
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, SmallerConfigMaxUsed) {
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 1000;
+  CallBitrateHelper call(bitrate_config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps =
+      rtc::Optional<int>(bitrate_config.start_bitrate_bps + 2000);
+
+  // Expect no calls because nothing changes
+  EXPECT_CALL(call.mock_cc(),
+              SetBweBitrates(testing::_, testing::_, testing::_))
+      .Times(0);
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, MaskStartLessThanConfigMinClamped) {
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 2000;
+  CallBitrateHelper call(bitrate_config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1000);
+
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(2000, 2000, testing::_));
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, MaskStartGreaterThanConfigMaxClamped) {
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.start_bitrate_bps = 2000;
+  CallBitrateHelper call(bitrate_config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps = rtc::Optional<int>(1000);
+
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, -1, 1000));
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, MaskMinGreaterThanConfigMaxClamped) {
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 2000;
+  CallBitrateHelper call(bitrate_config);
+
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps = rtc::Optional<int>(1000);
+
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, 1000));
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, SettingMaskStartForcesUpdate) {
+  CallBitrateHelper call;
+
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1000);
+
+  // SetBweBitrates should be called twice with the same params since
+  // start_bitrate_bps is set.
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, 1000, testing::_))
+      .Times(2);
+  call->SetBitrateConfigMask(mask);
+  call->SetBitrateConfigMask(mask);
+}
+
+TEST(CallBitrateTest, SetBitrateConfigWithNoChangesDoesNotCallSetBweBitrates) {
+  CallBitrateHelper call;
+
+  Call::Config::BitrateConfig config1;
+  config1.min_bitrate_bps = 0;
+  config1.start_bitrate_bps = 1000;
+  config1.max_bitrate_bps = -1;
+
+  Call::Config::BitrateConfig config2;
+  config2.min_bitrate_bps = 0;
+  config2.start_bitrate_bps = -1;
+  config2.max_bitrate_bps = -1;
+
+  // The second call should not call SetBweBitrates because it doesn't
+  // change any values.
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1));
+  call->SetBitrateConfig(config1);
+  call->SetBitrateConfig(config2);
+}
+
+// If SetBitrateConfig changes the max, but not the effective max,
+// SetBweBitrates shouldn't be called, to avoid unnecessary encoder
+// reconfigurations.
+TEST(CallBitrateTest, SetBweBitratesNotCalledWhenEffectiveMaxUnchanged) {
+  CallBitrateHelper call;
+
+  Call::Config::BitrateConfig config;
+  config.min_bitrate_bps = 0;
+  config.start_bitrate_bps = -1;
+  config.max_bitrate_bps = 2000;
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, testing::_, 2000));
+  call->SetBitrateConfig(config);
+
+  // Reduce effective max to 1000 with the mask.
+  Call::Config::BitrateConfigMask mask;
+  mask.max_bitrate_bps = rtc::Optional<int>(1000);
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, testing::_, 1000));
+  call->SetBitrateConfigMask(mask);
+
+  // This leaves the effective max unchanged, so SetBweBitrates shouldn't be
+  // called again.
+  config.max_bitrate_bps = 1000;
+  call->SetBitrateConfig(config);
+}
+
+// When the "start bitrate" mask is removed, SetBweBitrates shouldn't be called
+// again, since nothing's changing.
+TEST(CallBitrateTest, SetBweBitratesNotCalledWhenStartMaskRemoved) {
+  CallBitrateHelper call;
+
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1000);
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1));
+  call->SetBitrateConfigMask(mask);
+
+  mask.start_bitrate_bps.reset();
+  call->SetBitrateConfigMask(mask);
+}
+
+// Test that if SetBitrateConfig is called after SetBitrateConfigMask applies a
+// "start" value, the SetBitrateConfig call won't apply that start value a
+// second time.
+TEST(CallBitrateTest, SetBitrateConfigAfterSetBitrateConfigMaskWithStart) {
+  CallBitrateHelper call;
+
+  Call::Config::BitrateConfigMask mask;
+  mask.start_bitrate_bps = rtc::Optional<int>(1000);
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1));
+  call->SetBitrateConfigMask(mask);
+
+  Call::Config::BitrateConfig config;
+  config.min_bitrate_bps = 0;
+  config.start_bitrate_bps = -1;
+  config.max_bitrate_bps = 5000;
+  // The start value isn't changing, so SetBweBitrates should be called with
+  // -1.
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, -1, 5000));
+  call->SetBitrateConfig(config);
+}
+
+TEST(CallBitrateTest, SetBweBitratesNotCalledWhenClampedMinUnchanged) {
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.start_bitrate_bps = 500;
+  bitrate_config.max_bitrate_bps = 1000;
+  CallBitrateHelper call(bitrate_config);
+
+  // Set min to 2000; it is clamped to the max (1000).
+  Call::Config::BitrateConfigMask mask;
+  mask.min_bitrate_bps = rtc::Optional<int>(2000);
+  EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, -1, 1000));
+  call->SetBitrateConfigMask(mask);
+
+  // Set min to 3000; the clamped value stays the same so nothing happens.
+  mask.min_bitrate_bps = rtc::Optional<int>(3000);
+  call->SetBitrateConfigMask(mask);
+}
 
 }  // namespace webrtc