PacketRouter directly notify RtpTransportControllerSender when sending
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 <sprang@google.com>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Jakob Ivarsson <jakobi@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41974}
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 7d40048..4a27001 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -413,8 +413,6 @@
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 7e0580d..a10d75d 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 <cstdint>
#include <memory>
#include <utility>
#include <vector>
@@ -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 @@
// 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 @@
return this;
}
-TransportFeedbackObserver*
-RtpTransportControllerSend::transport_feedback_observer() {
- return this;
-}
-
RtpPacketSender* RtpTransportControllerSend::packet_sender() {
return &pacer_;
}
@@ -570,9 +573,20 @@
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 3d4db3c..68f14b4 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 <atomic>
+#include <cstdint>
#include <map>
#include <memory>
#include <string>
@@ -46,7 +47,6 @@
class RtpTransportControllerSend final
: public RtpTransportControllerSendInterface,
public NetworkLinkRtcpObserver,
- public TransportFeedbackObserver,
public NetworkStateEstimateObserver {
public:
explicit RtpTransportControllerSend(const RtpTransportConfig& config);
@@ -77,7 +77,6 @@
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 @@
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 @@
void UpdateCongestedState() RTC_RUN_ON(sequence_checker_);
absl::optional<bool> 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 eda5b1c..3fa6df5 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -114,7 +114,6 @@
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 56e6845..47e422e 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -214,8 +214,6 @@
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 8050270..fff788b 100644
--- a/call/test/mock_rtp_transport_controller_send.h
+++ b/call/test/mock_rtp_transport_controller_send.h
@@ -59,10 +59,6 @@
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 796f19e..a24bccd 100644
--- a/modules/pacing/BUILD.gn
+++ b/modules/pacing/BUILD.gn
@@ -63,6 +63,7 @@
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 382ffcd..5124e94 100644
--- a/modules/pacing/packet_router.cc
+++ b/modules/pacing/packet_router.cc
@@ -16,7 +16,9 @@
#include <memory>
#include <utility>
+#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 @@
return false;
}
+void PacketRouter::RegisterNotifyBweCallback(
+ absl::AnyInvocable<void(const RtpPacketToSend& packet,
+ const PacedPacketInfo& pacing_info)> 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 @@
"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<TransportSequenceNumber>();
- 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 @@
}
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<TransportSequenceNumber>()) {
+ 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 @@
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<uint32_t> ssrcs) {
RTC_DCHECK_RUN_ON(&thread_checker_);
diff --git a/modules/pacing/packet_router.h b/modules/pacing/packet_router.h
index 4c5747f..ae10637 100644
--- a/modules/pacing/packet_router.h
+++ b/modules/pacing/packet_router.h
@@ -14,6 +14,7 @@
#include <stddef.h>
#include <stdint.h>
+#include <cstdint>
#include <list>
#include <memory>
#include <set>
@@ -21,6 +22,7 @@
#include <utility>
#include <vector>
+#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 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<void(const RtpPacketToSend& packet,
+ const PacedPacketInfo& pacing_info)> callback);
+
void AddSendRtpModule(RtpRtcpInterface* rtp_module, bool remb_candidate);
void RemoveSendRtpModule(RtpRtcpInterface* rtp_module);
@@ -67,8 +74,6 @@
absl::optional<uint32_t> GetRtxSsrcForMedia(uint32_t ssrc) const override;
void OnBatchComplete() override;
- uint16_t CurrentTransportSequenceNumber() const;
-
// Send REMB feedback.
void SendRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs);
@@ -109,6 +114,9 @@
RTC_GUARDED_BY(thread_checker_);
uint64_t transport_seq_ RTC_GUARDED_BY(thread_checker_);
+ absl::AnyInvocable<void(RtpPacketToSend& packet,
+ const PacedPacketInfo& pacing_info)>
+ notify_bwe_callback_ RTC_GUARDED_BY(thread_checker_) = nullptr;
std::vector<std::unique_ptr<RtpPacketToSend>> 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 434cdcc..fdd45cc 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::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 @@
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<MockRtpRtcpInterface> 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<MockRtpRtcpInterface> 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, AllocatesRtpSequenceNumbersIfPacketCanBeSent) {
+ const uint16_t kSsrc1 = 1234;
+ PacketRouter packet_router;
+ NiceMock<MockRtpRtcpInterface> 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<MockRtpRtcpInterface> 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<void(const RtpPacketToSend& packet,
+ const PacedPacketInfo& pacing_info)>
+ notify_bwe_callback;
NiceMock<MockRtpRtcpInterface> 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<TransportSequenceNumber>());
- packet_router.SendPacket(std::move(packet), PacedPacketInfo());
- uint32_t expected_unwrapped_seq = static_cast<uint32_t>(kStartSeq) + i;
- EXPECT_EQ(static_cast<uint16_t>(expected_unwrapped_seq & 0xFFFF),
- packet_router.CurrentTransportSequenceNumber());
- }
+ auto packet = BuildRtpPacket(kSsrc1);
+ EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
+ 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 @@
NiceMock<MockRtpRtcpInterface> 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 @@
packet->SetSsrc(kSsrc1);
EXPECT_CALL(
rtp_1,
- TrySendPacket(
- Pointee(Property(
- &RtpPacketToSend::HasExtension<TransportSequenceNumber>, false)),
- _))
- .WillOnce(Return(true));
+ SendPacket(
+ AllOf(Pointee(Property(
+ &RtpPacketToSend::HasExtension<TransportSequenceNumber>,
+ 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<MockRtpRtcpInterface> rtp_1;
- NiceMock<MockRtpRtcpInterface> 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<TransportSequenceNumber>());
- EXPECT_CALL(rtp_1, TrySendPacket)
- .WillOnce([&](std::unique_ptr<RtpPacketToSend> 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<TransportSequenceNumber>());
-
- EXPECT_CALL(rtp_2, TrySendPacket)
-
- .WillOnce([&](std::unique_ptr<RtpPacketToSend> 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<MockRtpRtcpInterface> rtp;
constexpr uint32_t kSsrc = 1234;
@@ -432,14 +440,9 @@
// Return failure status code to make sure sequence number is not incremented.
auto packet = BuildRtpPacket(kSsrc);
EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
- EXPECT_CALL(rtp, TrySendPacket)
-
- .WillOnce([&](std::unique_ptr<RtpPacketToSend> 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 @@
packet = BuildRtpPacket(kSsrc);
EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
- EXPECT_CALL(rtp, TrySendPacket)
+ EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true));
+ EXPECT_CALL(rtp, SendPacket)
.WillOnce([&](std::unique_ptr<RtpPacketToSend> 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 @@
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);
