| /* |
| * Copyright (c) 2024 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 <atomic> |
| #include <map> |
| #include <string> |
| #include <string_view> |
| #include <vector> |
| |
| #include "absl/strings/str_cat.h" |
| #include "absl/strings/string_view.h" |
| #include "api/audio_options.h" |
| #include "api/jsep.h" |
| #include "api/peer_connection_interface.h" |
| #include "api/rtc_error.h" |
| #include "api/scoped_refptr.h" |
| #include "api/stats/rtc_stats_report.h" |
| #include "api/test/network_emulation/network_emulation_interfaces.h" |
| #include "api/test/network_emulation_manager.h" |
| #include "api/transport/ecn_marking.h" |
| #include "api/transport/stun.h" |
| #include "api/units/data_rate.h" |
| #include "api/units/time_delta.h" |
| #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| #include "modules/rtp_rtcp/source/rtcp_packet/congestion_control_feedback.h" |
| #include "modules/rtp_rtcp/source/rtcp_packet/rtpfb.h" |
| #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
| #include "modules/rtp_rtcp/source/rtp_util.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/network_constants.h" |
| #include "test/create_frame_generator_capturer.h" |
| #include "test/gmock.h" |
| #include "test/gtest.h" |
| #include "test/network/network_emulation.h" |
| #include "test/peer_scenario/bwe_integration_tests/stats_utilities.h" |
| #include "test/peer_scenario/peer_scenario.h" |
| #include "test/peer_scenario/peer_scenario_client.h" |
| #include "test/peer_scenario/signaling_route.h" |
| |
| namespace webrtc { |
| namespace { |
| |
| using test::GetAvailableSendBitrate; |
| using test::GetAverageRoundTripTime; |
| using test::GetPacketsReceived; |
| using test::GetPacketsReceivedWithCe; |
| using test::GetPacketsReceivedWithEct1; |
| using test::GetPacketsSentWithEct1; |
| using test::GetStatsAndProcess; |
| using test::PeerScenario; |
| using test::PeerScenarioClient; |
| using ::testing::ContainsRegex; |
| using ::testing::HasSubstr; |
| using ::testing::TestWithParam; |
| |
| // RTC event logs can be gathered from these tests. |
| // Add --peer_logs=true --peer_logs_root=/tmp/l4s/ to write logs to /tmp/l4s |
| |
| // This regexp matches both wildcard and non-wildcard ccfb lines. |
| constexpr std::string_view ccfb_regex = "a=rtcp-fb:[0-9*]* ack ccfb\r\n"; |
| |
| // Helper class used for counting RTCP feedback messages. |
| class RtcpFeedbackCounter { |
| public: |
| void Count(const EmulatedIpPacket& packet) { |
| if (!IsRtcpPacket(packet.data)) { |
| return; |
| } |
| rtcp::CommonHeader header; |
| ASSERT_TRUE(header.Parse(packet.data.cdata(), packet.data.size())); |
| if (header.type() != rtcp::Rtpfb::kPacketType) { |
| return; |
| } |
| if (header.fmt() == rtcp::CongestionControlFeedback::kFeedbackMessageType) { |
| ++congestion_control_feedback_; |
| rtcp::CongestionControlFeedback fb; |
| ASSERT_TRUE(fb.Parse(header)); |
| for (const rtcp::CongestionControlFeedback::PacketInfo& info : |
| fb.packets()) { |
| switch (info.ecn) { |
| case EcnMarking::kNotEct: |
| ++not_ect_; |
| break; |
| case EcnMarking::kEct0: |
| // Not used. |
| RTC_CHECK_NOTREACHED(); |
| break; |
| case EcnMarking::kEct1: |
| // ECN-Capable Transport |
| ++ect1_; |
| break; |
| case EcnMarking::kCe: |
| ++ce_; |
| } |
| } |
| } |
| if (header.fmt() == rtcp::TransportFeedback::kFeedbackMessageType) { |
| ++transport_sequence_number_feedback_; |
| } |
| } |
| |
| int FeedbackAccordingToRfc8888() const { |
| return congestion_control_feedback_; |
| } |
| int FeedbackAccordingToTransportCc() const { |
| return transport_sequence_number_feedback_; |
| } |
| int not_ect() const { return not_ect_; } |
| int ect1() const { return ect1_; } |
| int ce() const { return ce_; } |
| |
| private: |
| int congestion_control_feedback_ = 0; |
| int transport_sequence_number_feedback_ = 0; |
| int not_ect_ = 0; |
| int ect1_ = 0; |
| int ce_ = 0; |
| }; |
| |
| TEST(L4STest, NegotiateAndUseCcfbIfEnabled) { |
| PeerScenario s(*test_info_); |
| |
| PeerScenarioClient::Config config; |
| config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| config.disable_encryption = true; |
| PeerScenarioClient* caller = s.CreateClient(config); |
| PeerScenarioClient* callee = s.CreateClient(config); |
| |
| // Create network path from caller to callee. |
| auto send_node = s.net()->NodeBuilder().Build().node; |
| auto ret_node = s.net()->NodeBuilder().Build().node; |
| s.net()->CreateRoute(caller->endpoint(), {send_node}, callee->endpoint()); |
| s.net()->CreateRoute(callee->endpoint(), {ret_node}, caller->endpoint()); |
| |
| RtcpFeedbackCounter send_node_feedback_counter; |
| send_node->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| send_node_feedback_counter.Count(packet); |
| }); |
| RtcpFeedbackCounter ret_node_feedback_counter; |
| ret_node->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| ret_node_feedback_counter.Count(packet); |
| }); |
| |
| auto signaling = s.ConnectSignaling(caller, callee, {send_node}, {ret_node}); |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 15; |
| |
| caller->CreateAudio("AUDIO_1", AudioOptions()); |
| caller->CreateVideo("VIDEO_1", video_conf); |
| callee->CreateAudio("AUDIO_2", AudioOptions()); |
| callee->CreateVideo("VIDEO_2", video_conf); |
| |
| signaling.StartIceSignaling(); |
| |
| std::atomic<bool> offer_exchange_done(false); |
| signaling.NegotiateSdp( |
| [&](SessionDescriptionInterface* offer) { |
| std::string offer_str = absl::StrCat(*offer); |
| // Check that the offer contain both congestion control feedback |
| // according to RFC 8888, and transport-cc and the header extension |
| // http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01 |
| EXPECT_THAT(offer_str, ContainsRegex(ccfb_regex)); |
| EXPECT_THAT(offer_str, HasSubstr("transport-cc")); |
| EXPECT_THAT( |
| offer_str, |
| HasSubstr("http://www.ietf.org/id/" |
| "draft-holmer-rmcat-transport-wide-cc-extensions")); |
| }, |
| [&](const SessionDescriptionInterface& answer) { |
| std::string answer_str = absl::StrCat(answer); |
| EXPECT_THAT(answer_str, ContainsRegex(ccfb_regex)); |
| // Check that the answer does not contain transport-cc nor the |
| // header extension |
| // http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01 |
| EXPECT_THAT(answer_str, Not(HasSubstr("transport-cc"))); |
| EXPECT_THAT( |
| answer_str, |
| Not(HasSubstr(" http://www.ietf.org/id/" |
| "draft-holmer-rmcat-transport-wide-cc-extensions-"))); |
| offer_exchange_done = true; |
| }); |
| // Wait for SDP negotiation and the packet filter to be setup. |
| s.WaitAndProcess(&offer_exchange_done); |
| |
| s.ProcessMessages(TimeDelta::Seconds(2)); |
| EXPECT_GT(send_node_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_EQ(send_node_feedback_counter.FeedbackAccordingToTransportCc(), 0); |
| |
| EXPECT_GT(ret_node_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_EQ(ret_node_feedback_counter.FeedbackAccordingToTransportCc(), 0); |
| } |
| |
| TEST(L4STest, NoCcfbSentAfterRenegotiationAndCallerCachesLocalDescription) { |
| // The caller supports CCFB, but the callee does not. |
| // This test that the caller does not start sending CCFB after renegotiation |
| // even if the local description is cached. The caller's local description |
| // will contain CCFB since it was used in the initial offer. |
| PeerScenario s(*test_info_); |
| PeerScenarioClient::Config caller_config; |
| caller_config.disable_encryption = true; |
| caller_config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| PeerScenarioClient* caller = s.CreateClient(caller_config); |
| |
| PeerScenarioClient::Config callee_config; |
| callee_config.disable_encryption = true; |
| callee_config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Disabled"); |
| PeerScenarioClient* callee = s.CreateClient(callee_config); |
| |
| auto caller_to_callee = s.net() |
| ->NodeBuilder() |
| .capacity(DataRate::KilobitsPerSec(600)) |
| .Build() |
| .node; |
| auto callee_to_caller = s.net() |
| ->NodeBuilder() |
| .capacity(DataRate::KilobitsPerSec(600)) |
| .Build() |
| .node; |
| RtcpFeedbackCounter callee_feedback_counter; |
| caller_to_callee->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| callee_feedback_counter.Count(packet); |
| }); |
| RtcpFeedbackCounter caller_feedback_counter; |
| callee_to_caller->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| caller_feedback_counter.Count(packet); |
| }); |
| |
| s.net()->CreateRoute(caller->endpoint(), {caller_to_callee}, |
| callee->endpoint()); |
| s.net()->CreateRoute(callee->endpoint(), {callee_to_caller}, |
| caller->endpoint()); |
| |
| auto signaling = s.ConnectSignaling(caller, callee, {caller_to_callee}, |
| {callee_to_caller}); |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 30; |
| video_conf.generator.squares_video->width = 640; |
| video_conf.generator.squares_video->height = 360; |
| caller->CreateVideo("FROM_CALLER", video_conf); |
| callee->CreateVideo("FROM_CALLEE", video_conf); |
| |
| signaling.StartIceSignaling(); |
| std::atomic<bool> offer_exchange_done(false); |
| signaling.NegotiateSdp([&](const SessionDescriptionInterface& answer) { |
| offer_exchange_done = true; |
| }); |
| ASSERT_TRUE(s.WaitAndProcess(&offer_exchange_done)); |
| s.ProcessMessages(TimeDelta::Seconds(2)); |
| |
| EXPECT_EQ(caller_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_EQ(callee_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| int transport_cc_caller = |
| caller_feedback_counter.FeedbackAccordingToTransportCc(); |
| int transport_cc_callee = |
| callee_feedback_counter.FeedbackAccordingToTransportCc(); |
| EXPECT_GT(transport_cc_caller, 0); |
| EXPECT_GT(transport_cc_callee, 0); |
| |
| offer_exchange_done = false; |
| // Save the caller's local description and use it as answer to the next offer |
| // from callee. |
| std::string answer_str; |
| caller->pc()->local_description()->ToString(&answer_str); |
| ASSERT_FALSE(answer_str.empty()); |
| ASSERT_THAT(answer_str, ContainsRegex(ccfb_regex)); |
| |
| callee->CreateAndSetSdp( |
| [&](SessionDescriptionInterface* /*munge_offer*/) { |
| // Do not munge the offer. |
| }, |
| [&](std::string offer) { |
| // Callee does not support ccfb and does not have it in the offer. |
| ASSERT_THAT(offer, Not(ContainsRegex(ccfb_regex))); |
| caller->SetRemoteDescription( |
| offer, SdpType::kOffer, [&](RTCError error) { |
| ASSERT_TRUE(error.ok()); |
| caller->SetLocalDescription( |
| answer_str, SdpType::kAnswer, [&](RTCError error) { |
| ASSERT_TRUE(error.ok()); |
| callee->SetRemoteDescription(answer_str, SdpType::kAnswer, |
| [&](RTCError error) { |
| ASSERT_TRUE(error.ok()); |
| offer_exchange_done = true; |
| }); |
| }); |
| }); |
| }); |
| ASSERT_TRUE(s.WaitAndProcess(&offer_exchange_done)); |
| s.ProcessMessages(TimeDelta::Seconds(4)); |
| |
| EXPECT_EQ(caller_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_EQ(callee_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_GT(caller_feedback_counter.FeedbackAccordingToTransportCc(), |
| transport_cc_caller); |
| EXPECT_GT(callee_feedback_counter.FeedbackAccordingToTransportCc(), |
| transport_cc_callee); |
| } |
| |
| struct SupportRfc8888Params { |
| bool caller_supports_rfc8888 = false; |
| bool callee_supports_rfc8888 = false; |
| std::string test_suffix; |
| }; |
| |
| class FeedbackFormatTest : public TestWithParam<SupportRfc8888Params> {}; |
| |
| TEST_P(FeedbackFormatTest, AdaptToLinkCapacityWithoutEcn) { |
| const SupportRfc8888Params& params = GetParam(); |
| PeerScenario s(*testing::UnitTest::GetInstance()->current_test_info()); |
| |
| PeerScenarioClient::Config caller_config; |
| caller_config.disable_encryption = true; |
| caller_config.field_trials.Set( |
| "WebRTC-RFC8888CongestionControlFeedback", |
| params.caller_supports_rfc8888 ? "Enabled,offer:true" : "Disabled"); |
| PeerScenarioClient* caller = s.CreateClient(caller_config); |
| |
| PeerScenarioClient::Config callee_config; |
| callee_config.disable_encryption = true; |
| callee_config.field_trials.Set( |
| "WebRTC-RFC8888CongestionControlFeedback", |
| params.callee_supports_rfc8888 ? "Enabled" : "Disabled"); |
| PeerScenarioClient* callee = s.CreateClient(callee_config); |
| |
| auto caller_to_callee = s.net() |
| ->NodeBuilder() |
| .capacity(DataRate::KilobitsPerSec(250)) |
| .Build() |
| .node; |
| auto callee_to_caller = s.net() |
| ->NodeBuilder() |
| .capacity(DataRate::KilobitsPerSec(250)) |
| .Build() |
| .node; |
| RtcpFeedbackCounter callee_feedback_counter; |
| caller_to_callee->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| callee_feedback_counter.Count(packet); |
| }); |
| RtcpFeedbackCounter caller_feedback_counter; |
| callee_to_caller->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| caller_feedback_counter.Count(packet); |
| }); |
| |
| s.net()->CreateRoute(caller->endpoint(), {caller_to_callee}, |
| callee->endpoint()); |
| s.net()->CreateRoute(callee->endpoint(), {callee_to_caller}, |
| caller->endpoint()); |
| |
| auto signaling = s.ConnectSignaling(caller, callee, {caller_to_callee}, |
| {callee_to_caller}); |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 30; |
| video_conf.generator.squares_video->width = 320; |
| video_conf.generator.squares_video->height = 240; |
| caller->CreateVideo("FROM_CALLER", video_conf); |
| callee->CreateVideo("FROM_CALLEE", video_conf); |
| caller->CreateAudio("FROM_CALLER", AudioOptions()); |
| callee->CreateAudio("FROM_CALLEE", AudioOptions()); |
| |
| signaling.StartIceSignaling(); |
| std::atomic<bool> offer_exchange_done(false); |
| signaling.NegotiateSdp([&](const SessionDescriptionInterface& answer) { |
| offer_exchange_done = true; |
| }); |
| s.WaitAndProcess(&offer_exchange_done); |
| s.ProcessMessages(TimeDelta::Seconds(5)); |
| |
| DataRate caller_available_bwe = |
| GetAvailableSendBitrate(GetStatsAndProcess(s, caller)); |
| EXPECT_GT(caller_available_bwe.kbps(), 150); |
| EXPECT_LT(caller_available_bwe.kbps(), 300); |
| |
| DataRate callee_available_bwe = |
| GetAvailableSendBitrate(GetStatsAndProcess(s, callee)); |
| EXPECT_GT(callee_available_bwe.kbps(), 150); |
| EXPECT_LT(callee_available_bwe.kbps(), 300); |
| |
| EXPECT_LT(GetAverageRoundTripTime(GetStatsAndProcess(s, caller)), |
| TimeDelta::Millis(250)); |
| |
| if (params.caller_supports_rfc8888 && params.callee_supports_rfc8888) { |
| EXPECT_GT(caller_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_GT(callee_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_EQ(caller_feedback_counter.FeedbackAccordingToTransportCc(), 0); |
| EXPECT_EQ(callee_feedback_counter.FeedbackAccordingToTransportCc(), 0); |
| } else { |
| EXPECT_EQ(caller_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_EQ(callee_feedback_counter.FeedbackAccordingToRfc8888(), 0); |
| EXPECT_GT(caller_feedback_counter.FeedbackAccordingToTransportCc(), 0); |
| EXPECT_GT(callee_feedback_counter.FeedbackAccordingToTransportCc(), 0); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| L4STest, |
| FeedbackFormatTest, |
| testing::Values( |
| SupportRfc8888Params{.caller_supports_rfc8888 = true, |
| .test_suffix = "OnlyCallerSupportsRfc8888"}, |
| SupportRfc8888Params{.callee_supports_rfc8888 = true, |
| .test_suffix = "OnlyCalleeSupportsRfc8888"}, |
| SupportRfc8888Params{.caller_supports_rfc8888 = true, |
| .callee_supports_rfc8888 = true, |
| .test_suffix = "SupportsRfc8888"}), |
| [](const testing::TestParamInfo<SupportRfc8888Params>& info) { |
| return info.param.test_suffix; |
| }); |
| |
| TEST(L4STest, SendsEct1WithScream) { |
| PeerScenario s(*test_info_); |
| PeerScenarioClient::Config config; |
| config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| config.field_trials.Set("WebRTC-Bwe-ScreamV2", "Enabled"); |
| config.disable_encryption = true; |
| PeerScenarioClient* caller = s.CreateClient(config); |
| PeerScenarioClient* callee = s.CreateClient(config); |
| EmulatedNetworkNode* caller_to_callee = s.net()->NodeBuilder().Build().node; |
| EmulatedNetworkNode* callee_to_caller = s.net()->NodeBuilder().Build().node; |
| s.net()->CreateRoute(caller->endpoint(), {caller_to_callee}, |
| callee->endpoint()); |
| s.net()->CreateRoute(callee->endpoint(), {callee_to_caller}, |
| caller->endpoint()); |
| RtcpFeedbackCounter feedback_counter; |
| callee_to_caller->router()->SetWatcher( |
| [&](const EmulatedIpPacket& packet) { feedback_counter.Count(packet); }); |
| |
| test::SignalingRoute signaling = s.ConnectSignaling( |
| caller, callee, {caller_to_callee}, {callee_to_caller}); |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 15; |
| caller->CreateVideo("VIDEO_1", video_conf); |
| signaling.StartIceSignaling(); |
| std::atomic<bool> offer_exchange_done(false); |
| signaling.NegotiateSdp([&](const SessionDescriptionInterface& answer) { |
| offer_exchange_done = true; |
| }); |
| |
| s.WaitAndProcess(&offer_exchange_done); |
| s.ProcessMessages(TimeDelta::Seconds(3)); |
| EXPECT_EQ(GetPacketsSentWithEct1(GetStatsAndProcess(s, caller)), |
| feedback_counter.ect1()); |
| EXPECT_GT(feedback_counter.ect1(), 0); |
| EXPECT_EQ(feedback_counter.not_ect(), 0); |
| } |
| |
| TEST(L4STest, SendsEct1AfterRouteChangeEvenIfBleached) { |
| PeerScenario s(*test_info_); |
| |
| PeerScenarioClient::Config config; |
| config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| config.field_trials.Set("WebRTC-Bwe-ScreamV2", "Enabled"); |
| config.disable_encryption = true; |
| |
| // Caller has both wifi and cellular adapters. |
| config.endpoints = {{0, {.type = AdapterType::ADAPTER_TYPE_WIFI}}, |
| {1, {.type = AdapterType::ADAPTER_TYPE_CELLULAR}}}; |
| PeerScenarioClient* caller = s.CreateClient(config); |
| |
| // Callee has only wifi adapter. |
| config.endpoints = {{0, {.type = AdapterType::ADAPTER_TYPE_WIFI}}}; |
| PeerScenarioClient* callee = s.CreateClient(config); |
| |
| auto caller_wifi_node = s.net()->NodeBuilder().Build().node; |
| auto caller_cellular_node = s.net()->NodeBuilder().Build().node; |
| auto bleaching_node = |
| s.net()->NodeBuilder().config({.forward_ecn = false}).Build().node; |
| auto callee_to_caller_wifi = s.net()->NodeBuilder().config({}).Build().node; |
| auto callee_to_caller_cellular = |
| s.net()->NodeBuilder().config({}).Build().node; |
| |
| // Routes from caller to callee bleach ECN. |
| s.net()->CreateRoute(caller->endpoint(0), {caller_wifi_node, bleaching_node}, |
| callee->endpoint(0)); |
| s.net()->CreateRoute(caller->endpoint(1), |
| {caller_cellular_node, bleaching_node}, |
| callee->endpoint(0)); |
| // Routes from callee to caller do not bleach ECN. |
| s.net()->CreateRoute(callee->endpoint(0), {callee_to_caller_wifi}, |
| caller->endpoint(0)); |
| s.net()->CreateRoute(callee->endpoint(0), {callee_to_caller_cellular}, |
| caller->endpoint(1)); |
| |
| int ect1_count_wifi = 0; |
| int not_ect_count_wifi = 0; |
| int ect1_count_cellular = 0; |
| int not_ect_count_cellular = 0; |
| std::atomic<bool> seen_ect1_on_wifi = false; |
| std::atomic<bool> seen_ect1_on_cellular = false; |
| std::atomic<bool> seen_not_ect_on_wifi = false; |
| std::atomic<bool> seen_not_ect_on_cellular = false; |
| |
| caller_wifi_node->router()->SetWatcher([&](const EmulatedIpPacket& packet) { |
| if (!IsRtpPacket(packet.data)) |
| return; |
| if (packet.from.ipaddr() == caller->endpoint(0)->GetPeerLocalAddress()) { |
| if (packet.ecn == EcnMarking::kEct1) { |
| seen_ect1_on_wifi = true; |
| ect1_count_wifi++; |
| } else if (packet.ecn == EcnMarking::kNotEct) { |
| not_ect_count_wifi++; |
| seen_not_ect_on_wifi = true; |
| } |
| } |
| }); |
| |
| caller_cellular_node->router()->SetWatcher( |
| [&](const EmulatedIpPacket& packet) { |
| if (!IsRtpPacket(packet.data)) |
| return; |
| if (packet.from.ipaddr() == |
| caller->endpoint(1)->GetPeerLocalAddress()) { |
| if (packet.ecn == EcnMarking::kEct1) { |
| seen_ect1_on_cellular = true; |
| ect1_count_cellular++; |
| } else if (packet.ecn == EcnMarking::kNotEct) { |
| not_ect_count_cellular++; |
| seen_not_ect_on_cellular = true; |
| } |
| } |
| }); |
| |
| auto signaling = s.ConnectSignaling(caller, callee, {bleaching_node}, |
| {callee_to_caller_wifi}); |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 15; |
| |
| caller->CreateVideo("VIDEO_1", video_conf); |
| signaling.StartIceSignaling(); |
| |
| std::atomic<bool> offer_exchange_done(false); |
| signaling.NegotiateSdp([&](const SessionDescriptionInterface& answer) { |
| offer_exchange_done = true; |
| }); |
| s.WaitAndProcess(&offer_exchange_done); |
| |
| EXPECT_TRUE(s.WaitAndProcess(&seen_ect1_on_wifi, TimeDelta::Seconds(1))); |
| EXPECT_TRUE(s.WaitAndProcess(&seen_not_ect_on_wifi, TimeDelta::Seconds(1))); |
| |
| // Disable caller's wifi and expect that the connection switch to cellular. |
| s.net()->DisableEndpoint(caller->endpoint(0)); |
| EXPECT_TRUE(s.WaitAndProcess(&seen_ect1_on_cellular, TimeDelta::Seconds(5))); |
| EXPECT_TRUE( |
| s.WaitAndProcess(&seen_not_ect_on_cellular, TimeDelta::Seconds(5))); |
| |
| // Check statistics. |
| auto packets_sent_with_ect1_stats = |
| GetPacketsSentWithEct1(GetStatsAndProcess(s, caller)); |
| EXPECT_GE(packets_sent_with_ect1_stats, 0); |
| |
| scoped_refptr<const RTCStatsReport> callee_stats = |
| GetStatsAndProcess(s, callee); |
| EXPECT_EQ(GetPacketsReceivedWithEct1(callee_stats), 0); |
| EXPECT_EQ(GetPacketsReceivedWithCe(callee_stats), 0); |
| |
| // Verify that packets were sent with ECT1 and then fell back to not-ECT. |
| EXPECT_GT(ect1_count_wifi, 0); |
| EXPECT_GT(not_ect_count_wifi, 0); |
| EXPECT_GT(ect1_count_cellular, 0); |
| EXPECT_GT(not_ect_count_cellular, 0); |
| } |
| |
| TEST(L4STest, SendsEct1AfterRouteChangeFromTurnWithBleachingToDirect) { |
| PeerScenario s(*test_info_); |
| |
| EmulatedTURNServerConfig turn_config; |
| turn_config.client_config.type = AdapterType::ADAPTER_TYPE_WIFI; |
| turn_config.peer_config.type = AdapterType::ADAPTER_TYPE_WIFI; |
| EmulatedTURNServerInterface* turn_server = |
| s.net()->CreateTURNServer(turn_config); |
| |
| auto ice_server_config = turn_server->GetIceServerConfig(); |
| PeerConnectionInterface::IceServer ice_server; |
| ice_server.urls.push_back(ice_server_config.url); |
| ice_server.username = ice_server_config.username; |
| ice_server.password = ice_server_config.password; |
| |
| PeerScenarioClient::Config config; |
| config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| config.field_trials.Set("WebRTC-Bwe-ScreamV2", "Enabled"); |
| config.disable_encryption = true; |
| config.endpoints = {{0, {.type = AdapterType::ADAPTER_TYPE_WIFI}}}; |
| config.rtc_config.servers.push_back(ice_server); |
| PeerScenarioClient* caller = s.CreateClient(config); |
| PeerScenarioClient* callee = s.CreateClient(config); |
| |
| // TURN routes for Caller. |
| // Route via a node that will not forward ECN markings to simulate TURN |
| // server bleaching. The route also has longer delay to test that packets will |
| // be delivered out of order when switching to a direct route. |
| s.net()->CreateRoute( |
| caller->endpoint(0), |
| {s.net()->NodeBuilder().delay_ms(50).Build().node, |
| s.net()->NodeBuilder().config({.forward_ecn = false}).Build().node}, |
| turn_server->GetClientEndpoint()); |
| s.net()->CreateRoute(turn_server->GetClientEndpoint(), |
| {s.net()->NodeBuilder().Build().node}, |
| caller->endpoint(0)); |
| |
| // TURN routes for Callee. |
| s.net()->CreateRoute(callee->endpoint(0), |
| {s.net()->NodeBuilder().Build().node}, |
| turn_server->GetClientEndpoint()); |
| s.net()->CreateRoute(turn_server->GetClientEndpoint(), |
| {s.net()->NodeBuilder().Build().node}, |
| callee->endpoint(0)); |
| |
| auto signaling = |
| s.ConnectSignaling(caller, callee, {s.net()->NodeBuilder().Build().node}, |
| {s.net()->NodeBuilder().Build().node}); |
| |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 15; |
| caller->CreateVideo("VIDEO_1", video_conf); |
| signaling.StartIceSignaling(); |
| |
| std::atomic<bool> offer_exchange_done(false); |
| signaling.NegotiateSdp([&](const SessionDescriptionInterface& answer) { |
| offer_exchange_done = true; |
| }); |
| ASSERT_TRUE(s.WaitAndProcess(&offer_exchange_done)); |
| ASSERT_TRUE(offer_exchange_done); |
| |
| /// Run simulation with the TURN route |
| s.ProcessMessages(TimeDelta::Seconds(5)); |
| scoped_refptr<const RTCStatsReport> callee_stats = |
| GetStatsAndProcess(s, callee); |
| ASSERT_GT(GetPacketsReceived(callee_stats), 0); |
| EXPECT_LT(GetAverageRoundTripTime(callee_stats), TimeDelta::Millis(90)); |
| |
| // Create a direct route from caller to callee and callee to caller. |
| EmulatedNetworkNode* caller_to_direct_node = |
| s.net()->NodeBuilder().delay_ms(0).Build().node; |
| s.net()->CreateRoute(caller->endpoint(0), {caller_to_direct_node}, |
| callee->endpoint(0)); |
| int ect1_count_direct = 0; |
| int not_ect_count_direct = 0; |
| caller_to_direct_node->router()->SetWatcher( |
| [&](const EmulatedIpPacket& packet) { |
| if (!IsRtpPacket(packet.data)) |
| return; |
| if (packet.ecn == EcnMarking::kEct1) { |
| ++ect1_count_direct; |
| } else if (packet.ecn == EcnMarking::kNotEct) { |
| ++not_ect_count_direct; |
| } |
| }); |
| s.net()->CreateRoute(callee->endpoint(0), |
| {s.net()->NodeBuilder().Build().node}, |
| caller->endpoint(0)); |
| |
| s.ProcessMessages(TimeDelta::Seconds(10)); |
| // Expect that eventually, caller switches to sending packets with ect1 on the |
| // direct route. |
| EXPECT_GT(ect1_count_direct, 0); |
| EXPECT_EQ(not_ect_count_direct, 0); |
| } |
| |
| TEST(L4STest, RtcpSentAsEct1IfRtpWithEct1Received) { |
| int ecn_count = 0; |
| int not_ect_count = 0; |
| PeerScenario s(*test_info_); |
| PeerScenarioClient::Config config; |
| config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| config.field_trials.Set("WebRTC-Bwe-ScreamV2", "Enabled"); |
| PeerScenarioClient* caller = s.CreateClient(config); |
| PeerScenarioClient* callee = s.CreateClient(config); |
| EmulatedNetworkNode* caller_to_callee_node = |
| s.net()->NodeBuilder().Build().node; |
| EmulatedNetworkNode* callee_to_caller_node = |
| s.net()->NodeBuilder().Build().node; |
| // Callee is not sending media - Thus if Stun is ignored, most packets should |
| // be RTCP. Negotiation is still done using not ECT. |
| callee_to_caller_node->router()->SetWatcher( |
| [&](const EmulatedIpPacket& packet) { |
| if (StunMessage::ValidateFingerprint(packet.data)) { |
| return; |
| } |
| if (packet.ecn == EcnMarking::kEct1 || packet.ecn == EcnMarking::kCe) { |
| ecn_count++; |
| } else { |
| not_ect_count++; |
| } |
| }); |
| |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 15; |
| caller->CreateAudio("AUDIO_1", AudioOptions()); |
| caller->CreateVideo("VIDEO_1", video_conf); |
| |
| s.SimpleConnection(caller, callee, {caller_to_callee_node}, |
| {callee_to_caller_node}); |
| s.ProcessMessages(TimeDelta::Seconds(1)); |
| |
| // Feedback is sent every 25ms. Expect more than 20 feedback packets during |
| // 1S. |
| EXPECT_GT(ecn_count, 20); |
| EXPECT_LT(not_ect_count, 10); |
| } |
| |
| TEST(L4STest, RtcpSentAsNotEctIfRtpEcnBleached) { |
| int rtcp_ecn_count = 0; |
| int rtcp_not_ect_count = 0; |
| PeerScenario s(*test_info_); |
| PeerScenarioClient::Config config; |
| config.field_trials.Set("WebRTC-RFC8888CongestionControlFeedback", |
| "Enabled,offer:true"); |
| config.field_trials.Set("WebRTC-Bwe-ScreamV2", "Enabled"); |
| config.disable_encryption = true; |
| PeerScenarioClient* caller = s.CreateClient(config); |
| PeerScenarioClient* callee = s.CreateClient(config); |
| |
| EmulatedNetworkNode* caller_to_callee_node = |
| s.net()->NodeBuilder().config({.forward_ecn = false}).Build().node; |
| EmulatedNetworkNode* callee_to_caller_node = |
| s.net()->NodeBuilder().Build().node; |
| |
| callee_to_caller_node->router()->SetWatcher( |
| [&](const EmulatedIpPacket& packet) { |
| if (!IsRtcpPacket(packet.data)) { |
| return; |
| } |
| if (packet.ecn == EcnMarking::kEct1 || packet.ecn == EcnMarking::kCe) { |
| rtcp_ecn_count++; |
| } else { |
| rtcp_not_ect_count++; |
| } |
| }); |
| |
| PeerScenarioClient::VideoSendTrackConfig video_conf; |
| video_conf.generator.squares_video->framerate = 15; |
| caller->CreateAudio("AUDIO_1", AudioOptions()); |
| caller->CreateVideo("VIDEO_1", video_conf); |
| s.SimpleConnection(caller, callee, {caller_to_callee_node}, |
| {callee_to_caller_node}); |
| s.ProcessMessages(TimeDelta::Seconds(1)); |
| |
| EXPECT_EQ(rtcp_ecn_count, 0); |
| EXPECT_GT(rtcp_not_ect_count, 0); |
| } |
| |
| } // namespace |
| } // namespace webrtc |
