Add PacketRouter::SetMaxDesiredReceiveBitrate for application limited receive bandwidth

webrtc/modules/pacing/packet_router_unittest.cc

 /*
  *  Copyright (c) 2015 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 <list>
 #include <memory>
 
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/fakeclock.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::Field;
-using ::testing::NiceMock;
-using ::testing::Return;
-using ::testing::ReturnPointee;
-using ::testing::SaveArg;
-
 namespace webrtc {
 
 // TODO(eladalon): Restructure and/or replace the existing monolithic tests
 // (only some of the test are monolithic) according to the new
 // guidelines - small tests for one thing at a time.
 // (I'm not removing any tests during CL, so as to demonstrate no regressions.)
 
 namespace {
+
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::AtLeast;
+using ::testing::Field;
+using ::testing::Gt;
+using ::testing::Le;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::ReturnPointee;
+using ::testing::SaveArg;
+
 constexpr int kProbeMinProbes = 5;
 constexpr int kProbeMinBytes = 1000;
 
 class MockRtpRtcpWithRembTracking : public MockRtpRtcp {
  public:
   MockRtpRtcpWithRembTracking() {
     ON_CALL(*this, SetREMBStatus(_)).WillByDefault(SaveArg<0>(&remb_));
     ON_CALL(*this, REMB()).WillByDefault(ReturnPointee(&remb_));
   }
 
@@ skipping 506 matching lines @@
   bitrate_estimate = bitrate_estimate - 100;
   EXPECT_CALL(rtp, SetREMBData(bitrate_estimate, ssrcs)).Times(1);
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Call OnReceiveBitrateChanged again, this should not trigger a new callback.
   EXPECT_CALL(rtp, SetREMBData(_, _)).Times(0);
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
   packet_router.RemoveSendRtpModule(&rtp);
 }
 
+TEST(PacketRouterRembTest, SetMaxDesiredReceiveBitrateLimitsSetREMBData) {
+  rtc::ScopedFakeClock clock;
+  PacketRouter packet_router;
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  NiceMock<MockRtpRtcpWithRembTracking> remb_sender;
+  constexpr bool remb_candidate = true;
+  packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
+  ASSERT_TRUE(remb_sender.REMB());
+
+  const uint32_t cap_bitrate = 100000;
+  EXPECT_CALL(remb_sender, SetREMBData(Le(cap_bitrate), _)).Times(AtLeast(1));
+  EXPECT_CALL(remb_sender, SetREMBData(Gt(cap_bitrate), _)).Times(0);
+
+  const std::vector<uint32_t> ssrcs = {1234};
+  packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate);
+  packet_router.OnReceiveBitrateChanged(ssrcs, cap_bitrate + 5000);
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  packet_router.OnReceiveBitrateChanged(ssrcs, cap_bitrate - 5000);
+
+  // Test tear-down.
+  packet_router.RemoveSendRtpModule(&remb_sender);
+}
+
+TEST(PacketRouterRembTest,
+     SetMaxDesiredReceiveBitrateTriggersRembWhenMoreRestrictive) {
+  rtc::ScopedFakeClock clock;
+  PacketRouter packet_router;
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  NiceMock<MockRtpRtcpWithRembTracking> remb_sender;
+  constexpr bool remb_candidate = true;
+  packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
+  ASSERT_TRUE(remb_sender.REMB());
+
+  const uint32_t measured_bitrate_bps = 150000;
+  const uint32_t cap_bitrate_bps = measured_bitrate_bps - 5000;
+  const std::vector<uint32_t> ssrcs = {1234};
+  EXPECT_CALL(remb_sender, SetREMBData(measured_bitrate_bps, _));
+  packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
+
+  EXPECT_CALL(remb_sender, SetREMBData(cap_bitrate_bps, _));
+  packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
+
+  // Test tear-down.
+  packet_router.RemoveSendRtpModule(&remb_sender);
+}
+
+TEST(PacketRouterRembTest,
+     SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenAsRestrictive) {
+  rtc::ScopedFakeClock clock;
+  PacketRouter packet_router;
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  NiceMock<MockRtpRtcpWithRembTracking> remb_sender;
+  constexpr bool remb_candidate = true;
+  packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
+  ASSERT_TRUE(remb_sender.REMB());
+
+  const uint32_t measured_bitrate_bps = 150000;
+  const uint32_t cap_bitrate_bps = measured_bitrate_bps;
+  const std::vector<uint32_t> ssrcs = {1234};
+  EXPECT_CALL(remb_sender, SetREMBData(measured_bitrate_bps, _));
+  packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
+
+  EXPECT_CALL(remb_sender, SetREMBData(_, _)).Times(0);
+  packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
+
+  // Test tear-down.
+  packet_router.RemoveSendRtpModule(&remb_sender);
+}
+
+TEST(PacketRouterRembTest,
+     SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenLessRestrictive) {
+  rtc::ScopedFakeClock clock;
+  PacketRouter packet_router;
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  NiceMock<MockRtpRtcpWithRembTracking> remb_sender;
+  constexpr bool remb_candidate = true;
+  packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
+  ASSERT_TRUE(remb_sender.REMB());
+
+  const uint32_t measured_bitrate_bps = 150000;
+  const uint32_t cap_bitrate_bps = measured_bitrate_bps + 500;
+  const std::vector<uint32_t> ssrcs = {1234};
+  EXPECT_CALL(remb_sender, SetREMBData(measured_bitrate_bps, _));
+  packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
+
+  EXPECT_CALL(remb_sender, SetREMBData(_, _)).Times(0);
+  packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
+
+  // Test tear-down.
+  packet_router.RemoveSendRtpModule(&remb_sender);
+}
+
+TEST(PacketRouterRembTest,
+     SetMaxDesiredReceiveBitrateTriggersRembWhenNoRecentMeasure) {
+  rtc::ScopedFakeClock clock;
+  PacketRouter packet_router;
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  NiceMock<MockRtpRtcpWithRembTracking> remb_sender;
+  constexpr bool remb_candidate = true;
+  packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
+  ASSERT_TRUE(remb_sender.REMB());
+
+  const uint32_t measured_bitrate_bps = 150000;
+  const uint32_t cap_bitrate_bps = measured_bitrate_bps + 5000;
+  const std::vector<uint32_t> ssrcs = {1234};
+  EXPECT_CALL(remb_sender, SetREMBData(measured_bitrate_bps, _));
+  packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+
+  EXPECT_CALL(remb_sender, SetREMBData(cap_bitrate_bps, _));
+  packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
+
+  // Test tear-down.
+  packet_router.RemoveSendRtpModule(&remb_sender);
+}
+
+TEST(PacketRouterRembTest,
+     SetMaxDesiredReceiveBitrateTriggersRembWhenNoMeasures) {
+  rtc::ScopedFakeClock clock;
+  PacketRouter packet_router;
+  clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
+  NiceMock<MockRtpRtcpWithRembTracking> remb_sender;
+  constexpr bool remb_candidate = true;
+  packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
+  ASSERT_TRUE(remb_sender.REMB());
+
+  // Set cap.
+  EXPECT_CALL(remb_sender, SetREMBData(100000, _)).Times(1);
+  packet_router.SetMaxDesiredReceiveBitrate(100000);
+  // Increase cap.
+  EXPECT_CALL(remb_sender, SetREMBData(200000, _)).Times(1);
+  packet_router.SetMaxDesiredReceiveBitrate(200000);
+  // Decrease cap.
+  EXPECT_CALL(remb_sender, SetREMBData(150000, _)).Times(1);
+  packet_router.SetMaxDesiredReceiveBitrate(150000);
+
+  // Test tear-down.
+  packet_router.RemoveSendRtpModule(&remb_sender);
+}
+
 // Only register receiving modules and make sure we fallback to trigger a REMB
 // packet on this one.
 TEST(PacketRouterRembTest, NoSendingRtpModule) {
   rtc::ScopedFakeClock clock;
   NiceMock<MockRtpRtcp> rtp;
   PacketRouter packet_router;
 
   EXPECT_CALL(rtp, SetREMBStatus(true)).Times(1);
   packet_router.AddReceiveRtpModule(&rtp, true);
 
@@ skipping 182 matching lines @@
   EXPECT_CALL(receive_module, SetREMBData(bitrate_estimate, ssrcs)).Times(1);
 
   clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
   packet_router.RemoveReceiveRtpModule(&receive_module);
 }
 
 }  // namespace webrtc