mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

PacketRouter directly notify RtpTransportControllerSender when sending

Browse source 
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}
This commit is contained in:
Per K 2024-03-27 18:35:55 +00:00 committed by WebRTC LUCI CQ
parent e3b42636f3
commit 02af84064c
10 changed files with 147 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
audio/channel_send.cc
View file

@ -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;

28
call/rtp_transport_controller_send.cc
View file

@ -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 @@ 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);

10
call/rtp_transport_controller_send.h
View file

@ -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 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<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)

1
call/rtp_transport_controller_send_interface.h
View file

@ -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;

2
call/rtp_video_sender.cc
View file

@ -214,8 +214,6 @@ std::vector<RtpStreamSender> 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;

4
call/test/mock_rtp_transport_controller_send.h
View file

@ -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,

1
modules/pacing/BUILD.gn
View file

@ -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",

48
modules/pacing/packet_router.cc
View file

@ -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 @@ bool PacketRouter::SupportsRtxPayloadPadding() const {
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 @@ void PacketRouter::SendPacket(std::unique_ptr<RtpPacketToSend> 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<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 @@ void PacketRouter::SendPacket(std::unique_ptr<RtpPacketToSend> 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<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 @@ absl::optional<uint32_t> 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<uint32_t> ssrcs) {
RTC_DCHECK_RUN_ON(&thread_checker_);

14
modules/pacing/packet_router.h
View file

@ -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 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<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 @@ class PacketRouter : public PacingController::PacketSender {
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 @@ class PacketRouter : public PacingController::PacketSender {
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_);

167
modules/pacing/packet_router_unittest.cc
View file

@ -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<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, PadsOnLastActiveMediaStream) {
}
}
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 @@ TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) {
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 @@ TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) {
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 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
// 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 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
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 @@ 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);