[ tor-browser ].git.dasho

rtp_sender_unittest.cc (57553B)
      1 /*
      2 *  Copyright (c) 2012 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.h"
     12 
     13 #include <cstddef>
     14 #include <cstdint>
     15 #include <memory>
     16 #include <optional>
     17 #include <string>
     18 #include <utility>
     19 #include <vector>
     20 
     21 #include "absl/strings/string_view.h"
     22 #include "api/environment/environment.h"
     23 #include "api/environment/environment_factory.h"
     24 #include "api/rtp_packet_sender.h"
     25 #include "api/rtp_parameters.h"
     26 #include "api/units/frequency.h"
     27 #include "api/units/time_delta.h"
     28 #include "api/units/timestamp.h"
     29 #include "api/video/video_codec_type.h"
     30 #include "api/video/video_frame_type.h"
     31 #include "modules/rtp_rtcp/include/flexfec_sender.h"
     32 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
     33 #include "modules/rtp_rtcp/source/packet_sequencer.h"
     34 #include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
     35 #include "modules/rtp_rtcp/source/rtp_header_extension_size.h"
     36 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
     37 #include "modules/rtp_rtcp/source/rtp_packet_history.h"
     38 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
     39 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
     40 #include "modules/rtp_rtcp/source/rtp_sender_video.h"
     41 #include "modules/rtp_rtcp/source/video_fec_generator.h"
     42 #include "rtc_base/rate_limiter.h"
     43 #include "test/gmock.h"
     44 #include "test/gtest.h"
     45 #include "test/time_controller/simulated_time_controller.h"
     46 
     47 namespace webrtc {
     48 
     49 namespace {
     50 enum : int {  // The first valid value is 1.
     51  kAbsoluteSendTimeExtensionId = 1,
     52  kAudioLevelExtensionId,
     53  kGenericDescriptorId,
     54  kMidExtensionId,
     55  kRepairedRidExtensionId,
     56  kRidExtensionId,
     57  kTransmissionTimeOffsetExtensionId,
     58  kTransportSequenceNumberExtensionId,
     59  kVideoRotationExtensionId,
     60  kVideoTimingExtensionId,
     61 };
     62 
     63 constexpr int kPayload = 100;
     64 constexpr int kRtxPayload = 98;
     65 constexpr uint32_t kTimestamp = 10;
     66 constexpr uint16_t kSeqNum = 33;
     67 constexpr uint32_t kSsrc = 725242;
     68 constexpr uint32_t kRtxSsrc = 12345;
     69 constexpr uint32_t kFlexFecSsrc = 45678;
     70 constexpr uint64_t kStartTime = 123456789;
     71 constexpr uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
     72 constexpr TimeDelta kDefaultExpectedRetransmissionTime = TimeDelta::Millis(125);
     73 constexpr Frequency kRtpClockRate = Frequency::Hertz(90'000);
     74 constexpr absl::string_view kMid = "mid";
     75 constexpr absl::string_view kRid = "f";
     76 constexpr bool kMarkerBit = true;
     77 
     78 using ::testing::AllOf;
     79 using ::testing::AtLeast;
     80 using ::testing::Each;
     81 using ::testing::ElementsAre;
     82 using ::testing::ElementsAreArray;
     83 using ::testing::Eq;
     84 using ::testing::Gt;
     85 using ::testing::IsEmpty;
     86 using ::testing::Not;
     87 using ::testing::Pointee;
     88 using ::testing::Property;
     89 using ::testing::Return;
     90 using ::testing::SizeIs;
     91 
     92 class MockRtpPacketPacer : public RtpPacketSender {
     93 public:
     94  MockRtpPacketPacer() {}
     95  ~MockRtpPacketPacer() override {}
     96 
     97  MOCK_METHOD(void,
     98              EnqueuePackets,
     99              (std::vector<std::unique_ptr<RtpPacketToSend>>),
    100              (override));
    101  MOCK_METHOD(void, RemovePacketsForSsrc, (uint32_t), (override));
    102 };
    103 
    104 uint32_t ToRtpTimestamp(Timestamp time) {
    105  return static_cast<int64_t>((time - Timestamp::Zero()) * kRtpClockRate) &
    106         0xFFFF'FFFF;
    107 }
    108 
    109 }  // namespace
    110 
    111 class RtpSenderTest : public ::testing::Test {
    112 protected:
    113  RtpSenderTest()
    114      : time_controller_(Timestamp::Millis(kStartTime)),
    115        env_(CreateEnvironment(time_controller_.GetClock())),
    116        retransmission_rate_limiter_(&env_.clock(), 1000),
    117        flexfec_sender_(env_,
    118                        0,
    119                        kFlexFecSsrc,
    120                        kSsrc,
    121                        "",
    122                        std::vector<RtpExtension>(),
    123                        std::vector<RtpExtensionSize>(),
    124                        nullptr) {}
    125 
    126  void SetUp() override { SetUpRtpSender(true, false, nullptr); }
    127 
    128  void SetUpRtpSender(bool populate_network2,
    129                      bool always_send_mid_and_rid,
    130                      VideoFecGenerator* fec_generator) {
    131    RtpRtcpInterface::Configuration config = GetDefaultConfig();
    132    config.fec_generator = fec_generator;
    133    config.populate_network2_timestamp = populate_network2;
    134    config.always_send_mid_and_rid = always_send_mid_and_rid;
    135    CreateSender(config);
    136  }
    137 
    138  RtpRtcpInterface::Configuration GetDefaultConfig() {
    139    RtpRtcpInterface::Configuration config;
    140    config.local_media_ssrc = kSsrc;
    141    config.rtx_send_ssrc = kRtxSsrc;
    142    config.retransmission_rate_limiter = &retransmission_rate_limiter_;
    143    config.paced_sender = &mock_paced_sender_;
    144    // Configure rid unconditionally, it has effect only if
    145    // corresponding header extension is enabled.
    146    config.rid = std::string(kRid);
    147    return config;
    148  }
    149 
    150  void CreateSender(const RtpRtcpInterface::Configuration& config) {
    151    packet_history_ = std::make_unique<RtpPacketHistory>(
    152        env_, RtpPacketHistory::PaddingMode::kRecentLargePacket);
    153    sequencer_.emplace(kSsrc, kRtxSsrc,
    154                       /*require_marker_before_media_padding=*/!config.audio,
    155                       &env_.clock());
    156    rtp_sender_ = std::make_unique<RTPSender>(
    157        env_, config, packet_history_.get(), config.paced_sender);
    158    sequencer_->set_media_sequence_number(kSeqNum);
    159    rtp_sender_->SetTimestampOffset(0);
    160  }
    161 
    162  GlobalSimulatedTimeController time_controller_;
    163  const Environment env_;
    164  MockRtpPacketPacer mock_paced_sender_;
    165  RateLimiter retransmission_rate_limiter_;
    166  FlexfecSender flexfec_sender_;
    167 
    168  std::optional<PacketSequencer> sequencer_;
    169  std::unique_ptr<RtpPacketHistory> packet_history_;
    170  std::unique_ptr<RTPSender> rtp_sender_;
    171 
    172  std::unique_ptr<RtpPacketToSend> BuildRtpPacket(int payload_type,
    173                                                  bool marker_bit,
    174                                                  uint32_t rtp_timestamp,
    175                                                  Timestamp capture_time) {
    176    auto packet = rtp_sender_->AllocatePacket();
    177    packet->SetPayloadType(payload_type);
    178    packet->set_packet_type(RtpPacketMediaType::kVideo);
    179    packet->SetMarker(marker_bit);
    180    packet->SetTimestamp(rtp_timestamp);
    181    packet->set_capture_time(capture_time);
    182    return packet;
    183  }
    184 
    185  std::unique_ptr<RtpPacketToSend> SendPacket(Timestamp capture_time,
    186                                              int payload_length) {
    187    uint32_t rtp_timestamp = ToRtpTimestamp(capture_time);
    188    auto packet =
    189        BuildRtpPacket(kPayload, kMarkerBit, rtp_timestamp, capture_time);
    190    packet->AllocatePayload(payload_length);
    191    packet->set_allow_retransmission(true);
    192 
    193    // Packet should be stored in a send bucket.
    194    std::vector<std::unique_ptr<RtpPacketToSend>> packets(1);
    195    packets[0] = std::make_unique<RtpPacketToSend>(*packet);
    196    rtp_sender_->EnqueuePackets(std::move(packets));
    197    return packet;
    198  }
    199 
    200  std::unique_ptr<RtpPacketToSend> SendGenericPacket() {
    201    // Use maximum allowed size to catch corner cases when packet is dropped
    202    // because of lack of capacity for the media packet, or for an rtx packet
    203    // containing the media packet.
    204    return SendPacket(/*capture_time=*/env_.clock().CurrentTime(),
    205                      /*payload_length=*/rtp_sender_->MaxRtpPacketSize() -
    206                          rtp_sender_->ExpectedPerPacketOverhead());
    207  }
    208 
    209  std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
    210      size_t target_size_bytes) {
    211    return rtp_sender_->GeneratePadding(
    212        target_size_bytes, /*media_has_been_sent=*/true,
    213        sequencer_->CanSendPaddingOnMediaSsrc());
    214  }
    215 
    216  std::vector<std::unique_ptr<RtpPacketToSend>> Sequence(
    217      std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    218    for (auto& packet : packets) {
    219      sequencer_->Sequence(*packet);
    220    }
    221    return packets;
    222  }
    223 
    224  size_t GenerateAndSendPadding(size_t target_size_bytes) {
    225    size_t generated_bytes = 0;
    226    std::vector<std::unique_ptr<RtpPacketToSend>> packets;
    227    for (auto& packet : GeneratePadding(target_size_bytes)) {
    228      generated_bytes += packet->payload_size() + packet->padding_size();
    229      packets.push_back(std::move(packet));
    230    }
    231    rtp_sender_->EnqueuePackets(std::move(packets));
    232    return generated_bytes;
    233  }
    234 
    235  // The following are helpers for configuring the RTPSender. They must be
    236  // called before sending any packets.
    237 
    238  // Enable the retransmission stream with sizable packet storage.
    239  void EnableRtx() {
    240    // RTX needs to be able to read the source packets from the packet store.
    241    // Pick a number of packets to store big enough for any unit test.
    242    constexpr uint16_t kNumberOfPacketsToStore = 100;
    243    packet_history_->SetStorePacketsStatus(
    244        RtpPacketHistory::StorageMode::kStoreAndCull, kNumberOfPacketsToStore);
    245    rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
    246    rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
    247  }
    248 
    249  // Enable sending of the MID header extension for both the primary SSRC and
    250  // the RTX SSRC.
    251  void EnableMidSending(absl::string_view mid) {
    252    rtp_sender_->RegisterRtpHeaderExtension(RtpMid::Uri(), kMidExtensionId);
    253    rtp_sender_->SetMid(mid);
    254  }
    255 
    256  // Enable sending of the RSID header extension for the primary SSRC and the
    257  // RRSID header extension for the RTX SSRC.
    258  void EnableRidSending() {
    259    rtp_sender_->RegisterRtpHeaderExtension(RtpStreamId::Uri(),
    260                                            kRidExtensionId);
    261    rtp_sender_->RegisterRtpHeaderExtension(RepairedRtpStreamId::Uri(),
    262                                            kRepairedRidExtensionId);
    263  }
    264 };
    265 
    266 TEST_F(RtpSenderTest, AllocatePacketSetCsrcs) {
    267  // Configure rtp_sender with csrc.
    268  uint32_t csrcs[] = {0x23456789};
    269 
    270  auto packet = rtp_sender_->AllocatePacket(csrcs);
    271 
    272  ASSERT_TRUE(packet);
    273  EXPECT_EQ(rtp_sender_->SSRC(), packet->Ssrc());
    274  EXPECT_THAT(packet->Csrcs(), ElementsAreArray(csrcs));
    275 }
    276 
    277 TEST_F(RtpSenderTest, AllocatePacketReserveExtensions) {
    278  // Configure rtp_sender with extensions.
    279  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    280      TransmissionOffset::Uri(), kTransmissionTimeOffsetExtensionId));
    281  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    282      AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
    283  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    284      AudioLevelExtension::Uri(), kAudioLevelExtensionId));
    285  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    286      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
    287  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    288      VideoOrientation::Uri(), kVideoRotationExtensionId));
    289 
    290  auto packet = rtp_sender_->AllocatePacket();
    291 
    292  ASSERT_TRUE(packet);
    293  // Preallocate BWE extensions RtpSender set itself.
    294  EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
    295  EXPECT_TRUE(packet->HasExtension<AbsoluteSendTime>());
    296  EXPECT_TRUE(packet->HasExtension<TransportSequenceNumber>());
    297  // Do not allocate media specific extensions.
    298  EXPECT_FALSE(packet->HasExtension<AudioLevelExtension>());
    299  EXPECT_FALSE(packet->HasExtension<VideoOrientation>());
    300 }
    301 
    302 TEST_F(RtpSenderTest, PaddingAlwaysAllowedOnAudio) {
    303  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    304  config.audio = true;
    305  CreateSender(config);
    306 
    307  std::unique_ptr<RtpPacketToSend> audio_packet = rtp_sender_->AllocatePacket();
    308  // Padding on audio stream allowed regardless of marker in the last packet.
    309  audio_packet->SetMarker(false);
    310  audio_packet->SetPayloadType(kPayload);
    311  sequencer_->Sequence(*audio_packet);
    312 
    313  const size_t kPaddingSize = 59;
    314 
    315  EXPECT_CALL(
    316      mock_paced_sender_,
    317      EnqueuePackets(ElementsAre(AllOf(
    318          Pointee(Property(&RtpPacketToSend::packet_type,
    319                           RtpPacketMediaType::kPadding)),
    320          Pointee(Property(&RtpPacketToSend::padding_size, kPaddingSize))))));
    321  EXPECT_EQ(kPaddingSize, GenerateAndSendPadding(kPaddingSize));
    322 
    323  // Requested padding size is too small, will send a larger one.
    324  const size_t kMinPaddingSize = 50;
    325  EXPECT_CALL(mock_paced_sender_,
    326              EnqueuePackets(ElementsAre(
    327                  AllOf(Pointee(Property(&RtpPacketToSend::packet_type,
    328                                         RtpPacketMediaType::kPadding)),
    329                        Pointee(Property(&RtpPacketToSend::padding_size,
    330                                         kMinPaddingSize))))));
    331  EXPECT_EQ(kMinPaddingSize, GenerateAndSendPadding(kMinPaddingSize - 5));
    332 }
    333 
    334 TEST_F(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) {
    335  std::vector<std::unique_ptr<RtpPacketToSend>> packets(1);
    336  packets[0] =
    337      BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, Timestamp::Zero());
    338  Timestamp now = env_.clock().CurrentTime();
    339 
    340  EXPECT_CALL(mock_paced_sender_,
    341              EnqueuePackets(ElementsAre(AllOf(
    342                  Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
    343                  Pointee(Property(&RtpPacketToSend::capture_time, now))))));
    344 
    345  rtp_sender_->EnqueuePackets(std::move(packets));
    346 }
    347 
    348 TEST_F(RtpSenderTest, ReSendPacketForwardsPacketsToPacer) {
    349  packet_history_->SetStorePacketsStatus(
    350      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
    351  Timestamp now = env_.clock().CurrentTime();
    352  auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, now);
    353  packet->SetSequenceNumber(kSeqNum);
    354  packet->set_allow_retransmission(true);
    355  packet_history_->PutRtpPacket(std::move(packet), now);
    356 
    357  EXPECT_CALL(mock_paced_sender_,
    358              EnqueuePackets(ElementsAre(AllOf(
    359                  Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
    360                  Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)),
    361                  Pointee(Property(&RtpPacketToSend::capture_time, now)),
    362                  Pointee(Property(&RtpPacketToSend::packet_type,
    363                                   RtpPacketMediaType::kRetransmission))))));
    364  EXPECT_TRUE(rtp_sender_->ReSendPacket(kSeqNum));
    365 }
    366 
    367 // This test sends 1 regular video packet, then 4 padding packets, and then
    368 // 1 more regular packet.
    369 TEST_F(RtpSenderTest, SendPadding) {
    370  constexpr int kNumPaddingPackets = 4;
    371  EXPECT_CALL(mock_paced_sender_, EnqueuePackets);
    372  std::unique_ptr<RtpPacketToSend> media_packet =
    373      SendPacket(/*capture_time=*/env_.clock().CurrentTime(),
    374                 /*payload_length=*/100);
    375  sequencer_->Sequence(*media_packet);
    376 
    377  // Wait 50 ms before generating each padding packet.
    378  for (int i = 0; i < kNumPaddingPackets; ++i) {
    379    time_controller_.AdvanceTime(TimeDelta::Millis(50));
    380    const size_t kPaddingTargetBytes = 100;  // Request 100 bytes of padding.
    381 
    382    // Padding should be sent on the media ssrc, with a continous sequence
    383    // number range. Size will be forced to full pack size and the timestamp
    384    // shall be that of the last media packet.
    385    EXPECT_CALL(mock_paced_sender_,
    386                EnqueuePackets(ElementsAre(Pointee(AllOf(
    387                    Property(&RtpPacketToSend::Ssrc, kSsrc),
    388                    Property(&RtpPacketToSend::padding_size, kMaxPaddingLength),
    389                    Property(&RtpPacketToSend::SequenceNumber,
    390                             media_packet->SequenceNumber() + i + 1),
    391                    Property(&RtpPacketToSend::Timestamp,
    392                             media_packet->Timestamp()))))));
    393    std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
    394        Sequence(GeneratePadding(kPaddingTargetBytes));
    395    ASSERT_THAT(padding_packets, SizeIs(1));
    396    rtp_sender_->EnqueuePackets(std::move(padding_packets));
    397  }
    398 
    399  // Send a regular video packet again.
    400  EXPECT_CALL(
    401      mock_paced_sender_,
    402      EnqueuePackets(ElementsAre(Pointee(Property(
    403          &RtpPacketToSend::Timestamp, Gt(media_packet->Timestamp()))))));
    404 
    405  std::unique_ptr<RtpPacketToSend> next_media_packet =
    406      SendPacket(/*capture_time=*/env_.clock().CurrentTime(),
    407                 /*payload_length=*/100);
    408 }
    409 
    410 TEST_F(RtpSenderTest, NoPaddingAsFirstPacketWithoutBweExtensions) {
    411  EXPECT_THAT(rtp_sender_->GeneratePadding(
    412                  /*target_size_bytes=*/100,
    413                  /*media_has_been_sent=*/false,
    414                  /*can_send_padding_on_media_ssrc=*/false),
    415              IsEmpty());
    416 
    417  // Don't send padding before media even with RTX.
    418  EnableRtx();
    419  EXPECT_THAT(rtp_sender_->GeneratePadding(
    420                  /*target_size_bytes=*/100,
    421                  /*media_has_been_sent=*/false,
    422                  /*can_send_padding_on_media_ssrc=*/false),
    423              IsEmpty());
    424 }
    425 
    426 TEST_F(RtpSenderTest, RequiresRtxSsrcToEnableRtx) {
    427  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    428  config.rtx_send_ssrc = std::nullopt;
    429  RTPSender rtp_sender(env_, config, packet_history_.get(),
    430                       config.paced_sender);
    431  rtp_sender.SetRtxPayloadType(kRtxPayload, kPayload);
    432 
    433  rtp_sender.SetRtxStatus(kRtxRetransmitted);
    434 
    435  EXPECT_EQ(rtp_sender.RtxStatus(), kRtxOff);
    436 }
    437 
    438 TEST_F(RtpSenderTest, RequiresRtxPayloadTypesToEnableRtx) {
    439  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    440  config.rtx_send_ssrc = kRtxSsrc;
    441  RTPSender rtp_sender(env_, config, packet_history_.get(),
    442                       config.paced_sender);
    443 
    444  rtp_sender.SetRtxStatus(kRtxRetransmitted);
    445 
    446  EXPECT_EQ(rtp_sender.RtxStatus(), kRtxOff);
    447 }
    448 
    449 TEST_F(RtpSenderTest, CanEnableRtxWhenRtxSsrcAndPayloadTypeAreConfigured) {
    450  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    451  config.rtx_send_ssrc = kRtxSsrc;
    452  RTPSender rtp_sender(env_, config, packet_history_.get(),
    453                       config.paced_sender);
    454  rtp_sender.SetRtxPayloadType(kRtxPayload, kPayload);
    455 
    456  ASSERT_EQ(rtp_sender.RtxStatus(), kRtxOff);
    457  rtp_sender.SetRtxStatus(kRtxRetransmitted);
    458 
    459  EXPECT_EQ(rtp_sender.RtxStatus(), kRtxRetransmitted);
    460 }
    461 
    462 TEST_F(RtpSenderTest, AllowPaddingAsFirstPacketOnRtxWithTransportCc) {
    463  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    464      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
    465 
    466  // Padding can't be sent as first packet on media SSRC since we don't know
    467  // what payload type to assign.
    468  EXPECT_THAT(rtp_sender_->GeneratePadding(
    469                  /*target_size_bytes=*/100,
    470                  /*media_has_been_sent=*/false,
    471                  /*can_send_padding_on_media_ssrc=*/false),
    472              IsEmpty());
    473 
    474  // With transportcc padding can be sent as first packet on the RTX SSRC.
    475  EnableRtx();
    476  EXPECT_THAT(rtp_sender_->GeneratePadding(
    477                  /*target_size_bytes=*/100,
    478                  /*media_has_been_sent=*/false,
    479                  /*can_send_padding_on_media_ssrc=*/false),
    480              Not(IsEmpty()));
    481 }
    482 
    483 TEST_F(RtpSenderTest, AllowPaddingAsFirstPacketOnRtxWithAbsSendTime) {
    484  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    485      AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
    486 
    487  // Padding can't be sent as first packet on media SSRC since we don't know
    488  // what payload type to assign.
    489  EXPECT_THAT(rtp_sender_->GeneratePadding(
    490                  /*target_size_bytes=*/100,
    491                  /*media_has_been_sent=*/false,
    492                  /*can_send_padding_on_media_ssrc=*/false),
    493              IsEmpty());
    494 
    495  // With abs send time, padding can be sent as first packet on the RTX SSRC.
    496  EnableRtx();
    497  EXPECT_THAT(rtp_sender_->GeneratePadding(
    498                  /*target_size_bytes=*/100,
    499                  /*media_has_been_sent=*/false,
    500                  /*can_send_padding_on_media_ssrc=*/false),
    501              Not(IsEmpty()));
    502 }
    503 
    504 TEST_F(RtpSenderTest, UpdatesTimestampsOnPlainRtxPadding) {
    505  EnableRtx();
    506  // Timestamps as set based on capture time in RtpSenderTest.
    507  const Timestamp start_time = env_.clock().CurrentTime();
    508  const uint32_t start_timestamp = ToRtpTimestamp(start_time);
    509 
    510  // Start by sending one media packet.
    511  EXPECT_CALL(
    512      mock_paced_sender_,
    513      EnqueuePackets(ElementsAre(AllOf(
    514          Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
    515          Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
    516          Pointee(Property(&RtpPacketToSend::capture_time, start_time))))));
    517  std::unique_ptr<RtpPacketToSend> media_packet =
    518      SendPacket(start_time, /*payload_length=*/600);
    519  sequencer_->Sequence(*media_packet);
    520 
    521  // Advance time before sending padding.
    522  const TimeDelta kTimeDiff = TimeDelta::Millis(17);
    523  time_controller_.AdvanceTime(kTimeDiff);
    524 
    525  // Timestamps on padding should be offset from the sent media.
    526  EXPECT_THAT(
    527      Sequence(GeneratePadding(/*target_size_bytes=*/100)),
    528      Each(Pointee(AllOf(
    529          Property(&RtpPacketToSend::padding_size, kMaxPaddingLength),
    530          Property(&RtpPacketToSend::Timestamp,
    531                   start_timestamp + kRtpClockRate * kTimeDiff),
    532          Property(&RtpPacketToSend::capture_time, start_time + kTimeDiff)))));
    533 }
    534 
    535 TEST_F(RtpSenderTest, KeepsTimestampsOnPayloadPadding) {
    536  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
    537      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
    538  EnableRtx();
    539  // Timestamps as set based on capture time in RtpSenderTest.
    540  const Timestamp start_time = env_.clock().CurrentTime();
    541  const uint32_t start_timestamp = ToRtpTimestamp(start_time);
    542  const size_t kPayloadSize = 200;
    543 
    544  // Start by sending one media packet and putting in the packet history.
    545  EXPECT_CALL(
    546      mock_paced_sender_,
    547      EnqueuePackets(ElementsAre(AllOf(
    548          Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
    549          Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
    550          Pointee(Property(&RtpPacketToSend::capture_time, start_time))))));
    551  std::unique_ptr<RtpPacketToSend> media_packet =
    552      SendPacket(start_time, kPayloadSize);
    553  packet_history_->PutRtpPacket(std::move(media_packet), start_time);
    554 
    555  // Advance time before sending padding.
    556  const TimeDelta kTimeDiff = TimeDelta::Millis(17);
    557  time_controller_.AdvanceTime(kTimeDiff);
    558 
    559  // Timestamps on payload padding should be set to original.
    560  EXPECT_THAT(
    561      GeneratePadding(/*target_size_bytes=*/100),
    562      Each(AllOf(
    563          Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
    564          Pointee(Property(&RtpPacketToSend::payload_size,
    565                           kPayloadSize + kRtxHeaderSize)),
    566          Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
    567          Pointee(Property(&RtpPacketToSend::capture_time, start_time)))));
    568 }
    569 
    570 // Test that the MID header extension is included on sent packets when
    571 // configured.
    572 TEST_F(RtpSenderTest, MidIncludedOnSentPackets) {
    573  EnableMidSending(kMid);
    574 
    575  // Send a couple packets, expect both packets to have the MID set.
    576  EXPECT_CALL(mock_paced_sender_,
    577              EnqueuePackets(ElementsAre(Pointee(
    578                  Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid)))))
    579      .Times(2);
    580  SendGenericPacket();
    581  SendGenericPacket();
    582 }
    583 
    584 TEST_F(RtpSenderTest, RidIncludedOnSentPackets) {
    585  EnableRidSending();
    586 
    587  EXPECT_CALL(mock_paced_sender_,
    588              EnqueuePackets(ElementsAre(Pointee(Property(
    589                  &RtpPacketToSend::GetExtension<RtpStreamId>, kRid)))));
    590  SendGenericPacket();
    591 }
    592 
    593 TEST_F(RtpSenderTest, RidIncludedOnRtxSentPackets) {
    594  EnableRtx();
    595  EnableRidSending();
    596 
    597  EXPECT_CALL(mock_paced_sender_,
    598              EnqueuePackets(ElementsAre(Pointee(AllOf(
    599                  Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid),
    600                  Property(&RtpPacketToSend::HasExtension<RepairedRtpStreamId>,
    601                           false))))))
    602      .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    603        sequencer_->Sequence(*packets[0]);
    604        packet_history_->PutRtpPacket(std::move(packets[0]),
    605                                      env_.clock().CurrentTime());
    606      });
    607  SendGenericPacket();
    608 
    609  EXPECT_CALL(
    610      mock_paced_sender_,
    611      EnqueuePackets(ElementsAre(Pointee(AllOf(
    612          Property(&RtpPacketToSend::GetExtension<RepairedRtpStreamId>, kRid),
    613          Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
    614  rtp_sender_->ReSendPacket(kSeqNum);
    615 }
    616 
    617 TEST_F(RtpSenderTest, MidAndRidNotIncludedOnSentPacketsAfterAck) {
    618  EnableMidSending(kMid);
    619  EnableRidSending();
    620 
    621  // This first packet should include both MID and RID.
    622  EXPECT_CALL(
    623      mock_paced_sender_,
    624      EnqueuePackets(ElementsAre(Pointee(AllOf(
    625          Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
    626          Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid))))));
    627  auto first_built_packet = SendGenericPacket();
    628  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
    629 
    630  // The second packet should include neither since an ack was received.
    631  EXPECT_CALL(
    632      mock_paced_sender_,
    633      EnqueuePackets(ElementsAre(Pointee(AllOf(
    634          Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
    635          Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
    636  SendGenericPacket();
    637 }
    638 
    639 TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnSentPacketsWhenConfigured) {
    640  SetUpRtpSender(false, /*always_send_mid_and_rid=*/true, nullptr);
    641  EnableMidSending(kMid);
    642  EnableRidSending();
    643 
    644  // Send two media packets: one before and one after the ack.
    645  // Due to the configuration, both sent packets should contain MID and RID.
    646  EXPECT_CALL(
    647      mock_paced_sender_,
    648      EnqueuePackets(ElementsAre(Pointee(
    649          AllOf(Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
    650                Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid))))))
    651      .Times(2);
    652  auto first_built_packet = SendGenericPacket();
    653  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
    654  SendGenericPacket();
    655 }
    656 
    657 // Test that the first RTX packet includes both MID and RRID even if the packet
    658 // being retransmitted did not have MID or RID. The MID and RID are needed on
    659 // the first packets for a given SSRC, and RTX packets are sent on a separate
    660 // SSRC.
    661 TEST_F(RtpSenderTest, MidAndRidIncludedOnFirstRtxPacket) {
    662  EnableRtx();
    663  EnableMidSending(kMid);
    664  EnableRidSending();
    665 
    666  // This first packet will include both MID and RID.
    667  EXPECT_CALL(mock_paced_sender_, EnqueuePackets);
    668  auto first_built_packet = SendGenericPacket();
    669  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
    670 
    671  // The second packet will include neither since an ack was received, put
    672  // it in the packet history for retransmission.
    673  EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
    674      .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    675        packet_history_->PutRtpPacket(std::move(packets[0]),
    676                                      env_.clock().CurrentTime());
    677      });
    678  auto second_built_packet = SendGenericPacket();
    679 
    680  // The first RTX packet should include MID and RRID.
    681  EXPECT_CALL(mock_paced_sender_,
    682              EnqueuePackets(ElementsAre(Pointee(AllOf(
    683                  Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
    684                  Property(&RtpPacketToSend::GetExtension<RepairedRtpStreamId>,
    685                           kRid))))));
    686  rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber());
    687 }
    688 
    689 // Test that the RTX packets sent after receving an ACK on the RTX SSRC does
    690 // not include either MID or RRID even if the packet being retransmitted did
    691 // had a MID or RID.
    692 TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
    693  EnableRtx();
    694  EnableMidSending(kMid);
    695  EnableRidSending();
    696 
    697  // This first packet will include both MID and RID.
    698  auto first_built_packet = SendGenericPacket();
    699  sequencer_->Sequence(*first_built_packet);
    700  packet_history_->PutRtpPacket(
    701      std::make_unique<RtpPacketToSend>(*first_built_packet),
    702      /*send_time=*/env_.clock().CurrentTime());
    703  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
    704 
    705  // The second packet will include neither since an ack was received.
    706  auto second_built_packet = SendGenericPacket();
    707  sequencer_->Sequence(*second_built_packet);
    708  packet_history_->PutRtpPacket(
    709      std::make_unique<RtpPacketToSend>(*second_built_packet),
    710      /*send_time=*/env_.clock().CurrentTime());
    711 
    712  // The first RTX packet will include MID and RRID.
    713  EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
    714      .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    715        rtp_sender_->OnReceivedAckOnRtxSsrc(packets[0]->SequenceNumber());
    716        packet_history_->MarkPacketAsSent(
    717            *packets[0]->retransmitted_sequence_number());
    718      });
    719  rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber());
    720 
    721  // The second and third RTX packets should not include MID nor RRID.
    722  EXPECT_CALL(mock_paced_sender_,
    723              EnqueuePackets(ElementsAre(Pointee(AllOf(
    724                  Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
    725                  Property(&RtpPacketToSend::HasExtension<RepairedRtpStreamId>,
    726                           false))))))
    727      .Times(2);
    728  rtp_sender_->ReSendPacket(first_built_packet->SequenceNumber());
    729  rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber());
    730 }
    731 
    732 TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnRtxPacketsWhenConfigured) {
    733  SetUpRtpSender(false, /*always_send_mid_and_rid=*/true, nullptr);
    734  EnableRtx();
    735  EnableMidSending(kMid);
    736  EnableRidSending();
    737 
    738  // Send two media packets: one before and one after the ack.
    739  EXPECT_CALL(
    740      mock_paced_sender_,
    741      EnqueuePackets(ElementsAre(Pointee(
    742          AllOf(Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
    743                Property(&RtpPacketToSend::GetExtension<RtpStreamId>, kRid))))))
    744      .Times(2)
    745      .WillRepeatedly(
    746          [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    747            packet_history_->PutRtpPacket(std::move(packets[0]),
    748                                          env_.clock().CurrentTime());
    749          });
    750  auto media_packet1 = SendGenericPacket();
    751  rtp_sender_->OnReceivedAckOnSsrc(media_packet1->SequenceNumber());
    752  auto media_packet2 = SendGenericPacket();
    753 
    754  // Send three RTX packets with different combinations of orders w.r.t. the
    755  // media and RTX acks.
    756  // Due to the configuration, all sent packets should contain MID
    757  // and either RID (media) or RRID (RTX).
    758  EXPECT_CALL(mock_paced_sender_,
    759              EnqueuePackets(ElementsAre(Pointee(AllOf(
    760                  Property(&RtpPacketToSend::GetExtension<RtpMid>, kMid),
    761                  Property(&RtpPacketToSend::GetExtension<RepairedRtpStreamId>,
    762                           kRid))))))
    763      .Times(3)
    764      .WillRepeatedly(
    765          [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    766            rtp_sender_->OnReceivedAckOnRtxSsrc(packets[0]->SequenceNumber());
    767            packet_history_->MarkPacketAsSent(
    768                *packets[0]->retransmitted_sequence_number());
    769          });
    770  rtp_sender_->ReSendPacket(media_packet2->SequenceNumber());
    771  rtp_sender_->ReSendPacket(media_packet1->SequenceNumber());
    772  rtp_sender_->ReSendPacket(media_packet2->SequenceNumber());
    773 }
    774 
    775 // Test that if the RtpState indicates an ACK has been received on that SSRC
    776 // then neither the MID nor RID header extensions will be sent.
    777 TEST_F(RtpSenderTest, MidAndRidNotIncludedOnSentPacketsAfterRtpStateRestored) {
    778  EnableMidSending(kMid);
    779  EnableRidSending();
    780 
    781  RtpState state = rtp_sender_->GetRtpState();
    782  EXPECT_FALSE(state.ssrc_has_acked);
    783  state.ssrc_has_acked = true;
    784  rtp_sender_->SetRtpState(state);
    785 
    786  EXPECT_CALL(
    787      mock_paced_sender_,
    788      EnqueuePackets(ElementsAre(Pointee(AllOf(
    789          Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
    790          Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
    791  SendGenericPacket();
    792 }
    793 
    794 // Test that if the RTX RtpState indicates an ACK has been received on that
    795 // RTX SSRC then neither the MID nor RRID header extensions will be sent on
    796 // RTX packets.
    797 TEST_F(RtpSenderTest, MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored) {
    798  EnableRtx();
    799  EnableMidSending(kMid);
    800  EnableRidSending();
    801 
    802  RtpState rtx_state = rtp_sender_->GetRtxRtpState();
    803  EXPECT_FALSE(rtx_state.ssrc_has_acked);
    804  rtx_state.ssrc_has_acked = true;
    805  rtp_sender_->SetRtxRtpState(rtx_state);
    806 
    807  EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
    808      .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    809        packet_history_->PutRtpPacket(std::move(packets[0]),
    810                                      env_.clock().CurrentTime());
    811      });
    812  auto built_packet = SendGenericPacket();
    813 
    814  EXPECT_CALL(
    815      mock_paced_sender_,
    816      EnqueuePackets(ElementsAre(Pointee(AllOf(
    817          Property(&RtpPacketToSend::HasExtension<RtpMid>, false),
    818          Property(&RtpPacketToSend::HasExtension<RtpStreamId>, false))))));
    819  ASSERT_LT(0, rtp_sender_->ReSendPacket(built_packet->SequenceNumber()));
    820 }
    821 
    822 TEST_F(RtpSenderTest, RespectsNackBitrateLimit) {
    823  const int32_t kPacketSize = 1400;
    824  const int32_t kNumPackets = 30;
    825  retransmission_rate_limiter_.SetMaxRate(kPacketSize * kNumPackets * 8);
    826  EnableRtx();
    827 
    828  std::vector<uint16_t> sequence_numbers;
    829  for (int32_t i = 0; i < kNumPackets; ++i) {
    830    std::unique_ptr<RtpPacketToSend> packet =
    831        BuildRtpPacket(kPayload, /*marker_bit=*/true, /*rtp_timestamp=*/0,
    832                       /*capture_time=*/env_.clock().CurrentTime());
    833    packet->set_allow_retransmission(true);
    834    sequencer_->Sequence(*packet);
    835    sequence_numbers.push_back(packet->SequenceNumber());
    836    packet_history_->PutRtpPacket(std::move(packet),
    837                                  /*send_time=*/env_.clock().CurrentTime());
    838    time_controller_.AdvanceTime(TimeDelta::Millis(1));
    839  }
    840 
    841  time_controller_.AdvanceTime(TimeDelta::Millis(1000 - kNumPackets));
    842 
    843  // Resending should work - brings the bandwidth up to the limit.
    844  // NACK bitrate is capped to the same bitrate as the encoder, since the max
    845  // protection overhead is 50% (see MediaOptimization::SetTargetRates).
    846  EXPECT_CALL(mock_paced_sender_, EnqueuePackets(ElementsAre(Pointee(Property(
    847                                      &RtpPacketToSend::packet_type,
    848                                      RtpPacketMediaType::kRetransmission)))))
    849      .Times(kNumPackets)
    850      .WillRepeatedly(
    851          [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
    852            for (const auto& packet : packets) {
    853              packet_history_->MarkPacketAsSent(
    854                  *packet->retransmitted_sequence_number());
    855            }
    856          });
    857  rtp_sender_->OnReceivedNack(sequence_numbers, 0);
    858 
    859  // Must be at least 5ms in between retransmission attempts.
    860  time_controller_.AdvanceTime(TimeDelta::Millis(5));
    861 
    862  // Resending should not work, bandwidth exceeded.
    863  EXPECT_CALL(mock_paced_sender_, EnqueuePackets).Times(0);
    864  rtp_sender_->OnReceivedNack(sequence_numbers, 0);
    865 }
    866 
    867 TEST_F(RtpSenderTest, UpdatingCsrcsUpdatedOverhead) {
    868  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    869  config.rtx_send_ssrc = {};
    870  CreateSender(config);
    871 
    872  // Base RTP overhead is 12B.
    873  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    874 
    875  // Using packet with two csrcs adds 2*4 bytes to the header.
    876  uint32_t csrcs[] = {1, 2};
    877  rtp_sender_->AllocatePacket(csrcs);
    878  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 20u);
    879 }
    880 
    881 TEST_F(RtpSenderTest, OnOverheadChanged) {
    882  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    883  config.rtx_send_ssrc = {};
    884  CreateSender(config);
    885 
    886  // Base RTP overhead is 12B.
    887  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    888 
    889  rtp_sender_->RegisterRtpHeaderExtension(TransmissionOffset::Uri(),
    890                                          kTransmissionTimeOffsetExtensionId);
    891 
    892  // TransmissionTimeOffset extension has a size of 3B, but with the addition
    893  // of header index and rounding to 4 byte boundary we end up with 20B total.
    894  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 20u);
    895 }
    896 
    897 TEST_F(RtpSenderTest, CountMidOnlyUntilAcked) {
    898  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    899  config.rtx_send_ssrc = {};
    900  CreateSender(config);
    901 
    902  // Base RTP overhead is 12B.
    903  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    904 
    905  rtp_sender_->RegisterRtpHeaderExtension(RtpMid::Uri(), kMidExtensionId);
    906 
    907  // Counted only if set.
    908  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    909  rtp_sender_->SetMid("foo");
    910  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 36u);
    911  rtp_sender_->RegisterRtpHeaderExtension(RtpStreamId::Uri(), kRidExtensionId);
    912  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 52u);
    913 
    914  // Ack received, mid/rid no longer sent.
    915  rtp_sender_->OnReceivedAckOnSsrc(0);
    916  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    917 }
    918 
    919 TEST_F(RtpSenderTest, CountMidRidRridUntilAcked) {
    920  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    921  CreateSender(config);
    922 
    923  // Base RTP overhead is 12B and we use RTX which has an additional 2 bytes
    924  // overhead.
    925  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 14u);
    926 
    927  rtp_sender_->RegisterRtpHeaderExtension(RtpMid::Uri(), kMidExtensionId);
    928 
    929  // Counted only if set.
    930  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 14u);
    931  rtp_sender_->SetMid("foo");
    932  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 38u);
    933 
    934  rtp_sender_->RegisterRtpHeaderExtension(RtpStreamId::Uri(), kRidExtensionId);
    935  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 54u);
    936 
    937  // mid/rrid may be shared with mid/rid when both are active.
    938  rtp_sender_->RegisterRtpHeaderExtension(RepairedRtpStreamId::Uri(),
    939                                          kRepairedRidExtensionId);
    940  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 54u);
    941 
    942  // Ack received, mid/rid no longer sent but we still need space for
    943  // mid/rrid which can no longer be shared with mid/rid.
    944  rtp_sender_->OnReceivedAckOnSsrc(0);
    945  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 54u);
    946 
    947  // Ack received for RTX, no need to send RRID anymore.
    948  rtp_sender_->OnReceivedAckOnRtxSsrc(0);
    949  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 14u);
    950 }
    951 
    952 TEST_F(RtpSenderTest, DontCountVolatileExtensionsIntoOverhead) {
    953  RtpRtcpInterface::Configuration config = GetDefaultConfig();
    954  config.rtx_send_ssrc = {};
    955  CreateSender(config);
    956 
    957  // Base RTP overhead is 12B.
    958  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    959 
    960  rtp_sender_->RegisterRtpHeaderExtension(InbandComfortNoiseExtension::Uri(),
    961                                          1);
    962  rtp_sender_->RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::Uri(),
    963                                          2);
    964  rtp_sender_->RegisterRtpHeaderExtension(VideoOrientation::Uri(), 3);
    965  rtp_sender_->RegisterRtpHeaderExtension(PlayoutDelayLimits::Uri(), 4);
    966  rtp_sender_->RegisterRtpHeaderExtension(VideoContentTypeExtension::Uri(), 5);
    967  rtp_sender_->RegisterRtpHeaderExtension(VideoTimingExtension::Uri(), 6);
    968  rtp_sender_->RegisterRtpHeaderExtension(RepairedRtpStreamId::Uri(), 7);
    969  rtp_sender_->RegisterRtpHeaderExtension(ColorSpaceExtension::Uri(), 8);
    970 
    971  // Still only 12B counted since can't count on above being sent.
    972  EXPECT_EQ(rtp_sender_->ExpectedPerPacketOverhead(), 12u);
    973 }
    974 
    975 TEST_F(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
    976  packet_history_->SetStorePacketsStatus(
    977      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
    978 
    979  // Ignore calls to EnqueuePackets() for this test.
    980  EXPECT_CALL(mock_paced_sender_, EnqueuePackets).WillRepeatedly(Return());
    981 
    982  // Build a media packet and put in the packet history.
    983  std::unique_ptr<RtpPacketToSend> packet =
    984      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
    985  const uint16_t media_sequence_number = packet->SequenceNumber();
    986  packet->set_allow_retransmission(true);
    987  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
    988 
    989  // Simulate successful retransmission request.
    990  time_controller_.AdvanceTime(TimeDelta::Millis(30));
    991  EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Gt(0));
    992 
    993  // Packet already pending, retransmission not allowed.
    994  time_controller_.AdvanceTime(TimeDelta::Millis(30));
    995  EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Eq(0));
    996 
    997  // Simulate packet exiting pacer, mark as not longer pending.
    998  packet_history_->MarkPacketAsSent(media_sequence_number);
    999 
   1000  // Retransmissions allowed again.
   1001  time_controller_.AdvanceTime(TimeDelta::Millis(30));
   1002  EXPECT_THAT(rtp_sender_->ReSendPacket(media_sequence_number), Gt(0));
   1003 }
   1004 
   1005 TEST_F(RtpSenderTest, MarksRetransmittedPackets) {
   1006  packet_history_->SetStorePacketsStatus(
   1007      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
   1008 
   1009  // Build a media packet and put in the packet history.
   1010  std::unique_ptr<RtpPacketToSend> packet =
   1011      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
   1012  const uint32_t kMediaSsrc = 567;
   1013  const uint16_t kMediaSequenceNumber = 123;
   1014  packet->SetSsrc(kMediaSsrc);
   1015  packet->SetSequenceNumber(kMediaSequenceNumber);
   1016  packet->set_allow_retransmission(true);
   1017  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
   1018 
   1019  // Expect a retransmission packet marked with which packet it is a
   1020  // retransmit of.
   1021  EXPECT_CALL(
   1022      mock_paced_sender_,
   1023      EnqueuePackets(ElementsAre(AllOf(
   1024          Pointee(Property(&RtpPacketToSend::packet_type,
   1025                           RtpPacketMediaType::kRetransmission)),
   1026          Pointee(Property(&RtpPacketToSend::original_ssrc, kMediaSsrc)),
   1027          Pointee(Property(&RtpPacketToSend::retransmitted_sequence_number,
   1028                           Eq(kMediaSequenceNumber)))))));
   1029  EXPECT_THAT(rtp_sender_->ReSendPacket(kMediaSequenceNumber), Gt(0));
   1030 }
   1031 
   1032 TEST_F(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
   1033  // Min requested size in order to use RTX payload.
   1034  const size_t kMinPaddingSize = 50;
   1035  EnableRtx();
   1036 
   1037  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1038      TransmissionOffset::Uri(), kTransmissionTimeOffsetExtensionId));
   1039  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1040      AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
   1041  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1042      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
   1043 
   1044  // Put a packet in the history, in order to facilitate payload padding.
   1045  std::unique_ptr<RtpPacketToSend> packet =
   1046      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
   1047  packet->set_allow_retransmission(true);
   1048  packet->SetPayloadSize(kMinPaddingSize);
   1049  packet->set_packet_type(RtpPacketMediaType::kVideo);
   1050  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
   1051 
   1052  // Generate a plain padding packet, check that extensions are registered.
   1053  std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
   1054      GeneratePadding(/*target_size_bytes=*/1);
   1055  ASSERT_THAT(generated_packets, SizeIs(1));
   1056  auto& plain_padding = generated_packets.front();
   1057  EXPECT_GT(plain_padding->padding_size(), 0u);
   1058  EXPECT_TRUE(plain_padding->HasExtension<TransportSequenceNumber>());
   1059  EXPECT_TRUE(plain_padding->HasExtension<AbsoluteSendTime>());
   1060  EXPECT_TRUE(plain_padding->HasExtension<TransmissionOffset>());
   1061  EXPECT_GT(plain_padding->padding_size(), 0u);
   1062 
   1063  // Generate a payload padding packets, check that extensions are registered.
   1064  generated_packets = GeneratePadding(kMinPaddingSize);
   1065  ASSERT_EQ(generated_packets.size(), 1u);
   1066  auto& payload_padding = generated_packets.front();
   1067  EXPECT_EQ(payload_padding->padding_size(), 0u);
   1068  EXPECT_TRUE(payload_padding->HasExtension<TransportSequenceNumber>());
   1069  EXPECT_TRUE(payload_padding->HasExtension<AbsoluteSendTime>());
   1070  EXPECT_TRUE(payload_padding->HasExtension<TransmissionOffset>());
   1071  EXPECT_GT(payload_padding->payload_size(), 0u);
   1072 }
   1073 
   1074 TEST_F(RtpSenderTest, GeneratedPaddingHasMidRidExtensions) {
   1075  EnableMidSending("mid");
   1076  EnableRidSending();
   1077 
   1078  // Send a dummy video packet so it ends up in the packet history. Since we
   1079  // are not using RTX, it should never be used as padding.
   1080  packet_history_->SetStorePacketsStatus(
   1081      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
   1082  std::unique_ptr<RtpPacketToSend> packet =
   1083      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
   1084  packet->set_allow_retransmission(true);
   1085  packet->SetPayloadSize(1234);
   1086  packet->set_packet_type(RtpPacketMediaType::kVideo);
   1087  sequencer_->Sequence(*packet);
   1088  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
   1089 
   1090  std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
   1091      GeneratePadding(/*target_size_bytes=*/1);
   1092  ASSERT_THAT(padding_packets, SizeIs(1));
   1093 
   1094  EXPECT_TRUE(padding_packets[0]->HasExtension<RtpMid>());
   1095  EXPECT_TRUE(padding_packets[0]->HasExtension<RtpStreamId>());
   1096 }
   1097 
   1098 TEST_F(RtpSenderTest, GeneratedPaddingOnRtxHasMidRidExtensions) {
   1099  EnableRtx();
   1100  EnableMidSending("mid");
   1101  EnableRidSending();
   1102 
   1103  std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
   1104      GeneratePadding(/*target_size_bytes=*/1);
   1105  ASSERT_THAT(padding_packets, SizeIs(1));
   1106 
   1107  EXPECT_TRUE(padding_packets[0]->HasExtension<RtpMid>());
   1108  EXPECT_TRUE(padding_packets[0]->HasExtension<RepairedRtpStreamId>());
   1109 }
   1110 
   1111 TEST_F(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
   1112  // Min requested size in order to use RTX payload.
   1113  const size_t kMinPaddingSize = 50;
   1114 
   1115  rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
   1116  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
   1117  packet_history_->SetStorePacketsStatus(
   1118      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
   1119 
   1120  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1121      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
   1122 
   1123  const size_t kPayloadPacketSize = kMinPaddingSize;
   1124  std::unique_ptr<RtpPacketToSend> packet =
   1125      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
   1126  packet->set_allow_retransmission(true);
   1127  packet->SetPayloadSize(kPayloadPacketSize);
   1128  packet->set_packet_type(RtpPacketMediaType::kVideo);
   1129  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
   1130 
   1131  // Generated padding has large enough budget that the video packet should be
   1132  // retransmitted as padding.
   1133  std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
   1134      GeneratePadding(kMinPaddingSize);
   1135  ASSERT_EQ(generated_packets.size(), 1u);
   1136  auto& padding_packet = generated_packets.front();
   1137  EXPECT_EQ(padding_packet->packet_type(), RtpPacketMediaType::kPadding);
   1138  EXPECT_EQ(padding_packet->Ssrc(), kRtxSsrc);
   1139  EXPECT_EQ(padding_packet->payload_size(),
   1140            kPayloadPacketSize + kRtxHeaderSize);
   1141 
   1142  // Not enough budged for payload padding, use plain padding instead.
   1143  const size_t kPaddingBytesRequested = kMinPaddingSize - 1;
   1144 
   1145  size_t padding_bytes_generated = 0;
   1146  generated_packets = GeneratePadding(kPaddingBytesRequested);
   1147  EXPECT_EQ(generated_packets.size(), 1u);
   1148  for (auto& generated_packet : generated_packets) {
   1149    EXPECT_EQ(generated_packet->packet_type(), RtpPacketMediaType::kPadding);
   1150    EXPECT_EQ(generated_packet->Ssrc(), kRtxSsrc);
   1151    EXPECT_EQ(generated_packet->payload_size(), 0u);
   1152    EXPECT_GT(generated_packet->padding_size(), 0u);
   1153    padding_bytes_generated += generated_packet->padding_size();
   1154  }
   1155 
   1156  EXPECT_EQ(padding_bytes_generated, kMaxPaddingLength);
   1157 }
   1158 
   1159 TEST_F(RtpSenderTest, LimitsPayloadPaddingSize) {
   1160  // RTX payload padding is limited to 3x target size.
   1161  const double kFactor = 3.0;
   1162  SetUpRtpSender(false, false, nullptr);
   1163  rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
   1164  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
   1165  packet_history_->SetStorePacketsStatus(
   1166      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
   1167 
   1168  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1169      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
   1170 
   1171  // Send a dummy video packet so it ends up in the packet history.
   1172  const size_t kPayloadPacketSize = 1234u;
   1173  std::unique_ptr<RtpPacketToSend> packet =
   1174      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
   1175  packet->set_allow_retransmission(true);
   1176  packet->SetPayloadSize(kPayloadPacketSize);
   1177  packet->set_packet_type(RtpPacketMediaType::kVideo);
   1178  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
   1179 
   1180  // Smallest target size that will result in the sent packet being returned as
   1181  // padding.
   1182  const size_t kMinTargerSizeForPayload =
   1183      (kPayloadPacketSize + kRtxHeaderSize) / kFactor;
   1184 
   1185  // Generated padding has large enough budget that the video packet should be
   1186  // retransmitted as padding.
   1187  EXPECT_THAT(
   1188      GeneratePadding(kMinTargerSizeForPayload),
   1189      AllOf(Not(IsEmpty()),
   1190            Each(Pointee(Property(&RtpPacketToSend::padding_size, Eq(0u))))));
   1191 
   1192  // If payload padding is > 2x requested size, plain padding is returned
   1193  // instead.
   1194  EXPECT_THAT(
   1195      GeneratePadding(kMinTargerSizeForPayload - 1),
   1196      AllOf(Not(IsEmpty()),
   1197            Each(Pointee(Property(&RtpPacketToSend::padding_size, Gt(0u))))));
   1198 }
   1199 
   1200 TEST_F(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
   1201  packet_history_->SetStorePacketsStatus(
   1202      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
   1203  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1204      TransmissionOffset::Uri(), kTransmissionTimeOffsetExtensionId));
   1205  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1206      AbsoluteSendTime::Uri(), kAbsoluteSendTimeExtensionId));
   1207  ASSERT_TRUE(rtp_sender_->RegisterRtpHeaderExtension(
   1208      TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
   1209 
   1210  const size_t kPayloadPacketSize = 1234;
   1211  // Send a dummy video packet so it ends up in the packet history. Since we
   1212  // are not using RTX, it should never be used as padding.
   1213  std::unique_ptr<RtpPacketToSend> packet =
   1214      BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
   1215  packet->set_allow_retransmission(true);
   1216  packet->SetPayloadSize(kPayloadPacketSize);
   1217  packet->set_packet_type(RtpPacketMediaType::kVideo);
   1218  sequencer_->Sequence(*packet);
   1219  packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
   1220 
   1221  // Payload padding not available without RTX, only generate plain padding on
   1222  // the media SSRC.
   1223  // Number of padding packets is the requested padding size divided by max
   1224  // padding packet size, rounded up. Pure padding packets are always of the
   1225  // maximum size.
   1226  const size_t kPaddingBytesRequested = kPayloadPacketSize + kRtxHeaderSize;
   1227  const size_t kExpectedNumPaddingPackets =
   1228      (kPaddingBytesRequested + kMaxPaddingLength - 1) / kMaxPaddingLength;
   1229  size_t padding_bytes_generated = 0;
   1230  std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
   1231      GeneratePadding(kPaddingBytesRequested);
   1232  EXPECT_EQ(padding_packets.size(), kExpectedNumPaddingPackets);
   1233  for (auto& generated_packet : padding_packets) {
   1234    EXPECT_EQ(generated_packet->packet_type(), RtpPacketMediaType::kPadding);
   1235    EXPECT_EQ(generated_packet->Ssrc(), kSsrc);
   1236    EXPECT_EQ(generated_packet->payload_size(), 0u);
   1237    EXPECT_GT(generated_packet->padding_size(), 0u);
   1238    padding_bytes_generated += generated_packet->padding_size();
   1239    EXPECT_TRUE(generated_packet->HasExtension<TransportSequenceNumber>());
   1240    EXPECT_TRUE(generated_packet->HasExtension<AbsoluteSendTime>());
   1241    EXPECT_TRUE(generated_packet->HasExtension<TransmissionOffset>());
   1242  }
   1243 
   1244  EXPECT_EQ(padding_bytes_generated,
   1245            kExpectedNumPaddingPackets * kMaxPaddingLength);
   1246 }
   1247 
   1248 TEST_F(RtpSenderTest, SupportsPadding) {
   1249  bool kSendingMediaStats[] = {true, false};
   1250  bool kEnableRedundantPayloads[] = {true, false};
   1251  absl::string_view kBweExtensionUris[] = {
   1252      TransportSequenceNumber::Uri(), TransportSequenceNumberV2::Uri(),
   1253      AbsoluteSendTime::Uri(), TransmissionOffset::Uri()};
   1254  const int kExtensionsId = 7;
   1255 
   1256  for (bool sending_media : kSendingMediaStats) {
   1257    rtp_sender_->SetSendingMediaStatus(sending_media);
   1258    for (bool redundant_payloads : kEnableRedundantPayloads) {
   1259      int rtx_mode = kRtxRetransmitted;
   1260      if (redundant_payloads) {
   1261        rtx_mode |= kRtxRedundantPayloads;
   1262      }
   1263      rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
   1264      rtp_sender_->SetRtxStatus(rtx_mode);
   1265 
   1266      for (auto extension_uri : kBweExtensionUris) {
   1267        EXPECT_FALSE(rtp_sender_->SupportsPadding());
   1268        rtp_sender_->RegisterRtpHeaderExtension(extension_uri, kExtensionsId);
   1269        if (!sending_media) {
   1270          EXPECT_FALSE(rtp_sender_->SupportsPadding());
   1271        } else {
   1272          EXPECT_TRUE(rtp_sender_->SupportsPadding());
   1273          if (redundant_payloads) {
   1274            EXPECT_TRUE(rtp_sender_->SupportsRtxPayloadPadding());
   1275          } else {
   1276            EXPECT_FALSE(rtp_sender_->SupportsRtxPayloadPadding());
   1277          }
   1278        }
   1279        rtp_sender_->DeregisterRtpHeaderExtension(extension_uri);
   1280        EXPECT_FALSE(rtp_sender_->SupportsPadding());
   1281      }
   1282    }
   1283  }
   1284 }
   1285 
   1286 TEST_F(RtpSenderTest, SetsCaptureTimeOnRtxRetransmissions) {
   1287  EnableRtx();
   1288 
   1289  // Put a packet in the packet history, with current time as capture time.
   1290  const Timestamp start_time = env_.clock().CurrentTime();
   1291  std::unique_ptr<RtpPacketToSend> packet =
   1292      BuildRtpPacket(kPayload, kMarkerBit, /*rtp_timestamp=*/0,
   1293                     /*capture_time=*/start_time);
   1294  packet->set_allow_retransmission(true);
   1295  sequencer_->Sequence(*packet);
   1296  packet_history_->PutRtpPacket(std::move(packet), start_time);
   1297 
   1298  // Advance time, request an RTX retransmission. Capture timestamp should be
   1299  // preserved.
   1300  time_controller_.AdvanceTime(TimeDelta::Millis(10));
   1301 
   1302  EXPECT_CALL(mock_paced_sender_,
   1303              EnqueuePackets(ElementsAre(Pointee(
   1304                  Property(&RtpPacketToSend::capture_time, start_time)))));
   1305  EXPECT_GT(rtp_sender_->ReSendPacket(kSeqNum), 0);
   1306 }
   1307 
   1308 TEST_F(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
   1309  const TimeDelta kRtt = TimeDelta::Millis(10);
   1310 
   1311  EnableRtx();
   1312  packet_history_->SetRtt(kRtt);
   1313 
   1314  // Put a packet in the history.
   1315  const Timestamp start_time = env_.clock().CurrentTime();
   1316  std::unique_ptr<RtpPacketToSend> packet =
   1317      BuildRtpPacket(kPayload, kMarkerBit, 0, /*capture_time=*/start_time);
   1318  packet->set_allow_retransmission(true);
   1319  sequencer_->Sequence(*packet);
   1320  packet_history_->PutRtpPacket(std::move(packet), start_time);
   1321 
   1322  // Disable media sending and try to retransmit the packet, it should fail.
   1323  rtp_sender_->SetSendingMediaStatus(false);
   1324  time_controller_.AdvanceTime(kRtt);
   1325  EXPECT_LT(rtp_sender_->ReSendPacket(kSeqNum), 0);
   1326 }
   1327 
   1328 TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
   1329  // Set up retranmission without RTX, so that a plain copy of the old packet is
   1330  // re-sent instead.
   1331  const TimeDelta kRtt = TimeDelta::Millis(10);
   1332  rtp_sender_->SetSendingMediaStatus(true);
   1333  rtp_sender_->SetRtxStatus(kRtxOff);
   1334  packet_history_->SetStorePacketsStatus(
   1335      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
   1336  packet_history_->SetRtt(kRtt);
   1337 
   1338  // Put a fec protected packet in the history.
   1339  const Timestamp start_time = env_.clock().CurrentTime();
   1340  std::unique_ptr<RtpPacketToSend> packet =
   1341      BuildRtpPacket(kPayload, kMarkerBit, 0, start_time);
   1342  packet->set_allow_retransmission(true);
   1343  packet->set_fec_protect_packet(true);
   1344  sequencer_->Sequence(*packet);
   1345  packet_history_->PutRtpPacket(std::move(packet), start_time);
   1346 
   1347  // Re-send packet, the retransmitted packet should not have the FEC protection
   1348  // flag set.
   1349  EXPECT_CALL(mock_paced_sender_,
   1350              EnqueuePackets(ElementsAre(Pointee(
   1351                  Property(&RtpPacketToSend::fec_protect_packet, false)))));
   1352 
   1353  time_controller_.AdvanceTime(kRtt);
   1354  EXPECT_GT(rtp_sender_->ReSendPacket(kSeqNum), 0);
   1355 }
   1356 
   1357 TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) {
   1358  RTPSenderVideo::Config video_config;
   1359  video_config.clock = &env_.clock();
   1360  video_config.rtp_sender = rtp_sender_.get();
   1361  video_config.field_trials = &env_.field_trials();
   1362  RTPSenderVideo rtp_sender_video(video_config);
   1363 
   1364  const uint8_t kPayloadType = 127;
   1365  const std::optional<VideoCodecType> kCodecType =
   1366      VideoCodecType::kVideoCodecGeneric;
   1367 
   1368  const uint32_t kCaptureTimeMsToRtpTimestamp = 90;  // 90 kHz clock
   1369 
   1370  {
   1371    EXPECT_CALL(mock_paced_sender_,
   1372                EnqueuePackets(Each(
   1373                    Pointee(Property(&RtpPacketToSend::is_key_frame, true)))))
   1374        .Times(AtLeast(1));
   1375    RTPVideoHeader video_header;
   1376    video_header.frame_type = VideoFrameType::kVideoFrameKey;
   1377    Timestamp capture_time = env_.clock().CurrentTime();
   1378    EXPECT_TRUE(rtp_sender_video.SendVideo(
   1379        kPayloadType, kCodecType,
   1380        capture_time.ms() * kCaptureTimeMsToRtpTimestamp, capture_time,
   1381        kPayloadData, sizeof(kPayloadData), video_header,
   1382        kDefaultExpectedRetransmissionTime, {}));
   1383 
   1384    time_controller_.AdvanceTime(TimeDelta::Millis(33));
   1385  }
   1386 
   1387  {
   1388    EXPECT_CALL(mock_paced_sender_,
   1389                EnqueuePackets(Each(
   1390                    Pointee(Property(&RtpPacketToSend::is_key_frame, false)))))
   1391        .Times(AtLeast(1));
   1392    RTPVideoHeader video_header;
   1393    video_header.frame_type = VideoFrameType::kVideoFrameDelta;
   1394    Timestamp capture_time = env_.clock().CurrentTime();
   1395    EXPECT_TRUE(rtp_sender_video.SendVideo(
   1396        kPayloadType, kCodecType,
   1397        capture_time.ms() * kCaptureTimeMsToRtpTimestamp, capture_time,
   1398        kPayloadData, sizeof(kPayloadData), video_header,
   1399        kDefaultExpectedRetransmissionTime, {}));
   1400 
   1401    time_controller_.AdvanceTime(TimeDelta::Millis(33));
   1402  }
   1403 }
   1404 
   1405 }  // namespace webrtc
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE