1 files changed, 150 insertions, 0 deletions
diff --git a/third_party/libwebrtc/test/peer_scenario/tests/bwe_ramp_up_test.cc b/third_party/libwebrtc/test/peer_scenario/tests/bwe_ramp_up_test.cc
index a7a17bbfd1..f8eaa47858 100644
--- a/third_party/libwebrtc/test/peer_scenario/tests/bwe_ramp_up_test.cc
+++ b/third_party/libwebrtc/test/peer_scenario/tests/bwe_ramp_up_test.cc
@@ -25,6 +25,9 @@ namespace webrtc {
 namespace test {
 
 using ::testing::SizeIs;
+using ::testing::Test;
+using ::testing::ValuesIn;
+using ::testing::WithParamInterface;
 
 rtc::scoped_refptr<const RTCStatsReport> GetStatsAndProcess(
     PeerScenario& s,
@@ -124,5 +127,152 @@ TEST(BweRampupTest, RampUpWithUndemuxableRtpPackets) {
   // ensure BWE has increased beyond noise levels.
   EXPECT_GT(final_bwe, initial_bwe + DataRate::KilobitsPerSec(345));
 }
+
+struct InitialProbeTestParams {
+  DataRate network_capacity;
+  DataRate expected_bwe_min;
+};
+class BweRampupWithInitialProbeTest
+    : public Test,
+      public WithParamInterface<InitialProbeTestParams> {};
+
+INSTANTIATE_TEST_SUITE_P(
+    BweRampupWithInitialProbeTest,
+    BweRampupWithInitialProbeTest,
+    ValuesIn<InitialProbeTestParams>(
+        {{
+             .network_capacity = DataRate::KilobitsPerSec(3000),
+             .expected_bwe_min = DataRate::KilobitsPerSec(2500),
+         },
+         {
+             .network_capacity = webrtc::DataRate::KilobitsPerSec(500),
+             .expected_bwe_min = webrtc::DataRate::KilobitsPerSec(400),
+         }}));
+
+// Test that caller and callee BWE rampup even if no media packets are sent.
+// - BandWidthEstimationSettings.allow_probe_without_media must be set.
+// - A Video RtpTransceiver with RTX support needs to be negotiated.
+TEST_P(BweRampupWithInitialProbeTest, BweRampUpBothDirectionsWithoutMedia) {
+  PeerScenario s(*::testing::UnitTest::GetInstance()->current_test_info());
+  InitialProbeTestParams test_params = GetParam();
+
+  PeerScenarioClient* caller = s.CreateClient({});
+  PeerScenarioClient* callee = s.CreateClient({});
+
+  auto video_result = caller->pc()->AddTransceiver(cricket::MEDIA_TYPE_VIDEO);
+  ASSERT_EQ(video_result.error().type(), RTCErrorType::NONE);
+
+  caller->pc()->ReconfigureBandwidthEstimation(
+      {.allow_probe_without_media = true});
+  callee->pc()->ReconfigureBandwidthEstimation(
+      {.allow_probe_without_media = true});
+
+  auto node_builder =
+      s.net()->NodeBuilder().capacity_kbps(test_params.network_capacity.kbps());
+  auto caller_node = node_builder.Build().node;
+  auto callee_node = node_builder.Build().node;
+  s.net()->CreateRoute(caller->endpoint(), {caller_node}, callee->endpoint());
+  s.net()->CreateRoute(callee->endpoint(), {callee_node}, caller->endpoint());
+
+  auto signaling =
+      s.ConnectSignaling(caller, callee, {caller_node}, {callee_node});
+  signaling.StartIceSignaling();
+
+  std::atomic<bool> offer_exchange_done(false);
+  signaling.NegotiateSdp(
+      [&]() {
+        // When remote description has been set, a transceiver is created.
+        // Set the diretion to sendrecv so that it can be used for BWE probing
+        // from callee -> caller.
+        ASSERT_THAT(callee->pc()->GetTransceivers(), SizeIs(1));
+        ASSERT_TRUE(
+            callee->pc()
+                ->GetTransceivers()[0]
+                ->SetDirectionWithError(RtpTransceiverDirection::kSendRecv)
+                .ok());
+      },
+      [&](const SessionDescriptionInterface& answer) {
+        offer_exchange_done = true;
+      });
+  // Wait for SDP negotiation.
+  s.WaitAndProcess(&offer_exchange_done);
+
+  // Test that 1s after offer/answer exchange finish, we have a BWE estimate,
+  // even though no video frames have been sent.
+  s.ProcessMessages(TimeDelta::Seconds(1));
+
+  auto callee_inbound_stats =
+      GetStatsAndProcess(s, callee)->GetStatsOfType<RTCInboundRtpStreamStats>();
+  ASSERT_THAT(callee_inbound_stats, SizeIs(1));
+  ASSERT_EQ(*callee_inbound_stats[0]->frames_received, 0u);
+  auto caller_inbound_stats =
+      GetStatsAndProcess(s, caller)->GetStatsOfType<RTCInboundRtpStreamStats>();
+  ASSERT_THAT(caller_inbound_stats, SizeIs(1));
+  ASSERT_EQ(*caller_inbound_stats[0]->frames_received, 0u);
+
+  DataRate caller_bwe = GetAvailableSendBitrate(GetStatsAndProcess(s, caller));
+  EXPECT_GT(caller_bwe.kbps(), test_params.expected_bwe_min.kbps());
+  EXPECT_LE(caller_bwe.kbps(), test_params.network_capacity.kbps());
+  DataRate callee_bwe = GetAvailableSendBitrate(GetStatsAndProcess(s, callee));
+  EXPECT_GT(callee_bwe.kbps(), test_params.expected_bwe_min.kbps());
+  EXPECT_LE(callee_bwe.kbps(), test_params.network_capacity.kbps());
+}
+
+// Test that we can reconfigure bandwidth estimation and send new BWE probes.
+// In this test, camera is stopped, and some times later, the app want to get a
+// new BWE estimate.
+TEST(BweRampupTest, CanReconfigureBweAfterStopingVideo) {
+  PeerScenario s(*::testing::UnitTest::GetInstance()->current_test_info());
+  PeerScenarioClient* caller = s.CreateClient({});
+  PeerScenarioClient* callee = s.CreateClient({});
+
+  auto node_builder = s.net()->NodeBuilder().capacity_kbps(1000);
+  auto caller_node = node_builder.Build().node;
+  auto callee_node = node_builder.Build().node;
+  s.net()->CreateRoute(caller->endpoint(), {caller_node}, callee->endpoint());
+  s.net()->CreateRoute(callee->endpoint(), {callee_node}, caller->endpoint());
+
+  PeerScenarioClient::VideoSendTrack track = caller->CreateVideo("VIDEO", {});
+
+  auto signaling =
+      s.ConnectSignaling(caller, callee, {caller_node}, {callee_node});
+
+  signaling.StartIceSignaling();
+
+  std::atomic<bool> offer_exchange_done(false);
+  signaling.NegotiateSdp([&](const SessionDescriptionInterface& answer) {
+    offer_exchange_done = true;
+  });
+  // Wait for SDP negotiation.
+  s.WaitAndProcess(&offer_exchange_done);
+
+  // Send a TCP messages to the receiver using the same downlink node.
+  // This is done just to force a lower BWE than the link capacity.
+  webrtc::TcpMessageRoute* tcp_route = s.net()->CreateTcpRoute(
+      s.net()->CreateRoute({caller_node}), s.net()->CreateRoute({callee_node}));
+  DataRate bwe_before_restart = DataRate::Zero();
+
+  std::atomic<bool> message_delivered(false);
+  tcp_route->SendMessage(
+      /*size=*/5'00'000,
+      /*on_received=*/[&]() { message_delivered = true; });
+  s.WaitAndProcess(&message_delivered);
+  bwe_before_restart = GetAvailableSendBitrate(GetStatsAndProcess(s, caller));
+
+  // Camera is stopped.
+  track.capturer->Stop();
+  s.ProcessMessages(TimeDelta::Seconds(2));
+
+  // Some time later, the app is interested in restarting BWE since we may want
+  // to resume video eventually.
+  caller->pc()->ReconfigureBandwidthEstimation(
+      {.allow_probe_without_media = true});
+  s.ProcessMessages(TimeDelta::Seconds(1));
+  DataRate bwe_after_restart =
+      GetAvailableSendBitrate(GetStatsAndProcess(s, caller));
+  EXPECT_GT(bwe_after_restart.kbps(), bwe_before_restart.kbps() + 300);
+  EXPECT_LT(bwe_after_restart.kbps(), 1000);
+}
+
 }  // namespace test
 }  // namespace webrtc