rtp_sender_egress_unittest.cc (40928B)
1 /* 2 * Copyright (c) 2021 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "modules/rtp_rtcp/source/rtp_sender_egress.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <map> 16 #include <memory> 17 #include <optional> 18 #include <utility> 19 20 #include "api/array_view.h" 21 #include "api/call/transport.h" 22 #include "api/environment/environment.h" 23 #include "api/environment/environment_factory.h" 24 #include "api/transport/network_types.h" 25 #include "api/units/data_size.h" 26 #include "api/units/time_delta.h" 27 #include "api/units/timestamp.h" 28 #include "api/video/video_timing.h" 29 #include "modules/rtp_rtcp/include/flexfec_sender.h" 30 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" 31 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 32 #include "modules/rtp_rtcp/source/rtp_header_extension_size.h" 33 #include "modules/rtp_rtcp/source/rtp_header_extensions.h" 34 #include "modules/rtp_rtcp/source/rtp_packet_history.h" 35 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 36 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" 37 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h" 38 #include "rtc_base/checks.h" 39 #include "test/gmock.h" 40 #include "test/gtest.h" 41 #include "test/time_controller/simulated_time_controller.h" 42 43 namespace webrtc { 44 namespace { 45 46 using ::testing::_; 47 using ::testing::AllOf; 48 using ::testing::Eq; 49 using ::testing::Field; 50 using ::testing::InSequence; 51 using ::testing::NiceMock; 52 53 constexpr Timestamp kStartTime = Timestamp::Millis(123456789); 54 constexpr int kDefaultPayloadType = 100; 55 constexpr int kFlexfectPayloadType = 110; 56 constexpr uint16_t kStartSequenceNumber = 33; 57 constexpr uint32_t kSsrc = 725242; 58 constexpr uint32_t kRtxSsrc = 12345; 59 constexpr uint32_t kFlexFecSsrc = 23456; 60 enum : int { 61 kTransportSequenceNumberExtensionId = 1, 62 kAbsoluteSendTimeExtensionId, 63 kTransmissionOffsetExtensionId, 64 kVideoTimingExtensionId, 65 }; 66 67 class MockSendPacketObserver : public SendPacketObserver { 68 public: 69 MOCK_METHOD(void, 70 OnSendPacket, 71 (std::optional<uint16_t>, Timestamp, uint32_t), 72 (override)); 73 }; 74 75 class MockStreamDataCountersCallback : public StreamDataCountersCallback { 76 public: 77 MOCK_METHOD(void, 78 MockDataCountersUpdated, 79 (const StreamDataCounters& counters, uint32_t ssrc)); 80 81 StreamDataCounters GetDataCounters(uint32_t ssrc) const override { 82 auto it = counters_by_ssrc.find(ssrc); 83 return it != counters_by_ssrc.end() ? it->second : StreamDataCounters(); 84 } 85 void DataCountersUpdated(const StreamDataCounters& counters, 86 uint32_t ssrc) override { 87 MockDataCountersUpdated(counters, ssrc); 88 counters_by_ssrc[ssrc] = counters; 89 } 90 91 std::map<uint32_t, StreamDataCounters> counters_by_ssrc; 92 }; 93 94 struct TransmittedPacket { 95 TransmittedPacket(ArrayView<const uint8_t> data, 96 const PacketOptions& packet_options, 97 RtpHeaderExtensionMap* extensions) 98 : packet(extensions), options(packet_options) { 99 EXPECT_TRUE(packet.Parse(data)); 100 } 101 RtpPacketReceived packet; 102 PacketOptions options; 103 }; 104 105 class TestTransport : public Transport { 106 public: 107 explicit TestTransport(RtpHeaderExtensionMap* extensions) 108 : total_data_sent_(DataSize::Zero()), extensions_(extensions) {} 109 MOCK_METHOD(void, SentRtp, (const PacketOptions& options), ()); 110 bool SendRtp(ArrayView<const uint8_t> packet, 111 const PacketOptions& options) override { 112 total_data_sent_ += DataSize::Bytes(packet.size()); 113 last_packet_.emplace(packet, options, extensions_); 114 SentRtp(options); 115 return true; 116 } 117 118 bool SendRtcp(ArrayView<const uint8_t> /* packet */, 119 const PacketOptions& /* options */) override { 120 RTC_CHECK_NOTREACHED(); 121 } 122 123 std::optional<TransmittedPacket> last_packet() { return last_packet_; } 124 125 private: 126 DataSize total_data_sent_; 127 std::optional<TransmittedPacket> last_packet_; 128 RtpHeaderExtensionMap* const extensions_; 129 }; 130 131 } // namespace 132 133 class RtpSenderEgressTest : public ::testing::Test { 134 protected: 135 RtpSenderEgressTest() 136 : time_controller_(kStartTime), 137 env_(CreateEnvironment(time_controller_.GetClock())), 138 transport_(&header_extensions_), 139 packet_history_(env_, 140 RtpPacketHistory::PaddingMode::kRecentLargePacket), 141 sequence_number_(kStartSequenceNumber) {} 142 143 std::unique_ptr<RtpSenderEgress> CreateRtpSenderEgress() { 144 return std::make_unique<RtpSenderEgress>(env_, DefaultConfig(), 145 &packet_history_); 146 } 147 148 RtpRtcpInterface::Configuration DefaultConfig() { 149 RtpRtcpInterface::Configuration config; 150 config.audio = false; 151 config.outgoing_transport = &transport_; 152 config.local_media_ssrc = kSsrc; 153 config.rtx_send_ssrc = kRtxSsrc; 154 config.fec_generator = nullptr; 155 config.send_packet_observer = &send_packet_observer_; 156 config.rtp_stats_callback = &mock_rtp_stats_callback_; 157 config.populate_network2_timestamp = false; 158 return config; 159 } 160 161 std::unique_ptr<RtpPacketToSend> BuildRtpPacket(bool marker_bit, 162 int64_t capture_time_ms) { 163 auto packet = std::make_unique<RtpPacketToSend>(&header_extensions_); 164 packet->SetSsrc(kSsrc); 165 packet->ReserveExtension<AbsoluteSendTime>(); 166 packet->ReserveExtension<TransmissionOffset>(); 167 packet->ReserveExtension<TransportSequenceNumber>(); 168 169 packet->SetPayloadType(kDefaultPayloadType); 170 packet->set_packet_type(RtpPacketMediaType::kVideo); 171 packet->SetMarker(marker_bit); 172 packet->SetTimestamp(capture_time_ms * 90); 173 packet->set_capture_time(Timestamp::Millis(capture_time_ms)); 174 packet->SetSequenceNumber(sequence_number_++); 175 return packet; 176 } 177 178 std::unique_ptr<RtpPacketToSend> BuildRtpPacket() { 179 return BuildRtpPacket(/*marker_bit=*/true, env_.clock().CurrentTime().ms()); 180 } 181 182 GlobalSimulatedTimeController time_controller_; 183 const Environment env_; 184 NiceMock<MockStreamDataCountersCallback> mock_rtp_stats_callback_; 185 NiceMock<MockSendPacketObserver> send_packet_observer_; 186 RtpHeaderExtensionMap header_extensions_; 187 NiceMock<TestTransport> transport_; 188 RtpPacketHistory packet_history_; 189 uint16_t sequence_number_; 190 }; 191 192 TEST_F(RtpSenderEgressTest, SendsPacketsOneByOneWhenNotBatching) { 193 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 194 EXPECT_CALL(transport_, 195 SentRtp(AllOf(Field(&PacketOptions::last_packet_in_batch, false), 196 Field(&PacketOptions::batchable, false)))); 197 sender->SendPacket(BuildRtpPacket(), PacedPacketInfo()); 198 } 199 200 TEST_F(RtpSenderEgressTest, SendsPacketsOneByOneWhenBatchingWithAudio) { 201 auto config = DefaultConfig(); 202 config.enable_send_packet_batching = true; 203 config.audio = true; 204 auto sender = 205 std::make_unique<RtpSenderEgress>(env_, config, &packet_history_); 206 EXPECT_CALL(transport_, 207 SentRtp(AllOf(Field(&PacketOptions::last_packet_in_batch, false), 208 Field(&PacketOptions::batchable, false)))) 209 .Times(2); 210 sender->SendPacket(BuildRtpPacket(), PacedPacketInfo()); 211 sender->SendPacket(BuildRtpPacket(), PacedPacketInfo()); 212 } 213 214 TEST_F(RtpSenderEgressTest, CollectsPacketsWhenBatchingWithVideo) { 215 auto config = DefaultConfig(); 216 config.enable_send_packet_batching = true; 217 RtpSenderEgress sender(env_, config, &packet_history_); 218 sender.SendPacket(BuildRtpPacket(), PacedPacketInfo()); 219 sender.SendPacket(BuildRtpPacket(), PacedPacketInfo()); 220 InSequence s; 221 EXPECT_CALL(transport_, 222 SentRtp(AllOf(Field(&PacketOptions::last_packet_in_batch, false), 223 Field(&PacketOptions::batchable, true)))); 224 EXPECT_CALL(transport_, 225 SentRtp(AllOf(Field(&PacketOptions::last_packet_in_batch, true), 226 Field(&PacketOptions::batchable, true)))); 227 sender.OnBatchComplete(); 228 } 229 230 TEST_F(RtpSenderEgressTest, PacketOptionsIsMediaSetByPacketType) { 231 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 232 233 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 234 auto sequence_number = media_packet->SequenceNumber(); 235 media_packet->set_packet_type(RtpPacketMediaType::kVideo); 236 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 237 EXPECT_TRUE(transport_.last_packet()->options.is_media); 238 239 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket(); 240 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission); 241 retransmission->set_retransmitted_sequence_number(sequence_number); 242 sender->SendPacket(std::move(retransmission), PacedPacketInfo()); 243 EXPECT_FALSE(transport_.last_packet()->options.is_media); 244 } 245 246 TEST_F(RtpSenderEgressTest, DoesnSetIncludedInAllocationByDefault) { 247 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 248 249 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 250 sender->SendPacket(std::move(packet), PacedPacketInfo()); 251 EXPECT_FALSE(transport_.last_packet()->options.included_in_feedback); 252 EXPECT_FALSE(transport_.last_packet()->options.included_in_allocation); 253 } 254 255 TEST_F(RtpSenderEgressTest, 256 SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered) { 257 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 258 259 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 260 TransportSequenceNumber::Uri()); 261 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 262 packet->set_transport_sequence_number(1); 263 sender->SendPacket(std::move(packet), PacedPacketInfo()); 264 EXPECT_TRUE(transport_.last_packet()->options.included_in_feedback); 265 } 266 267 TEST_F( 268 RtpSenderEgressTest, 269 SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered) { 270 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 271 272 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 273 TransportSequenceNumber::Uri()); 274 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 275 packet->set_transport_sequence_number(1); 276 sender->SendPacket(std::move(packet), PacedPacketInfo()); 277 EXPECT_TRUE(transport_.last_packet()->options.included_in_allocation); 278 } 279 280 TEST_F(RtpSenderEgressTest, 281 SetsIncludedInAllocationWhenForcedAsPartOfAllocation) { 282 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 283 sender->ForceIncludeSendPacketsInAllocation(true); 284 285 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 286 sender->SendPacket(std::move(packet), PacedPacketInfo()); 287 EXPECT_FALSE(transport_.last_packet()->options.included_in_feedback); 288 EXPECT_TRUE(transport_.last_packet()->options.included_in_allocation); 289 } 290 291 TEST_F(RtpSenderEgressTest, 292 DoesntWriteTransmissionOffsetOnRtxPaddingBeforeMedia) { 293 header_extensions_.RegisterByUri(kTransmissionOffsetExtensionId, 294 TransmissionOffset::Uri()); 295 296 // Prior to sending media, timestamps are 0. 297 std::unique_ptr<RtpPacketToSend> padding = 298 BuildRtpPacket(/*marker_bit=*/true, /*capture_time_ms=*/0); 299 padding->set_packet_type(RtpPacketMediaType::kPadding); 300 padding->SetSsrc(kRtxSsrc); 301 EXPECT_TRUE(padding->HasExtension<TransmissionOffset>()); 302 303 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 304 sender->SendPacket(std::move(padding), PacedPacketInfo()); 305 306 std::optional<int32_t> offset = 307 transport_.last_packet()->packet.GetExtension<TransmissionOffset>(); 308 EXPECT_EQ(offset, 0); 309 } 310 311 TEST_F(RtpSenderEgressTest, WritesPacerExitToTimingExtension) { 312 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 313 header_extensions_.RegisterByUri(kVideoTimingExtensionId, 314 VideoTimingExtension::Uri()); 315 316 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 317 packet->SetExtension<VideoTimingExtension>(VideoSendTiming{}); 318 319 const int kStoredTimeInMs = 100; 320 time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); 321 sender->SendPacket(std::move(packet), PacedPacketInfo()); 322 ASSERT_TRUE(transport_.last_packet().has_value()); 323 324 VideoSendTiming video_timing; 325 EXPECT_TRUE( 326 transport_.last_packet()->packet.GetExtension<VideoTimingExtension>( 327 &video_timing)); 328 EXPECT_EQ(video_timing.pacer_exit_delta_ms, kStoredTimeInMs); 329 } 330 331 TEST_F(RtpSenderEgressTest, WritesNetwork2ToTimingExtension) { 332 RtpRtcpInterface::Configuration rtp_config = DefaultConfig(); 333 rtp_config.populate_network2_timestamp = true; 334 RtpSenderEgress sender(env_, rtp_config, &packet_history_); 335 header_extensions_.RegisterByUri(kVideoTimingExtensionId, 336 VideoTimingExtension::Uri()); 337 338 const uint16_t kPacerExitMs = 1234u; 339 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 340 VideoSendTiming send_timing = {}; 341 send_timing.pacer_exit_delta_ms = kPacerExitMs; 342 packet->SetExtension<VideoTimingExtension>(send_timing); 343 344 const int kStoredTimeInMs = 100; 345 time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); 346 sender.SendPacket(std::move(packet), PacedPacketInfo()); 347 ASSERT_TRUE(transport_.last_packet().has_value()); 348 349 VideoSendTiming video_timing; 350 EXPECT_TRUE( 351 transport_.last_packet()->packet.GetExtension<VideoTimingExtension>( 352 &video_timing)); 353 EXPECT_EQ(video_timing.network2_timestamp_delta_ms, kStoredTimeInMs); 354 EXPECT_EQ(video_timing.pacer_exit_delta_ms, kPacerExitMs); 355 } 356 357 TEST_F(RtpSenderEgressTest, WritesTransportSequenceNumberExtensionIfAllocated) { 358 RtpSenderEgress sender(env_, DefaultConfig(), &packet_history_); 359 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 360 TransportSequenceNumber::Uri()); 361 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 362 ASSERT_TRUE(packet->HasExtension<TransportSequenceNumber>()); 363 const int64_t kTransportSequenceNumber = 0xFFFF000F; 364 packet->set_transport_sequence_number(kTransportSequenceNumber); 365 366 sender.SendPacket(std::move(packet), PacedPacketInfo()); 367 368 ASSERT_TRUE(transport_.last_packet().has_value()); 369 EXPECT_EQ( 370 transport_.last_packet()->packet.GetExtension<TransportSequenceNumber>(), 371 kTransportSequenceNumber & 0xFFFF); 372 } 373 374 TEST_F(RtpSenderEgressTest, OnSendPacketUpdated) { 375 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 376 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 377 TransportSequenceNumber::Uri()); 378 379 const uint16_t kTransportSequenceNumber = 1; 380 EXPECT_CALL(send_packet_observer_, 381 OnSendPacket(Eq(kTransportSequenceNumber), 382 env_.clock().CurrentTime(), kSsrc)); 383 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 384 packet->set_transport_sequence_number(kTransportSequenceNumber); 385 sender->SendPacket(std::move(packet), PacedPacketInfo()); 386 } 387 388 TEST_F(RtpSenderEgressTest, OnSendPacketUpdatedWithoutTransportSequenceNumber) { 389 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 390 391 EXPECT_CALL( 392 send_packet_observer_, 393 OnSendPacket(Eq(std::nullopt), env_.clock().CurrentTime(), kSsrc)); 394 sender->SendPacket(BuildRtpPacket(), PacedPacketInfo()); 395 } 396 397 TEST_F(RtpSenderEgressTest, OnSendPacketNotUpdatedForRetransmits) { 398 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 399 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 400 TransportSequenceNumber::Uri()); 401 402 const uint16_t kTransportSequenceNumber = 1; 403 EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(0); 404 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 405 packet->set_transport_sequence_number(kTransportSequenceNumber); 406 packet->set_packet_type(RtpPacketMediaType::kRetransmission); 407 packet->set_retransmitted_sequence_number(packet->SequenceNumber()); 408 packet->set_original_ssrc(packet->Ssrc()); 409 sender->SendPacket(std::move(packet), PacedPacketInfo()); 410 } 411 412 TEST_F(RtpSenderEgressTest, ReportsFecRate) { 413 constexpr int kNumPackets = 10; 414 constexpr TimeDelta kTimeBetweenPackets = TimeDelta::Millis(33); 415 416 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 417 DataSize total_fec_data_sent = DataSize::Zero(); 418 // Send some packets, alternating between media and FEC. 419 for (size_t i = 0; i < kNumPackets; ++i) { 420 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 421 media_packet->set_packet_type(RtpPacketMediaType::kVideo); 422 media_packet->SetPayloadSize(500); 423 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 424 425 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket(); 426 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); 427 fec_packet->SetPayloadSize(123); 428 auto fec_packet_size = fec_packet->size(); 429 sender->SendPacket(std::move(fec_packet), PacedPacketInfo()); 430 total_fec_data_sent += DataSize::Bytes(fec_packet_size); 431 432 time_controller_.AdvanceTime(kTimeBetweenPackets); 433 } 434 435 EXPECT_NEAR( 436 (sender->GetSendRates( 437 time_controller_.GetClock() 438 ->CurrentTime())[RtpPacketMediaType::kForwardErrorCorrection]) 439 .bps(), 440 (total_fec_data_sent / (kTimeBetweenPackets * kNumPackets)).bps(), 500); 441 } 442 443 TEST_F(RtpSenderEgressTest, BitrateCallbacks) { 444 class MockBitrateStaticsObserver : public BitrateStatisticsObserver { 445 public: 446 MOCK_METHOD(void, Notify, (uint32_t, uint32_t, uint32_t), (override)); 447 } observer; 448 449 RtpRtcpInterface::Configuration config = DefaultConfig(); 450 config.send_bitrate_observer = &observer; 451 RtpSenderEgress sender(env_, config, &packet_history_); 452 453 // Simulate kNumPackets sent with kPacketInterval intervals, with the 454 // number of packets selected so that we fill (but don't overflow) the one 455 // second averaging window. 456 const TimeDelta kWindowSize = TimeDelta::Seconds(1); 457 const TimeDelta kPacketInterval = TimeDelta::Millis(20); 458 const int kNumPackets = (kWindowSize - kPacketInterval) / kPacketInterval; 459 460 DataSize total_data_sent = DataSize::Zero(); 461 462 // Send all but on of the packets, expect a call for each packet but don't 463 // verify bitrate yet (noisy measurements in the beginning). 464 for (int i = 0; i < kNumPackets; ++i) { 465 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 466 packet->SetPayloadSize(500); 467 // Mark all packets as retransmissions - will cause total and retransmission 468 // rates to be equal. 469 packet->set_packet_type(RtpPacketMediaType::kRetransmission); 470 packet->set_retransmitted_sequence_number(packet->SequenceNumber()); 471 total_data_sent += DataSize::Bytes(packet->size()); 472 473 EXPECT_CALL(observer, Notify(_, _, kSsrc)) 474 .WillOnce([&](uint32_t total_bitrate_bps, 475 uint32_t retransmission_bitrate_bps, uint32_t /*ssrc*/) { 476 TimeDelta window_size = i * kPacketInterval + TimeDelta::Millis(1); 477 // If there is just a single data point, there is no well defined 478 // averaging window so a bitrate of zero will be reported. 479 const double expected_bitrate_bps = 480 i == 0 ? 0.0 : (total_data_sent / window_size).bps(); 481 EXPECT_NEAR(total_bitrate_bps, expected_bitrate_bps, 500); 482 EXPECT_NEAR(retransmission_bitrate_bps, expected_bitrate_bps, 500); 483 }); 484 485 sender.SendPacket(std::move(packet), PacedPacketInfo()); 486 time_controller_.AdvanceTime(kPacketInterval); 487 } 488 } 489 490 TEST_F(RtpSenderEgressTest, DoesNotPutNotRetransmittablePacketsInHistory) { 491 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 492 packet_history_.SetStorePacketsStatus( 493 RtpPacketHistory::StorageMode::kStoreAndCull, 10); 494 495 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 496 packet->set_allow_retransmission(false); 497 auto packet_sequence_number = packet->SequenceNumber(); 498 sender->SendPacket(std::move(packet), PacedPacketInfo()); 499 EXPECT_FALSE(packet_history_.GetPacketState(packet_sequence_number)); 500 } 501 502 TEST_F(RtpSenderEgressTest, PutsRetransmittablePacketsInHistory) { 503 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 504 packet_history_.SetStorePacketsStatus( 505 RtpPacketHistory::StorageMode::kStoreAndCull, 10); 506 507 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 508 packet->set_allow_retransmission(true); 509 auto packet_sequence_number = packet->SequenceNumber(); 510 sender->SendPacket(std::move(packet), PacedPacketInfo()); 511 EXPECT_TRUE(packet_history_.GetPacketState(packet_sequence_number)); 512 } 513 514 TEST_F(RtpSenderEgressTest, DoesNotPutNonMediaInHistory) { 515 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 516 packet_history_.SetStorePacketsStatus( 517 RtpPacketHistory::StorageMode::kStoreAndCull, 10); 518 519 // Non-media packets, even when marked as retransmittable, are not put into 520 // the packet history. 521 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket(); 522 retransmission->set_allow_retransmission(true); 523 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission); 524 retransmission->set_retransmitted_sequence_number( 525 retransmission->SequenceNumber()); 526 auto retransmission_sequence_number = retransmission->SequenceNumber(); 527 sender->SendPacket(std::move(retransmission), PacedPacketInfo()); 528 EXPECT_FALSE(packet_history_.GetPacketState(retransmission_sequence_number)); 529 530 std::unique_ptr<RtpPacketToSend> fec = BuildRtpPacket(); 531 fec->set_allow_retransmission(true); 532 fec->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); 533 auto fec_sequence_number = fec->SequenceNumber(); 534 sender->SendPacket(std::move(fec), PacedPacketInfo()); 535 EXPECT_FALSE(packet_history_.GetPacketState(fec_sequence_number)); 536 537 std::unique_ptr<RtpPacketToSend> padding = BuildRtpPacket(); 538 padding->set_allow_retransmission(true); 539 padding->set_packet_type(RtpPacketMediaType::kPadding); 540 auto padding_sequence_number = padding->SequenceNumber(); 541 sender->SendPacket(std::move(padding), PacedPacketInfo()); 542 EXPECT_FALSE(packet_history_.GetPacketState(padding_sequence_number)); 543 } 544 545 TEST_F(RtpSenderEgressTest, UpdatesSendStatusOfRetransmittedPackets) { 546 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 547 packet_history_.SetStorePacketsStatus( 548 RtpPacketHistory::StorageMode::kStoreAndCull, 10); 549 550 // Send a packet, putting it in the history. 551 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 552 media_packet->set_allow_retransmission(true); 553 auto media_packet_sequence_number = media_packet->SequenceNumber(); 554 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 555 EXPECT_TRUE(packet_history_.GetPacketState(media_packet_sequence_number)); 556 557 // Simulate a retransmission, marking the packet as pending. 558 std::unique_ptr<RtpPacketToSend> retransmission = 559 packet_history_.GetPacketAndMarkAsPending(media_packet_sequence_number); 560 retransmission->set_retransmitted_sequence_number( 561 media_packet_sequence_number); 562 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission); 563 EXPECT_TRUE(packet_history_.GetPacketState(media_packet_sequence_number)); 564 565 // Simulate packet leaving pacer, the packet should be marked as non-pending. 566 sender->SendPacket(std::move(retransmission), PacedPacketInfo()); 567 EXPECT_TRUE(packet_history_.GetPacketState(media_packet_sequence_number)); 568 } 569 570 TEST_F(RtpSenderEgressTest, StreamDataCountersCallbacks) { 571 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 572 573 const RtpPacketCounter kEmptyCounter; 574 RtpPacketCounter expected_transmitted_counter; 575 RtpPacketCounter expected_retransmission_counter; 576 577 // Send a media packet. 578 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 579 media_packet->SetPayloadSize(6); 580 media_packet->SetSequenceNumber(kStartSequenceNumber); 581 media_packet->set_time_in_send_queue(TimeDelta::Millis(10)); 582 expected_transmitted_counter.packets += 1; 583 expected_transmitted_counter.payload_bytes += media_packet->payload_size(); 584 expected_transmitted_counter.header_bytes += media_packet->headers_size(); 585 expected_transmitted_counter.total_packet_delay += TimeDelta::Millis(10); 586 587 EXPECT_CALL(mock_rtp_stats_callback_, 588 MockDataCountersUpdated( 589 AllOf(Field(&StreamDataCounters::transmitted, 590 expected_transmitted_counter), 591 Field(&StreamDataCounters::retransmitted, 592 expected_retransmission_counter), 593 Field(&StreamDataCounters::fec, kEmptyCounter)), 594 kSsrc)); 595 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 596 time_controller_.AdvanceTime(TimeDelta::Zero()); 597 598 // Send a retransmission. Retransmissions are counted into both transmitted 599 // and retransmitted packet statistics. 600 std::unique_ptr<RtpPacketToSend> retransmission_packet = BuildRtpPacket(); 601 retransmission_packet->set_packet_type(RtpPacketMediaType::kRetransmission); 602 retransmission_packet->SetSequenceNumber(kStartSequenceNumber); 603 retransmission_packet->set_retransmitted_sequence_number( 604 kStartSequenceNumber); 605 retransmission_packet->set_time_in_send_queue(TimeDelta::Millis(20)); 606 expected_transmitted_counter.packets += 1; 607 expected_transmitted_counter.payload_bytes += 608 retransmission_packet->payload_size(); 609 expected_transmitted_counter.header_bytes += 610 retransmission_packet->headers_size(); 611 expected_transmitted_counter.total_packet_delay += TimeDelta::Millis(20); 612 613 expected_retransmission_counter.packets += 1; 614 expected_retransmission_counter.payload_bytes += 615 retransmission_packet->payload_size(); 616 expected_retransmission_counter.header_bytes += 617 retransmission_packet->headers_size(); 618 expected_retransmission_counter.total_packet_delay += TimeDelta::Millis(20); 619 620 EXPECT_CALL(mock_rtp_stats_callback_, 621 MockDataCountersUpdated( 622 AllOf(Field(&StreamDataCounters::transmitted, 623 expected_transmitted_counter), 624 Field(&StreamDataCounters::retransmitted, 625 expected_retransmission_counter), 626 Field(&StreamDataCounters::fec, kEmptyCounter)), 627 kSsrc)); 628 sender->SendPacket(std::move(retransmission_packet), PacedPacketInfo()); 629 time_controller_.AdvanceTime(TimeDelta::Zero()); 630 631 // Send a padding packet. 632 std::unique_ptr<RtpPacketToSend> padding_packet = BuildRtpPacket(); 633 padding_packet->set_packet_type(RtpPacketMediaType::kPadding); 634 padding_packet->SetPadding(224); 635 padding_packet->SetSequenceNumber(kStartSequenceNumber + 1); 636 padding_packet->set_time_in_send_queue(TimeDelta::Millis(30)); 637 expected_transmitted_counter.packets += 1; 638 expected_transmitted_counter.padding_bytes += padding_packet->padding_size(); 639 expected_transmitted_counter.header_bytes += padding_packet->headers_size(); 640 expected_transmitted_counter.total_packet_delay += TimeDelta::Millis(30); 641 642 EXPECT_CALL(mock_rtp_stats_callback_, 643 MockDataCountersUpdated( 644 AllOf(Field(&StreamDataCounters::transmitted, 645 expected_transmitted_counter), 646 Field(&StreamDataCounters::retransmitted, 647 expected_retransmission_counter), 648 Field(&StreamDataCounters::fec, kEmptyCounter)), 649 kSsrc)); 650 sender->SendPacket(std::move(padding_packet), PacedPacketInfo()); 651 time_controller_.AdvanceTime(TimeDelta::Zero()); 652 } 653 654 TEST_F(RtpSenderEgressTest, StreamDataCountersCallbacksFec) { 655 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 656 657 const RtpPacketCounter kEmptyCounter; 658 RtpPacketCounter expected_transmitted_counter; 659 RtpPacketCounter expected_fec_counter; 660 661 // Send a media packet. 662 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 663 media_packet->SetPayloadSize(6); 664 expected_transmitted_counter.packets += 1; 665 expected_transmitted_counter.payload_bytes += media_packet->payload_size(); 666 expected_transmitted_counter.header_bytes += media_packet->headers_size(); 667 668 EXPECT_CALL( 669 mock_rtp_stats_callback_, 670 MockDataCountersUpdated( 671 AllOf(Field(&StreamDataCounters::transmitted, 672 expected_transmitted_counter), 673 Field(&StreamDataCounters::retransmitted, kEmptyCounter), 674 Field(&StreamDataCounters::fec, expected_fec_counter)), 675 kSsrc)); 676 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 677 time_controller_.AdvanceTime(TimeDelta::Zero()); 678 679 // Send and FEC packet. FEC is counted into both transmitted and FEC packet 680 // statistics. 681 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket(); 682 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); 683 fec_packet->SetPayloadSize(6); 684 expected_transmitted_counter.packets += 1; 685 expected_transmitted_counter.payload_bytes += fec_packet->payload_size(); 686 expected_transmitted_counter.header_bytes += fec_packet->headers_size(); 687 688 expected_fec_counter.packets += 1; 689 expected_fec_counter.payload_bytes += fec_packet->payload_size(); 690 expected_fec_counter.header_bytes += fec_packet->headers_size(); 691 692 EXPECT_CALL( 693 mock_rtp_stats_callback_, 694 MockDataCountersUpdated( 695 AllOf(Field(&StreamDataCounters::transmitted, 696 expected_transmitted_counter), 697 Field(&StreamDataCounters::retransmitted, kEmptyCounter), 698 Field(&StreamDataCounters::fec, expected_fec_counter)), 699 kSsrc)); 700 sender->SendPacket(std::move(fec_packet), PacedPacketInfo()); 701 time_controller_.AdvanceTime(TimeDelta::Zero()); 702 } 703 704 TEST_F(RtpSenderEgressTest, UpdatesDataCounters) { 705 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 706 707 const RtpPacketCounter kEmptyCounter; 708 709 // Send a media packet. 710 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 711 media_packet->SetPayloadSize(6); 712 auto media_packet_sequence_number = media_packet->SequenceNumber(); 713 auto media_packet_payload_size = media_packet->payload_size(); 714 auto media_packet_padding_size = media_packet->padding_size(); 715 auto media_packet_headers_size = media_packet->headers_size(); 716 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 717 time_controller_.AdvanceTime(TimeDelta::Zero()); 718 719 // Send an RTX retransmission packet. 720 std::unique_ptr<RtpPacketToSend> rtx_packet = BuildRtpPacket(); 721 rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission); 722 rtx_packet->SetSsrc(kRtxSsrc); 723 rtx_packet->SetPayloadSize(7); 724 rtx_packet->set_retransmitted_sequence_number(media_packet_sequence_number); 725 auto rtx_packet_payload_size = rtx_packet->payload_size(); 726 auto rtx_packet_padding_size = rtx_packet->padding_size(); 727 auto rtx_packet_headers_size = rtx_packet->headers_size(); 728 sender->SendPacket(std::move(rtx_packet), PacedPacketInfo()); 729 time_controller_.AdvanceTime(TimeDelta::Zero()); 730 731 StreamDataCounters rtp_stats; 732 StreamDataCounters rtx_stats; 733 sender->GetDataCounters(&rtp_stats, &rtx_stats); 734 735 EXPECT_EQ(rtp_stats.transmitted.packets, 1u); 736 EXPECT_EQ(rtp_stats.transmitted.payload_bytes, media_packet_payload_size); 737 EXPECT_EQ(rtp_stats.transmitted.padding_bytes, media_packet_padding_size); 738 EXPECT_EQ(rtp_stats.transmitted.header_bytes, media_packet_headers_size); 739 EXPECT_EQ(rtp_stats.retransmitted, kEmptyCounter); 740 EXPECT_EQ(rtp_stats.fec, kEmptyCounter); 741 742 // Retransmissions are counted both into transmitted and retransmitted 743 // packet counts. 744 EXPECT_EQ(rtx_stats.transmitted.packets, 1u); 745 EXPECT_EQ(rtx_stats.transmitted.payload_bytes, rtx_packet_payload_size); 746 EXPECT_EQ(rtx_stats.transmitted.padding_bytes, rtx_packet_padding_size); 747 EXPECT_EQ(rtx_stats.transmitted.header_bytes, rtx_packet_headers_size); 748 EXPECT_EQ(rtx_stats.retransmitted, rtx_stats.transmitted); 749 EXPECT_EQ(rtx_stats.fec, kEmptyCounter); 750 } 751 752 TEST_F(RtpSenderEgressTest, SendPacketUpdatesExtensions) { 753 header_extensions_.RegisterByUri(kVideoTimingExtensionId, 754 VideoTimingExtension::Uri()); 755 header_extensions_.RegisterByUri(kAbsoluteSendTimeExtensionId, 756 AbsoluteSendTime::Uri()); 757 header_extensions_.RegisterByUri(kTransmissionOffsetExtensionId, 758 TransmissionOffset::Uri()); 759 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 760 761 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 762 packet->set_packetization_finish_time(env_.clock().CurrentTime()); 763 764 const int32_t kDiffMs = 10; 765 time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs)); 766 767 sender->SendPacket(std::move(packet), PacedPacketInfo()); 768 769 RtpPacketReceived received_packet = transport_.last_packet()->packet; 770 771 EXPECT_EQ(received_packet.GetExtension<TransmissionOffset>(), kDiffMs * 90); 772 773 EXPECT_EQ(received_packet.GetExtension<AbsoluteSendTime>(), 774 AbsoluteSendTime::To24Bits(env_.clock().CurrentTime())); 775 776 VideoSendTiming timing; 777 EXPECT_TRUE(received_packet.GetExtension<VideoTimingExtension>(&timing)); 778 EXPECT_EQ(timing.pacer_exit_delta_ms, kDiffMs); 779 } 780 781 TEST_F(RtpSenderEgressTest, SendPacketSetsPacketOptions) { 782 const uint16_t kPacketId = 42; 783 const uint16_t kSequenceNumber = 456; 784 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 785 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 786 TransportSequenceNumber::Uri()); 787 788 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 789 uint32_t ssrc = packet->Ssrc(); 790 packet->SetSequenceNumber(kSequenceNumber); 791 packet->set_transport_sequence_number(kPacketId); 792 EXPECT_CALL(send_packet_observer_, OnSendPacket); 793 sender->SendPacket(std::move(packet), PacedPacketInfo()); 794 795 PacketOptions packet_options = transport_.last_packet()->options; 796 797 EXPECT_EQ(packet_options.packet_id, kPacketId); 798 EXPECT_TRUE(packet_options.included_in_allocation); 799 EXPECT_TRUE(packet_options.included_in_feedback); 800 EXPECT_TRUE(packet_options.is_media); 801 802 // Send another packet as retransmission, verify options are populated. 803 std::unique_ptr<RtpPacketToSend> retransmission = BuildRtpPacket(); 804 retransmission->set_transport_sequence_number(kPacketId + 1); 805 retransmission->set_packet_type(RtpPacketMediaType::kRetransmission); 806 retransmission->set_retransmitted_sequence_number(kSequenceNumber); 807 retransmission->set_original_ssrc(ssrc); 808 sender->SendPacket(std::move(retransmission), PacedPacketInfo()); 809 EXPECT_FALSE(transport_.last_packet()->options.is_media); 810 } 811 812 TEST_F(RtpSenderEgressTest, SendPacketSetsPacketOptionsIdFromExtension) { 813 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 814 TransportSequenceNumber::Uri()); 815 RtpSenderEgress sender(env_, DefaultConfig(), &packet_history_); 816 817 // 64-bit transport sequence number. 818 const int64_t kTransportSequenceNumber = 0xFFFF000F; 819 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 820 packet->set_transport_sequence_number(kTransportSequenceNumber); 821 822 EXPECT_CALL(send_packet_observer_, OnSendPacket); 823 sender.SendPacket(std::move(packet), PacedPacketInfo()); 824 825 ASSERT_TRUE(transport_.last_packet().has_value()); 826 EXPECT_EQ( 827 transport_.last_packet()->packet.GetExtension<TransportSequenceNumber>(), 828 kTransportSequenceNumber & 0xFFFF); 829 PacketOptions packet_options = transport_.last_packet()->options; 830 // 16 bit packet id. 831 EXPECT_EQ(packet_options.packet_id, kTransportSequenceNumber & 0xFFFF); 832 } 833 834 TEST_F(RtpSenderEgressTest, 835 SendPacketSetsPacketOptionsIdFromRtpSendPacketIfNotUsingExtension) { 836 RtpSenderEgress sender(env_, DefaultConfig(), &packet_history_); 837 // 64-bit transport sequence number. 838 const int64_t kTransportSequenceNumber = 0xFFFF000F; 839 std::unique_ptr<RtpPacketToSend> packet = BuildRtpPacket(); 840 packet->set_transport_sequence_number(kTransportSequenceNumber); 841 842 EXPECT_CALL(send_packet_observer_, OnSendPacket); 843 sender.SendPacket(std::move(packet), PacedPacketInfo()); 844 845 ASSERT_TRUE(transport_.last_packet().has_value()); 846 ASSERT_FALSE( 847 transport_.last_packet()->packet.HasExtension<TransportSequenceNumber>()); 848 PacketOptions packet_options = transport_.last_packet()->options; 849 EXPECT_EQ(packet_options.packet_id, kTransportSequenceNumber); 850 } 851 852 TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) { 853 const size_t kPayloadSize = 1000; 854 855 const ArrayView<const RtpExtensionSize> kNoRtpHeaderExtensionSizes; 856 FlexfecSender flexfec(env_, kFlexfectPayloadType, kFlexFecSsrc, kSsrc, 857 /*mid=*/"", 858 /*rtp_header_extensions=*/{}, 859 kNoRtpHeaderExtensionSizes, 860 /*rtp_state=*/nullptr); 861 RtpRtcpInterface::Configuration config = DefaultConfig(); 862 config.fec_generator = &flexfec; 863 RtpSenderEgress sender(env_, config, &packet_history_); 864 865 header_extensions_.RegisterByUri(kTransportSequenceNumberExtensionId, 866 TransportSequenceNumber::Uri()); 867 868 const Timestamp capture_time = env_.clock().CurrentTime(); 869 870 std::unique_ptr<RtpPacketToSend> video_packet = BuildRtpPacket(); 871 video_packet->set_packet_type(RtpPacketMediaType::kVideo); 872 video_packet->SetPayloadSize(kPayloadSize); 873 video_packet->set_transport_sequence_number(1); 874 875 std::unique_ptr<RtpPacketToSend> rtx_packet = BuildRtpPacket(); 876 rtx_packet->SetSsrc(kRtxSsrc); 877 rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission); 878 rtx_packet->set_original_ssrc(video_packet->Ssrc()); 879 rtx_packet->set_retransmitted_sequence_number(video_packet->SequenceNumber()); 880 rtx_packet->SetPayloadSize(kPayloadSize); 881 rtx_packet->set_transport_sequence_number(2); 882 883 std::unique_ptr<RtpPacketToSend> fec_packet = BuildRtpPacket(); 884 fec_packet->SetSsrc(kFlexFecSsrc); 885 fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); 886 fec_packet->SetPayloadSize(kPayloadSize); 887 fec_packet->set_transport_sequence_number(3); 888 889 const int64_t kDiffMs = 25; 890 time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs)); 891 892 EXPECT_CALL(send_packet_observer_, OnSendPacket(Eq(1), capture_time, kSsrc)); 893 894 sender.SendPacket(std::move(video_packet), PacedPacketInfo()); 895 896 // Send packet observer not called for padding/retransmissions. 897 EXPECT_CALL(send_packet_observer_, OnSendPacket(Eq(2), _, _)).Times(0); 898 sender.SendPacket(std::move(rtx_packet), PacedPacketInfo()); 899 900 EXPECT_CALL(send_packet_observer_, 901 OnSendPacket(Eq(3), capture_time, kFlexFecSsrc)); 902 sender.SendPacket(std::move(fec_packet), PacedPacketInfo()); 903 904 time_controller_.AdvanceTime(TimeDelta::Zero()); 905 StreamDataCounters rtp_stats = 906 mock_rtp_stats_callback_.GetDataCounters(kSsrc); 907 StreamDataCounters rtx_stats = 908 mock_rtp_stats_callback_.GetDataCounters(kRtxSsrc); 909 StreamDataCounters fec_stats = 910 mock_rtp_stats_callback_.GetDataCounters(kFlexFecSsrc); 911 sender.GetDataCounters(&rtp_stats, &rtx_stats); 912 EXPECT_EQ(rtp_stats.transmitted.packets, 1u); 913 EXPECT_EQ(fec_stats.transmitted.packets, 1u); 914 EXPECT_EQ(rtx_stats.retransmitted.packets, 1u); 915 } 916 917 TEST_F(RtpSenderEgressTest, SupportsAbortingRetransmissions) { 918 std::unique_ptr<RtpSenderEgress> sender = CreateRtpSenderEgress(); 919 packet_history_.SetStorePacketsStatus( 920 RtpPacketHistory::StorageMode::kStoreAndCull, 10); 921 922 // Create a packet and send it so it is put in the history. 923 std::unique_ptr<RtpPacketToSend> media_packet = BuildRtpPacket(); 924 media_packet->set_packet_type(RtpPacketMediaType::kVideo); 925 media_packet->set_allow_retransmission(true); 926 const uint16_t media_sequence_number = media_packet->SequenceNumber(); 927 sender->SendPacket(std::move(media_packet), PacedPacketInfo()); 928 929 // Fetch a retranmission packet from the history, this should mark the 930 // media packets as pending so it is not available to grab again. 931 std::unique_ptr<RtpPacketToSend> retransmission_packet = 932 packet_history_.GetPacketAndMarkAsPending(media_sequence_number); 933 ASSERT_TRUE(retransmission_packet); 934 EXPECT_FALSE( 935 packet_history_.GetPacketAndMarkAsPending(media_sequence_number)); 936 937 // Mark retransmission as aborted, fetching packet is possible again. 938 retransmission_packet.reset(); 939 uint16_t kAbortedSequenceNumbers[] = {media_sequence_number}; 940 sender->OnAbortedRetransmissions(kAbortedSequenceNumbers); 941 EXPECT_TRUE(packet_history_.GetPacketAndMarkAsPending(media_sequence_number)); 942 } 943 944 } // namespace webrtc