From 02af84064c5f31caf7d9f89a24b9beeddf32b05e Mon Sep 17 00:00:00 2001 From: Per K Date: Wed, 27 Mar 2024 18:35:55 +0000 Subject: [PATCH] PacketRouter directly notify RtpTransportControllerSender when sending MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit With this cl RtpTransportControllerSend::OnAddPacket is instead directly invoked from PacketRouter::SendPacket instead of going via RTP module. Transport sequence numbers are instead of directly written to header extension, added to RtpPacketToSendMetaData and written to the extenion by RTP module. This is to allow transport sequence numbers without actually sending them in an extension. Bug: webrtc:15368 Change-Id: Idd03e02a4257dfc4d0f1898b2803345975d7dad2 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/344720 Reviewed-by: Erik Språng Reviewed-by: Erik Språng Reviewed-by: Jakob Ivarsson‎ Commit-Queue: Per Kjellander Cr-Commit-Position: refs/heads/main@{#41974} --- audio/channel_send.cc | 2 - call/rtp_transport_controller_send.cc | 28 ++- call/rtp_transport_controller_send.h | 10 +- .../rtp_transport_controller_send_interface.h | 1 - call/rtp_video_sender.cc | 2 - .../test/mock_rtp_transport_controller_send.h | 4 - modules/pacing/BUILD.gn | 1 + modules/pacing/packet_router.cc | 48 ++--- modules/pacing/packet_router.h | 14 +- modules/pacing/packet_router_unittest.cc | 167 +++++++++--------- 10 files changed, 147 insertions(+), 130 deletions(-) diff --git a/audio/channel_send.cc b/audio/channel_send.cc index 7d40048967..4a2700177b 100644 --- a/audio/channel_send.cc +++ b/audio/channel_send.cc @@ -413,8 +413,6 @@ ChannelSend::ChannelSend( configuration.report_block_data_observer = this; configuration.network_link_rtcp_observer = transport_controller->GetRtcpObserver(); - configuration.transport_feedback_callback = - transport_controller->transport_feedback_observer(); configuration.clock = (clock ? clock : Clock::GetRealTimeClock()); configuration.audio = true; configuration.outgoing_transport = rtp_transport; diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc index 7e0580d1e2..a10d75d2e0 100644 --- a/call/rtp_transport_controller_send.cc +++ b/call/rtp_transport_controller_send.cc @@ -9,6 +9,7 @@ */ #include "call/rtp_transport_controller_send.h" +#include #include #include #include @@ -26,7 +27,9 @@ #include "call/rtp_video_sender.h" #include "logging/rtc_event_log/events/rtc_event_remote_estimate.h" #include "logging/rtc_event_log/events/rtc_event_route_change.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" +#include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" #include "rtc_base/rate_limiter.h" @@ -112,6 +115,11 @@ RtpTransportControllerSend::RtpTransportControllerSend( // Default burst interval overriden by config. pacer_.SetSendBurstInterval(*config.pacer_burst_interval); } + packet_router_.RegisterNotifyBweCallback( + [this](const RtpPacketToSend& packet, + const PacedPacketInfo& pacing_info) { + return NotifyBweOfPacedSentPacket(packet, pacing_info); + }); } RtpTransportControllerSend::~RtpTransportControllerSend() { @@ -224,11 +232,6 @@ RtpTransportControllerSend::network_state_estimate_observer() { return this; } -TransportFeedbackObserver* -RtpTransportControllerSend::transport_feedback_observer() { - return this; -} - RtpPacketSender* RtpTransportControllerSend::packet_sender() { return &pacer_; } @@ -570,9 +573,20 @@ void RtpTransportControllerSend::OnRttUpdate(Timestamp receive_time, PostUpdates(controller_->OnRoundTripTimeUpdate(report)); } -void RtpTransportControllerSend::OnAddPacket( - const RtpPacketSendInfo& packet_info) { +void RtpTransportControllerSend::NotifyBweOfPacedSentPacket( + const RtpPacketToSend& packet, + const PacedPacketInfo& pacing_info) { RTC_DCHECK_RUN_ON(&sequence_checker_); + + if (!packet.transport_sequence_number()) { + return; + } + if (!packet.packet_type()) { + RTC_DCHECK_NOTREACHED() << "Unknown packet type"; + return; + } + + RtpPacketSendInfo packet_info = RtpPacketSendInfo::From(packet, pacing_info); Timestamp creation_time = Timestamp::Millis(env_.clock().TimeInMilliseconds()); feedback_demuxer_.AddPacket(packet_info); diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h index 3d4db3c815..68f14b4987 100644 --- a/call/rtp_transport_controller_send.h +++ b/call/rtp_transport_controller_send.h @@ -12,6 +12,7 @@ #define CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_ #include +#include #include #include #include @@ -46,7 +47,6 @@ class FrameEncryptorInterface; class RtpTransportControllerSend final : public RtpTransportControllerSendInterface, public NetworkLinkRtcpObserver, - public TransportFeedbackObserver, public NetworkStateEstimateObserver { public: explicit RtpTransportControllerSend(const RtpTransportConfig& config); @@ -77,7 +77,6 @@ class RtpTransportControllerSend final PacketRouter* packet_router() override; NetworkStateEstimateObserver* network_state_estimate_observer() override; - TransportFeedbackObserver* transport_feedback_observer() override; RtpPacketSender* packet_sender() override; void SetAllocatedSendBitrateLimits(BitrateAllocationLimits limits) override; @@ -118,9 +117,6 @@ class RtpTransportControllerSend final void OnTransportFeedback(Timestamp receive_time, const rtcp::TransportFeedback& feedback) override; - // Implements TransportFeedbackObserver interface - void OnAddPacket(const RtpPacketSendInfo& packet_info) override; - // Implements NetworkStateEstimateObserver interface void OnRemoteNetworkEstimate(NetworkStateEstimate estimate) override; @@ -143,6 +139,10 @@ class RtpTransportControllerSend final void UpdateCongestedState() RTC_RUN_ON(sequence_checker_); absl::optional GetCongestedStateUpdate() const RTC_RUN_ON(sequence_checker_); + + // Called by packet router just before packet is sent to the RTP modules. + void NotifyBweOfPacedSentPacket(const RtpPacketToSend& packet, + const PacedPacketInfo& pacing_info); void ProcessSentPacket(const rtc::SentPacket& sent_packet) RTC_RUN_ON(sequence_checker_); void ProcessSentPacketUpdates(NetworkControlUpdate updates) diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h index eda5b1c5a2..3fa6df55bb 100644 --- a/call/rtp_transport_controller_send_interface.h +++ b/call/rtp_transport_controller_send_interface.h @@ -114,7 +114,6 @@ class RtpTransportControllerSendInterface { virtual void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) = 0; virtual NetworkStateEstimateObserver* network_state_estimate_observer() = 0; - virtual TransportFeedbackObserver* transport_feedback_observer() = 0; virtual RtpPacketSender* packet_sender() = 0; diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index 56e6845951..47e422ebfc 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -214,8 +214,6 @@ std::vector CreateRtpStreamSenders( configuration.network_link_rtcp_observer = transport->GetRtcpObserver(); configuration.network_state_estimate_observer = transport->network_state_estimate_observer(); - configuration.transport_feedback_callback = - transport->transport_feedback_observer(); configuration.rtt_stats = observers.rtcp_rtt_stats; configuration.rtcp_packet_type_counter_observer = observers.rtcp_type_observer; diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h index 805027009c..fff788b6dc 100644 --- a/call/test/mock_rtp_transport_controller_send.h +++ b/call/test/mock_rtp_transport_controller_send.h @@ -59,10 +59,6 @@ class MockRtpTransportControllerSend network_state_estimate_observer, (), (override)); - MOCK_METHOD(TransportFeedbackObserver*, - transport_feedback_observer, - (), - (override)); MOCK_METHOD(RtpPacketSender*, packet_sender, (), (override)); MOCK_METHOD(void, SetAllocatedSendBitrateLimits, diff --git a/modules/pacing/BUILD.gn b/modules/pacing/BUILD.gn index 796f19e485..a24bccd39c 100644 --- a/modules/pacing/BUILD.gn +++ b/modules/pacing/BUILD.gn @@ -63,6 +63,7 @@ rtc_library("pacing") { absl_deps = [ "//third_party/abseil-cpp/absl/cleanup", "//third_party/abseil-cpp/absl/container:inlined_vector", + "//third_party/abseil-cpp/absl/functional:any_invocable", "//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/strings", "//third_party/abseil-cpp/absl/types:optional", diff --git a/modules/pacing/packet_router.cc b/modules/pacing/packet_router.cc index 382ffcd090..5124e94d13 100644 --- a/modules/pacing/packet_router.cc +++ b/modules/pacing/packet_router.cc @@ -16,7 +16,9 @@ #include #include +#include "absl/functional/any_invocable.h" #include "absl/types/optional.h" +#include "api/transport/network_types.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtcp_packet.h" #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h" @@ -27,12 +29,10 @@ namespace webrtc { -PacketRouter::PacketRouter() : PacketRouter(1) {} - -PacketRouter::PacketRouter(uint16_t start_transport_seq) +PacketRouter::PacketRouter() : last_send_module_(nullptr), active_remb_module_(nullptr), - transport_seq_(start_transport_seq) {} + transport_seq_(1) {} PacketRouter::~PacketRouter() { RTC_DCHECK_RUN_ON(&thread_checker_); @@ -75,6 +75,13 @@ bool PacketRouter::SupportsRtxPayloadPadding() const { return false; } +void PacketRouter::RegisterNotifyBweCallback( + absl::AnyInvocable callback) { + RTC_DCHECK_RUN_ON(&thread_checker_); + notify_bwe_callback_ = std::move(callback); +} + void PacketRouter::AddSendRtpModuleToMap(RtpRtcpInterface* rtp_module, uint32_t ssrc) { RTC_DCHECK_RUN_ON(&thread_checker_); @@ -156,14 +163,6 @@ void PacketRouter::SendPacket(std::unique_ptr packet, "sequence_number", packet->SequenceNumber(), "rtp_timestamp", packet->Timestamp()); - // With the new pacer code path, transport sequence numbers are only set here, - // on the pacer thread. Therefore we don't need atomics/synchronization. - bool assign_transport_sequence_number = - packet->HasExtension(); - if (assign_transport_sequence_number) { - packet->set_transport_sequence_number(transport_seq_); - } - uint32_t ssrc = packet->Ssrc(); auto it = send_modules_map_.find(ssrc); if (it == send_modules_map_.end()) { @@ -175,18 +174,24 @@ void PacketRouter::SendPacket(std::unique_ptr packet, } RtpRtcpInterface* rtp_module = it->second; - if (!rtp_module->TrySendPacket(std::move(packet), cluster_info)) { - RTC_LOG(LS_WARNING) << "Failed to send packet, rejected by RTP module."; + if (!packet || !rtp_module->CanSendPacket(*packet)) { + RTC_LOG(LS_WARNING) << "Failed to send packet, Not sending media"; return; } + // TODO(bugs.webrtc.org/15368): Even if the TransportSequenceNumber extension + // is not negotiated, we will need the transport sequence number for BWE. + if (packet->HasExtension()) { + packet->set_transport_sequence_number(transport_seq_++); + } + rtp_module->AssignSequenceNumber(*packet); + if (notify_bwe_callback_) { + notify_bwe_callback_(*packet, cluster_info); + } + + rtp_module->SendPacket(std::move(packet), cluster_info); modules_used_in_current_batch_.insert(rtp_module); // Sending succeeded. - - if (assign_transport_sequence_number) { - ++transport_seq_; - } - if (rtp_module->SupportsRtxPayloadPadding()) { // This is now the last module to send media, and has the desired // properties needed for payload based padding. Cache it for later use. @@ -281,11 +286,6 @@ absl::optional PacketRouter::GetRtxSsrcForMedia(uint32_t ssrc) const { return absl::nullopt; } -uint16_t PacketRouter::CurrentTransportSequenceNumber() const { - RTC_DCHECK_RUN_ON(&thread_checker_); - return transport_seq_ & 0xFFFF; -} - void PacketRouter::SendRemb(int64_t bitrate_bps, std::vector ssrcs) { RTC_DCHECK_RUN_ON(&thread_checker_); diff --git a/modules/pacing/packet_router.h b/modules/pacing/packet_router.h index 4c5747f7e3..ae10637117 100644 --- a/modules/pacing/packet_router.h +++ b/modules/pacing/packet_router.h @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -21,6 +22,7 @@ #include #include +#include "absl/functional/any_invocable.h" #include "api/sequence_checker.h" #include "api/transport/network_types.h" #include "modules/pacing/pacing_controller.h" @@ -41,12 +43,17 @@ class RtpRtcpInterface; class PacketRouter : public PacingController::PacketSender { public: PacketRouter(); - explicit PacketRouter(uint16_t start_transport_seq); ~PacketRouter() override; PacketRouter(const PacketRouter&) = delete; PacketRouter& operator=(const PacketRouter&) = delete; + // Callback is invoked after pacing, before a packet is forwarded to the + // sending rtp module. + void RegisterNotifyBweCallback( + absl::AnyInvocable callback); + void AddSendRtpModule(RtpRtcpInterface* rtp_module, bool remb_candidate); void RemoveSendRtpModule(RtpRtcpInterface* rtp_module); @@ -67,8 +74,6 @@ class PacketRouter : public PacingController::PacketSender { absl::optional GetRtxSsrcForMedia(uint32_t ssrc) const override; void OnBatchComplete() override; - uint16_t CurrentTransportSequenceNumber() const; - // Send REMB feedback. void SendRemb(int64_t bitrate_bps, std::vector ssrcs); @@ -109,6 +114,9 @@ class PacketRouter : public PacingController::PacketSender { RTC_GUARDED_BY(thread_checker_); uint64_t transport_seq_ RTC_GUARDED_BY(thread_checker_); + absl::AnyInvocable + notify_bwe_callback_ RTC_GUARDED_BY(thread_checker_) = nullptr; std::vector> pending_fec_packets_ RTC_GUARDED_BY(thread_checker_); diff --git a/modules/pacing/packet_router_unittest.cc b/modules/pacing/packet_router_unittest.cc index 434cdccafa..fdd45ccbd8 100644 --- a/modules/pacing/packet_router_unittest.cc +++ b/modules/pacing/packet_router_unittest.cc @@ -19,6 +19,7 @@ #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" +#include "modules/rtp_rtcp/source/rtp_packet_to_send.h" #include "rtc_base/checks.h" #include "rtc_base/fake_clock.h" #include "test/gmock.h" @@ -39,7 +40,9 @@ using ::testing::AtLeast; using ::testing::ElementsAreArray; using ::testing::Field; using ::testing::Gt; +using ::testing::InSequence; using ::testing::Le; +using ::testing::MockFunction; using ::testing::NiceMock; using ::testing::Pointee; using ::testing::Property; @@ -219,29 +222,38 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) { EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1)); EXPECT_CALL(rtp_1, SupportsPadding).WillRepeatedly(Return(true)); EXPECT_CALL(rtp_1, SupportsRtxPayloadPadding).WillRepeatedly(Return(true)); - EXPECT_CALL(rtp_1, TrySendPacket).WillRepeatedly(Return(false)); - EXPECT_CALL(rtp_1, TrySendPacket( - Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc1)), _)) - .WillRepeatedly(Return(true)); + EXPECT_CALL(rtp_1, CanSendPacket) + .WillRepeatedly([&](const RtpPacketToSend& packet) { + if (packet.Ssrc() == kSsrc1) { + return true; + } + return false; + }); NiceMock rtp_2; EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2)); EXPECT_CALL(rtp_2, SupportsPadding).WillRepeatedly(Return(true)); EXPECT_CALL(rtp_2, SupportsRtxPayloadPadding).WillRepeatedly(Return(true)); - EXPECT_CALL(rtp_2, TrySendPacket).WillRepeatedly(Return(false)); - EXPECT_CALL(rtp_2, TrySendPacket( - Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc2)), _)) - .WillRepeatedly(Return(true)); + EXPECT_CALL(rtp_2, CanSendPacket) + .WillRepeatedly([&](const RtpPacketToSend& packet) { + if (packet.Ssrc() == kSsrc2) { + return true; + } + return false; + }); // Third module is sending media, but does not support rtx. NiceMock rtp_3; EXPECT_CALL(rtp_3, SSRC()).WillRepeatedly(Return(kSsrc3)); EXPECT_CALL(rtp_3, SupportsPadding).WillRepeatedly(Return(true)); EXPECT_CALL(rtp_3, SupportsRtxPayloadPadding).WillRepeatedly(Return(false)); - EXPECT_CALL(rtp_3, TrySendPacket).WillRepeatedly(Return(false)); - EXPECT_CALL(rtp_3, TrySendPacket( - Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc3)), _)) - .WillRepeatedly(Return(true)); + EXPECT_CALL(rtp_3, CanSendPacket) + .WillRepeatedly([&](const RtpPacketToSend& packet) { + if (packet.Ssrc() == kSsrc3) { + return true; + } + return false; + }); packet_router_.AddSendRtpModule(&rtp_1, false); packet_router_.AddSendRtpModule(&rtp_2, false); @@ -307,25 +319,60 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) { } } +TEST_F(PacketRouterTest, AllocatesRtpSequenceNumbersIfPacketCanBeSent) { + const uint16_t kSsrc1 = 1234; + PacketRouter packet_router; + NiceMock rtp; + ON_CALL(rtp, SSRC()).WillByDefault(Return(kSsrc1)); + + InSequence s; + EXPECT_CALL(rtp, CanSendPacket).WillRepeatedly(Return(true)); + EXPECT_CALL(rtp, AssignSequenceNumber); + packet_router.AddSendRtpModule(&rtp, false); + packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo()); + + packet_router.OnBatchComplete(); + packet_router.RemoveSendRtpModule(&rtp); +} + +TEST_F(PacketRouterTest, DoNotAllocatesRtpSequenceNumbersIfPacketCanNotBeSent) { + const uint16_t kSsrc1 = 1234; + PacketRouter packet_router; + NiceMock rtp; + ON_CALL(rtp, SSRC()).WillByDefault(Return(kSsrc1)); + + EXPECT_CALL(rtp, CanSendPacket).WillRepeatedly(Return(false)); + EXPECT_CALL(rtp, AssignSequenceNumber).Times(0); + packet_router.AddSendRtpModule(&rtp, false); + packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo()); + + packet_router.OnBatchComplete(); + packet_router.RemoveSendRtpModule(&rtp); +} + TEST_F(PacketRouterTest, AllocatesTransportSequenceNumbers) { - const uint16_t kStartSeq = 0xFFF0; - const size_t kNumPackets = 32; const uint16_t kSsrc1 = 1234; - PacketRouter packet_router(kStartSeq - 1); + PacketRouter packet_router; + testing::MockFunction + notify_bwe_callback; NiceMock rtp_1; + packet_router.RegisterNotifyBweCallback(notify_bwe_callback.AsStdFunction()); + EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1)); - EXPECT_CALL(rtp_1, TrySendPacket).WillRepeatedly(Return(true)); + EXPECT_CALL(rtp_1, CanSendPacket).WillRepeatedly(Return(true)); + packet_router.AddSendRtpModule(&rtp_1, false); - for (size_t i = 0; i < kNumPackets; ++i) { - auto packet = BuildRtpPacket(kSsrc1); - EXPECT_TRUE(packet->ReserveExtension()); - packet_router.SendPacket(std::move(packet), PacedPacketInfo()); - uint32_t expected_unwrapped_seq = static_cast(kStartSeq) + i; - EXPECT_EQ(static_cast(expected_unwrapped_seq & 0xFFFF), - packet_router.CurrentTransportSequenceNumber()); - } + auto packet = BuildRtpPacket(kSsrc1); + EXPECT_TRUE(packet->ReserveExtension()); + EXPECT_CALL(notify_bwe_callback, Call) + .WillOnce([](const RtpPacketToSend& packet, + const PacedPacketInfo& pacing_info) { + EXPECT_EQ(packet.transport_sequence_number(), 1); + }); + packet_router.SendPacket(std::move(packet), PacedPacketInfo()); packet_router.OnBatchComplete(); packet_router.RemoveSendRtpModule(&rtp_1); @@ -358,6 +405,7 @@ TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) { NiceMock rtp_1; ON_CALL(rtp_1, SendingMedia).WillByDefault(Return(true)); ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1)); + ON_CALL(rtp_1, CanSendPacket).WillByDefault(Return(true)); packet_router_.AddSendRtpModule(&rtp_1, false); // Send a packet without TransportSequenceNumber extension registered, @@ -367,58 +415,18 @@ TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) { packet->SetSsrc(kSsrc1); EXPECT_CALL( rtp_1, - TrySendPacket( - Pointee(Property( - &RtpPacketToSend::HasExtension, false)), - _)) - .WillOnce(Return(true)); + SendPacket( + AllOf(Pointee(Property( + &RtpPacketToSend::HasExtension, + false)), + Pointee(Property(&RtpPacketToSend::transport_sequence_number, + absl::nullopt))), + _)); packet_router_.SendPacket(std::move(packet), PacedPacketInfo()); packet_router_.OnBatchComplete(); packet_router_.RemoveSendRtpModule(&rtp_1); } -TEST_F(PacketRouterTest, SendPacketAssignsTransportSequenceNumbers) { - NiceMock rtp_1; - NiceMock rtp_2; - - const uint16_t kSsrc1 = 1234; - const uint16_t kSsrc2 = 2345; - - ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1)); - ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2)); - - packet_router_.AddSendRtpModule(&rtp_1, false); - packet_router_.AddSendRtpModule(&rtp_2, false); - - auto packet = BuildRtpPacket(kSsrc1); - EXPECT_TRUE(packet->ReserveExtension()); - EXPECT_CALL(rtp_1, TrySendPacket) - .WillOnce([&](std::unique_ptr packet, - const PacedPacketInfo& pacing_info) { - // Transport sequence numbers start at 1 per default, for historical - // reasons. - EXPECT_EQ(packet->transport_sequence_number(), 1); - return true; - }); - packet_router_.SendPacket(std::move(packet), PacedPacketInfo()); - - packet = BuildRtpPacket(kSsrc2); - EXPECT_TRUE(packet->ReserveExtension()); - - EXPECT_CALL(rtp_2, TrySendPacket) - - .WillOnce([&](std::unique_ptr packet, - const PacedPacketInfo& pacing_info) { - EXPECT_EQ(packet->transport_sequence_number(), 2); - return true; - }); - packet_router_.SendPacket(std::move(packet), PacedPacketInfo()); - - packet_router_.OnBatchComplete(); - packet_router_.RemoveSendRtpModule(&rtp_1); - packet_router_.RemoveSendRtpModule(&rtp_2); -} - TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) { NiceMock rtp; constexpr uint32_t kSsrc = 1234; @@ -432,14 +440,9 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) { // Return failure status code to make sure sequence number is not incremented. auto packet = BuildRtpPacket(kSsrc); EXPECT_TRUE(packet->ReserveExtension()); - EXPECT_CALL(rtp, TrySendPacket) - - .WillOnce([&](std::unique_ptr packet, - const PacedPacketInfo& pacing_info) { - EXPECT_EQ(packet->transport_sequence_number(), - kStartTransportSequenceNumber); - return false; - }); + EXPECT_CALL(rtp, CanSendPacket).WillOnce([&](const RtpPacketToSend& packet) { + return false; + }); packet_router_.SendPacket(std::move(packet), PacedPacketInfo()); // Send another packet, verify transport sequence number is still at the @@ -447,12 +450,12 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) { packet = BuildRtpPacket(kSsrc); EXPECT_TRUE(packet->ReserveExtension()); - EXPECT_CALL(rtp, TrySendPacket) + EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true)); + EXPECT_CALL(rtp, SendPacket) .WillOnce([&](std::unique_ptr packet, const PacedPacketInfo& pacing_info) { EXPECT_EQ(packet->transport_sequence_number(), kStartTransportSequenceNumber); - return false; }); packet_router_.SendPacket(std::move(packet), PacedPacketInfo()); @@ -531,7 +534,7 @@ TEST_F(PacketRouterTest, RoutesBatchCompleteToActiveModules) { ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2)); packet_router_.AddSendRtpModule(&rtp_1, false); packet_router_.AddSendRtpModule(&rtp_2, false); - EXPECT_CALL(rtp_1, TrySendPacket).WillOnce(Return(true)); + EXPECT_CALL(rtp_1, CanSendPacket).WillOnce(Return(true)); packet_router_.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo()); EXPECT_CALL(rtp_1, OnBatchComplete); EXPECT_CALL(rtp_2, OnBatchComplete).Times(0);