[ tor-browser ].git.dasho

packet_router_unittest.cc (32248B)
      1 /*
      2 *  Copyright (c) 2015 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/pacing/packet_router.h"
     12 
     13 #include <cstddef>
     14 #include <cstdint>
     15 #include <memory>
     16 #include <optional>
     17 #include <utility>
     18 #include <vector>
     19 
     20 #include "api/rtp_headers.h"
     21 #include "api/transport/network_types.h"
     22 #include "api/units/data_size.h"
     23 #include "api/units/time_delta.h"
     24 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
     25 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
     26 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
     27 #include "modules/rtp_rtcp/source/rtcp_packet.h"
     28 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
     29 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
     30 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
     31 #include "rtc_base/checks.h"
     32 #include "rtc_base/fake_clock.h"
     33 #include "test/gmock.h"
     34 #include "test/gtest.h"
     35 
     36 namespace webrtc {
     37 
     38 // TODO(eladalon): Restructure and/or replace the existing monolithic tests
     39 // (only some of the test are monolithic) according to the new
     40 // guidelines - small tests for one thing at a time.
     41 // (I'm not removing any tests during CL, so as to demonstrate no regressions.)
     42 
     43 namespace {
     44 
     45 using ::testing::_;
     46 using ::testing::ElementsAreArray;
     47 using ::testing::InSequence;
     48 using ::testing::MockFunction;
     49 using ::testing::NiceMock;
     50 using ::testing::Pointee;
     51 using ::testing::Property;
     52 using ::testing::Return;
     53 
     54 constexpr int kProbeMinProbes = 5;
     55 constexpr int kProbeMinBytes = 1000;
     56 
     57 }  // namespace
     58 
     59 class PacketRouterTest : public ::testing::Test {
     60 public:
     61  PacketRouterTest() {
     62    extension_manager.Register<TransportSequenceNumber>(/*id=*/1);
     63  }
     64 
     65 protected:
     66  std::unique_ptr<RtpPacketToSend> BuildRtpPacket(uint32_t ssrc) {
     67    std::unique_ptr<RtpPacketToSend> packet =
     68        std::make_unique<RtpPacketToSend>(&extension_manager);
     69    packet->SetSsrc(ssrc);
     70    return packet;
     71  }
     72 
     73  PacketRouter packet_router_;
     74  RtpHeaderExtensionMap extension_manager;
     75 };
     76 
     77 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_GeneratePadding) {
     78  constexpr DataSize bytes = DataSize::Bytes(300);
     79  const PacedPacketInfo paced_info(1, kProbeMinProbes, kProbeMinBytes);
     80 
     81  EXPECT_TRUE(packet_router_.GeneratePadding(bytes).empty());
     82 }
     83 
     84 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_SendRemb) {
     85  const std::vector<uint32_t> ssrcs = {1, 2, 3};
     86  constexpr uint32_t bitrate_bps = 10000;
     87  // Expect not to crash
     88  packet_router_.SendRemb(bitrate_bps, ssrcs);
     89 }
     90 
     91 TEST_F(PacketRouterTest, Sanity_NoModuleRegistered_SendTransportFeedback) {
     92  std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback;
     93  feedback.push_back(std::make_unique<rtcp::TransportFeedback>());
     94  // Expect not to crash
     95  packet_router_.SendCombinedRtcpPacket(std::move(feedback));
     96 }
     97 
     98 TEST_F(PacketRouterTest, GeneratePaddingPrioritizesRtx) {
     99  // Two RTP modules. The first (prioritized due to rtx) isn't sending media so
    100  // should not be called.
    101  const uint16_t kSsrc1 = 1234;
    102  const uint16_t kSsrc2 = 4567;
    103 
    104  NiceMock<MockRtpRtcpInterface> rtp_1;
    105  ON_CALL(rtp_1, RtxSendStatus()).WillByDefault(Return(kRtxRedundantPayloads));
    106  ON_CALL(rtp_1, SSRC()).WillByDefault(Return(kSsrc1));
    107  ON_CALL(rtp_1, SupportsPadding).WillByDefault(Return(false));
    108 
    109  NiceMock<MockRtpRtcpInterface> rtp_2;
    110  ON_CALL(rtp_2, RtxSendStatus()).WillByDefault(Return(kRtxOff));
    111  ON_CALL(rtp_2, SSRC()).WillByDefault(Return(kSsrc2));
    112  ON_CALL(rtp_2, SupportsPadding).WillByDefault(Return(true));
    113 
    114  packet_router_.AddSendRtpModule(&rtp_1, false);
    115  packet_router_.AddSendRtpModule(&rtp_2, false);
    116 
    117  const size_t kPaddingSize = 123;
    118  const size_t kExpectedPaddingPackets = 1;
    119  EXPECT_CALL(rtp_1, GeneratePadding(_)).Times(0);
    120  EXPECT_CALL(rtp_2, GeneratePadding(kPaddingSize))
    121      .WillOnce([&](size_t /* padding_size */) {
    122        return std::vector<std::unique_ptr<RtpPacketToSend>>(
    123            kExpectedPaddingPackets);
    124      });
    125  auto generated_padding =
    126      packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
    127  EXPECT_EQ(generated_padding.size(), kExpectedPaddingPackets);
    128 
    129  packet_router_.RemoveSendRtpModule(&rtp_1);
    130  packet_router_.RemoveSendRtpModule(&rtp_2);
    131 }
    132 
    133 TEST_F(PacketRouterTest, SupportsRtxPayloadPaddingFalseIfNoRtxSendModule) {
    134  EXPECT_FALSE(packet_router_.SupportsRtxPayloadPadding());
    135 
    136  NiceMock<MockRtpRtcpInterface> none_rtx_module;
    137  ON_CALL(none_rtx_module, SupportsRtxPayloadPadding())
    138      .WillByDefault(Return(false));
    139 
    140  packet_router_.AddSendRtpModule(&none_rtx_module, false);
    141  EXPECT_FALSE(packet_router_.SupportsRtxPayloadPadding());
    142 
    143  packet_router_.RemoveSendRtpModule(&none_rtx_module);
    144  EXPECT_FALSE(packet_router_.SupportsRtxPayloadPadding());
    145 }
    146 
    147 TEST_F(PacketRouterTest, SupportsRtxPayloadPaddingTrueIfRtxSendModule) {
    148  NiceMock<MockRtpRtcpInterface> rtx_module;
    149  ON_CALL(rtx_module, SupportsRtxPayloadPadding()).WillByDefault(Return(true));
    150 
    151  packet_router_.AddSendRtpModule(&rtx_module, false);
    152  EXPECT_TRUE(packet_router_.SupportsRtxPayloadPadding());
    153 
    154  packet_router_.RemoveSendRtpModule(&rtx_module);
    155  EXPECT_FALSE(packet_router_.SupportsRtxPayloadPadding());
    156 }
    157 
    158 TEST_F(PacketRouterTest, GeneratePaddingPrioritizesVideo) {
    159  // Two RTP modules. Neither support RTX, both support padding,
    160  // but the first one is for audio and second for video.
    161  const uint16_t kSsrc1 = 1234;
    162  const uint16_t kSsrc2 = 4567;
    163  const size_t kPaddingSize = 123;
    164  const size_t kExpectedPaddingPackets = 1;
    165 
    166  auto generate_padding = [&](size_t /* padding_size */) {
    167    return std::vector<std::unique_ptr<RtpPacketToSend>>(
    168        kExpectedPaddingPackets);
    169  };
    170 
    171  NiceMock<MockRtpRtcpInterface> audio_module;
    172  ON_CALL(audio_module, RtxSendStatus()).WillByDefault(Return(kRtxOff));
    173  ON_CALL(audio_module, SSRC()).WillByDefault(Return(kSsrc1));
    174  ON_CALL(audio_module, SupportsPadding).WillByDefault(Return(true));
    175  ON_CALL(audio_module, IsAudioConfigured).WillByDefault(Return(true));
    176 
    177  NiceMock<MockRtpRtcpInterface> video_module;
    178  ON_CALL(video_module, RtxSendStatus()).WillByDefault(Return(kRtxOff));
    179  ON_CALL(video_module, SSRC()).WillByDefault(Return(kSsrc2));
    180  ON_CALL(video_module, SupportsPadding).WillByDefault(Return(true));
    181  ON_CALL(video_module, IsAudioConfigured).WillByDefault(Return(false));
    182 
    183  // First add only the audio module. Since this is the only choice we have,
    184  // padding should be sent on the audio ssrc.
    185  packet_router_.AddSendRtpModule(&audio_module, false);
    186  EXPECT_CALL(audio_module, GeneratePadding(kPaddingSize))
    187      .WillOnce(generate_padding);
    188  packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
    189 
    190  // Add the video module, this should now be prioritized since we cannot
    191  // guarantee that audio packets will be included in the BWE.
    192  packet_router_.AddSendRtpModule(&video_module, false);
    193  EXPECT_CALL(audio_module, GeneratePadding).Times(0);
    194  EXPECT_CALL(video_module, GeneratePadding(kPaddingSize))
    195      .WillOnce(generate_padding);
    196  packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
    197 
    198  // Remove and the add audio module again. Module order shouldn't matter;
    199  // video should still be prioritized.
    200  packet_router_.RemoveSendRtpModule(&audio_module);
    201  packet_router_.AddSendRtpModule(&audio_module, false);
    202  EXPECT_CALL(audio_module, GeneratePadding).Times(0);
    203  EXPECT_CALL(video_module, GeneratePadding(kPaddingSize))
    204      .WillOnce(generate_padding);
    205  packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
    206 
    207  // Remove and the video module, we should fall back to padding on the
    208  // audio module again.
    209  packet_router_.RemoveSendRtpModule(&video_module);
    210  EXPECT_CALL(audio_module, GeneratePadding(kPaddingSize))
    211      .WillOnce(generate_padding);
    212  packet_router_.GeneratePadding(DataSize::Bytes(kPaddingSize));
    213 
    214  packet_router_.RemoveSendRtpModule(&audio_module);
    215 }
    216 
    217 TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
    218  const uint16_t kSsrc1 = 1234;
    219  const uint16_t kSsrc2 = 4567;
    220  const uint16_t kSsrc3 = 8901;
    221 
    222  // First two rtp modules send media and have rtx.
    223  NiceMock<MockRtpRtcpInterface> rtp_1;
    224  EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
    225  EXPECT_CALL(rtp_1, SupportsPadding).WillRepeatedly(Return(true));
    226  EXPECT_CALL(rtp_1, SupportsRtxPayloadPadding).WillRepeatedly(Return(true));
    227  EXPECT_CALL(rtp_1, CanSendPacket)
    228      .WillRepeatedly([&](const RtpPacketToSend& packet) {
    229        if (packet.Ssrc() == kSsrc1) {
    230          return true;
    231        }
    232        return false;
    233      });
    234 
    235  NiceMock<MockRtpRtcpInterface> rtp_2;
    236  EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2));
    237  EXPECT_CALL(rtp_2, SupportsPadding).WillRepeatedly(Return(true));
    238  EXPECT_CALL(rtp_2, SupportsRtxPayloadPadding).WillRepeatedly(Return(true));
    239  EXPECT_CALL(rtp_2, CanSendPacket)
    240      .WillRepeatedly([&](const RtpPacketToSend& packet) {
    241        if (packet.Ssrc() == kSsrc2) {
    242          return true;
    243        }
    244        return false;
    245      });
    246 
    247  // Third module is sending media, but does not support rtx.
    248  NiceMock<MockRtpRtcpInterface> rtp_3;
    249  EXPECT_CALL(rtp_3, SSRC()).WillRepeatedly(Return(kSsrc3));
    250  EXPECT_CALL(rtp_3, SupportsPadding).WillRepeatedly(Return(true));
    251  EXPECT_CALL(rtp_3, SupportsRtxPayloadPadding).WillRepeatedly(Return(false));
    252  EXPECT_CALL(rtp_3, CanSendPacket)
    253      .WillRepeatedly([&](const RtpPacketToSend& packet) {
    254        if (packet.Ssrc() == kSsrc3) {
    255          return true;
    256        }
    257        return false;
    258      });
    259 
    260  packet_router_.AddSendRtpModule(&rtp_1, false);
    261  packet_router_.AddSendRtpModule(&rtp_2, false);
    262  packet_router_.AddSendRtpModule(&rtp_3, false);
    263 
    264  const size_t kPaddingBytes = 100;
    265 
    266  // Initially, padding will be sent on last added rtp module that sends media
    267  // and supports rtx.
    268  EXPECT_CALL(rtp_2, GeneratePadding(kPaddingBytes))
    269      .Times(1)
    270      .WillOnce([&](size_t /* target_size_bytes */) {
    271        std::vector<std::unique_ptr<RtpPacketToSend>> packets;
    272        packets.push_back(BuildRtpPacket(kSsrc2));
    273        return packets;
    274      });
    275  packet_router_.GeneratePadding(DataSize::Bytes(kPaddingBytes));
    276 
    277  // Send media on first module. Padding should be sent on that module.
    278  packet_router_.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
    279 
    280  EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes))
    281      .Times(1)
    282      .WillOnce([&](size_t /* target_size_bytes */) {
    283        std::vector<std::unique_ptr<RtpPacketToSend>> packets;
    284        packets.push_back(BuildRtpPacket(kSsrc1));
    285        return packets;
    286      });
    287  packet_router_.GeneratePadding(DataSize::Bytes(kPaddingBytes));
    288 
    289  // Send media on second module. Padding should be sent there.
    290  packet_router_.SendPacket(BuildRtpPacket(kSsrc2), PacedPacketInfo());
    291 
    292  // If the last active module is removed, and no module sends media before
    293  // the next padding request, and arbitrary module will be selected.
    294  packet_router_.OnBatchComplete();
    295  packet_router_.RemoveSendRtpModule(&rtp_2);
    296 
    297  // Send on and then remove all remaining modules.
    298  RtpRtcpInterface* last_send_module;
    299  EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes))
    300      .Times(1)
    301      .WillOnce([&](size_t /* target_size_bytes */) {
    302        last_send_module = &rtp_1;
    303        std::vector<std::unique_ptr<RtpPacketToSend>> packets;
    304        packets.push_back(BuildRtpPacket(kSsrc1));
    305        return packets;
    306      });
    307  EXPECT_CALL(rtp_3, GeneratePadding(kPaddingBytes))
    308      .Times(1)
    309      .WillOnce([&](size_t /* target_size_bytes */) {
    310        last_send_module = &rtp_3;
    311        std::vector<std::unique_ptr<RtpPacketToSend>> packets;
    312        packets.push_back(BuildRtpPacket(kSsrc3));
    313        return packets;
    314      });
    315 
    316  for (int i = 0; i < 2; ++i) {
    317    last_send_module = nullptr;
    318    packet_router_.GeneratePadding(DataSize::Bytes(kPaddingBytes));
    319    EXPECT_NE(last_send_module, nullptr);
    320    packet_router_.RemoveSendRtpModule(last_send_module);
    321  }
    322 }
    323 
    324 TEST_F(PacketRouterTest, AllocatesRtpSequenceNumbersIfPacketCanBeSent) {
    325  const uint16_t kSsrc1 = 1234;
    326  PacketRouter packet_router;
    327  NiceMock<MockRtpRtcpInterface> rtp;
    328  ON_CALL(rtp, SSRC()).WillByDefault(Return(kSsrc1));
    329 
    330  InSequence s;
    331  EXPECT_CALL(rtp, CanSendPacket).WillRepeatedly(Return(true));
    332  EXPECT_CALL(rtp, AssignSequenceNumber);
    333  packet_router.AddSendRtpModule(&rtp, false);
    334  packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
    335 
    336  packet_router.OnBatchComplete();
    337  packet_router.RemoveSendRtpModule(&rtp);
    338 }
    339 
    340 TEST_F(PacketRouterTest, DoNotAllocatesRtpSequenceNumbersIfPacketCanNotBeSent) {
    341  const uint16_t kSsrc1 = 1234;
    342  PacketRouter packet_router;
    343  NiceMock<MockRtpRtcpInterface> rtp;
    344  ON_CALL(rtp, SSRC()).WillByDefault(Return(kSsrc1));
    345 
    346  EXPECT_CALL(rtp, CanSendPacket).WillRepeatedly(Return(false));
    347  EXPECT_CALL(rtp, AssignSequenceNumber).Times(0);
    348  packet_router.AddSendRtpModule(&rtp, false);
    349  packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
    350 
    351  packet_router.OnBatchComplete();
    352  packet_router.RemoveSendRtpModule(&rtp);
    353 }
    354 
    355 TEST_F(PacketRouterTest, AllocatesTransportSequenceNumbers) {
    356  const uint16_t kSsrc1 = 1234;
    357 
    358  PacketRouter packet_router;
    359  testing::MockFunction<void(const RtpPacketToSend& packet,
    360                             const PacedPacketInfo& pacing_info)>
    361      notify_bwe_callback;
    362  NiceMock<MockRtpRtcpInterface> rtp_1;
    363  packet_router.RegisterNotifyBweCallback(notify_bwe_callback.AsStdFunction());
    364 
    365  EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
    366  EXPECT_CALL(rtp_1, CanSendPacket).WillRepeatedly(Return(true));
    367 
    368  packet_router.AddSendRtpModule(&rtp_1, false);
    369 
    370  auto packet = BuildRtpPacket(kSsrc1);
    371  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
    372  EXPECT_CALL(notify_bwe_callback, Call)
    373      .WillOnce([](const RtpPacketToSend& packet,
    374                   const PacedPacketInfo& /* pacing_info */) {
    375        EXPECT_EQ(packet.transport_sequence_number(), 1);
    376      });
    377  packet_router.SendPacket(std::move(packet), PacedPacketInfo());
    378 
    379  packet_router.OnBatchComplete();
    380  packet_router.RemoveSendRtpModule(&rtp_1);
    381 }
    382 
    383 TEST_F(PacketRouterTest,
    384       DoesNotAllocateTransportSequenceNumberWithoutExtension) {
    385  const uint16_t kSsrc1 = 1234;
    386 
    387  PacketRouter packet_router;
    388  testing::MockFunction<void(const RtpPacketToSend& packet,
    389                             const PacedPacketInfo& pacing_info)>
    390      notify_bwe_callback;
    391  NiceMock<MockRtpRtcpInterface> rtp_1;
    392  packet_router.RegisterNotifyBweCallback(notify_bwe_callback.AsStdFunction());
    393 
    394  EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
    395  EXPECT_CALL(rtp_1, CanSendPacket).WillRepeatedly(Return(true));
    396 
    397  packet_router.AddSendRtpModule(&rtp_1, false);
    398 
    399  auto packet = BuildRtpPacket(kSsrc1);
    400  EXPECT_CALL(notify_bwe_callback, Call)
    401      .WillOnce([](const RtpPacketToSend& packet,
    402                   const PacedPacketInfo& /* pacing_info */) {
    403        EXPECT_EQ(packet.transport_sequence_number(), std::nullopt);
    404      });
    405  packet_router.SendPacket(std::move(packet), PacedPacketInfo());
    406 
    407  packet_router.OnBatchComplete();
    408  packet_router.RemoveSendRtpModule(&rtp_1);
    409 }
    410 
    411 TEST_F(PacketRouterTest,
    412       AllocateTransportSequenceNumberWithoutExtensionIfRfc8888Enabled) {
    413  const uint16_t kSsrc1 = 1234;
    414 
    415  PacketRouter packet_router;
    416  testing::MockFunction<void(const RtpPacketToSend& packet,
    417                             const PacedPacketInfo& pacing_info)>
    418      notify_bwe_callback;
    419  NiceMock<MockRtpRtcpInterface> rtp_1;
    420  packet_router.RegisterNotifyBweCallback(notify_bwe_callback.AsStdFunction());
    421 
    422  EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
    423  EXPECT_CALL(rtp_1, CanSendPacket).WillRepeatedly(Return(true));
    424 
    425  packet_router.AddSendRtpModule(&rtp_1, false);
    426  packet_router.ConfigureForRfc8888Feedback(/*send_rtp_packets_as_ect1=*/false);
    427 
    428  auto packet = BuildRtpPacket(kSsrc1);
    429  EXPECT_CALL(notify_bwe_callback, Call)
    430      .WillOnce([](const RtpPacketToSend& packet,
    431                   const PacedPacketInfo& /* pacing_info */) {
    432        EXPECT_EQ(packet.transport_sequence_number(), 1);
    433      });
    434  packet_router.SendPacket(std::move(packet), PacedPacketInfo());
    435 
    436  packet_router.OnBatchComplete();
    437  packet_router.RemoveSendRtpModule(&rtp_1);
    438 }
    439 
    440 TEST_F(PacketRouterTest, SendPacketsAsEct1IfConfigured) {
    441  const uint16_t kSsrc1 = 1234;
    442  PacketRouter packet_router;
    443  NiceMock<MockRtpRtcpInterface> rtp_1;
    444  ON_CALL(rtp_1, SSRC()).WillByDefault(Return(kSsrc1));
    445  ON_CALL(rtp_1, CanSendPacket).WillByDefault(Return(kSsrc1));
    446 
    447  packet_router.AddSendRtpModule(&rtp_1, false);
    448  packet_router.ConfigureForRfc8888Feedback(/*send_rtp_packets_as_ect1=*/true);
    449 
    450  testing::Sequence s;
    451  EXPECT_CALL(
    452      rtp_1,
    453      SendPacket(Pointee(Property(&RtpPacketToSend::send_as_ect1, true)), _))
    454      .InSequence(s);
    455  EXPECT_CALL(
    456      rtp_1,
    457      SendPacket(Pointee(Property(&RtpPacketToSend::send_as_ect1, false)), _))
    458      .InSequence(s);
    459 
    460  packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
    461  packet_router.ConfigureForRfc8888Feedback(/*send_rtp_packets_as_ect1=*/false);
    462  packet_router.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
    463 
    464  packet_router.OnBatchComplete();
    465  packet_router.RemoveSendRtpModule(&rtp_1);
    466 }
    467 
    468 TEST_F(PacketRouterTest, SendTransportFeedback) {
    469  NiceMock<MockRtpRtcpInterface> rtp_1;
    470  NiceMock<MockRtpRtcpInterface> rtp_2;
    471 
    472  ON_CALL(rtp_1, RTCP()).WillByDefault(Return(RtcpMode::kCompound));
    473  ON_CALL(rtp_2, RTCP()).WillByDefault(Return(RtcpMode::kCompound));
    474 
    475  packet_router_.AddSendRtpModule(&rtp_1, false);
    476  packet_router_.AddReceiveRtpModule(&rtp_2, false);
    477 
    478  std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback;
    479  feedback.push_back(std::make_unique<rtcp::TransportFeedback>());
    480  EXPECT_CALL(rtp_1, SendCombinedRtcpPacket);
    481  packet_router_.SendCombinedRtcpPacket(std::move(feedback));
    482  packet_router_.RemoveSendRtpModule(&rtp_1);
    483  EXPECT_CALL(rtp_2, SendCombinedRtcpPacket);
    484  std::vector<std::unique_ptr<rtcp::RtcpPacket>> new_feedback;
    485  new_feedback.push_back(std::make_unique<rtcp::TransportFeedback>());
    486  packet_router_.SendCombinedRtcpPacket(std::move(new_feedback));
    487  packet_router_.RemoveReceiveRtpModule(&rtp_2);
    488 }
    489 
    490 TEST_F(PacketRouterTest, SendPacketWithoutTransportSequenceNumbers) {
    491  const uint16_t kSsrc1 = 1234;
    492  NiceMock<MockRtpRtcpInterface> rtp_1;
    493  ON_CALL(rtp_1, SendingMedia).WillByDefault(Return(true));
    494  ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
    495  ON_CALL(rtp_1, CanSendPacket).WillByDefault(Return(true));
    496  packet_router_.AddSendRtpModule(&rtp_1, false);
    497 
    498  // Send a packet without TransportSequenceNumber extension registered,
    499  // packets sent should not have the extension set.
    500  RtpHeaderExtensionMap extension_manager;
    501  auto packet = std::make_unique<RtpPacketToSend>(&extension_manager);
    502  packet->SetSsrc(kSsrc1);
    503  EXPECT_CALL(
    504      rtp_1,
    505      SendPacket(
    506          AllOf(Pointee(Property(
    507                    &RtpPacketToSend::HasExtension<TransportSequenceNumber>,
    508                    false)),
    509                Pointee(Property(&RtpPacketToSend::transport_sequence_number,
    510                                 std::nullopt))),
    511          _));
    512  packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
    513  packet_router_.OnBatchComplete();
    514  packet_router_.RemoveSendRtpModule(&rtp_1);
    515 }
    516 
    517 TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
    518  NiceMock<MockRtpRtcpInterface> rtp;
    519  constexpr uint32_t kSsrc = 1234;
    520  ON_CALL(rtp, SSRC).WillByDefault(Return(kSsrc));
    521  packet_router_.AddSendRtpModule(&rtp, false);
    522 
    523  // Transport sequence numbers start at 1, for historical reasons.
    524  const uint16_t kStartTransportSequenceNumber = 1;
    525 
    526  // Build and send a packet - it should be assigned the start sequence number.
    527  // Return failure status code to make sure sequence number is not incremented.
    528  auto packet = BuildRtpPacket(kSsrc);
    529  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
    530  EXPECT_CALL(rtp, CanSendPacket)
    531      .WillOnce([&](const RtpPacketToSend& /* packet */) { return false; });
    532  packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
    533 
    534  // Send another packet, verify transport sequence number is still at the
    535  // start state.
    536  packet = BuildRtpPacket(kSsrc);
    537  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
    538 
    539  EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true));
    540  EXPECT_CALL(rtp, SendPacket)
    541      .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
    542                    const PacedPacketInfo& /* pacing_info */) {
    543        EXPECT_EQ(packet->transport_sequence_number(),
    544                  kStartTransportSequenceNumber);
    545      });
    546  packet_router_.SendPacket(std::move(packet), PacedPacketInfo());
    547 
    548  packet_router_.OnBatchComplete();
    549  packet_router_.RemoveSendRtpModule(&rtp);
    550 }
    551 
    552 TEST_F(PacketRouterTest, ForwardsAbortedRetransmissions) {
    553  NiceMock<MockRtpRtcpInterface> rtp_1;
    554  NiceMock<MockRtpRtcpInterface> rtp_2;
    555 
    556  const uint32_t kSsrc1 = 1234;
    557  const uint32_t kSsrc2 = 2345;
    558  const uint32_t kInvalidSsrc = 3456;
    559 
    560  ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
    561  ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2));
    562 
    563  packet_router_.AddSendRtpModule(&rtp_1, false);
    564  packet_router_.AddSendRtpModule(&rtp_2, false);
    565 
    566  // Sets of retransmission sequence numbers we wish to abort, per ssrc.
    567  const uint16_t kAbortedRetransmissionsOnSsrc1[] = {17, 42};
    568  const uint16_t kAbortedRetransmissionsOnSsrc2[] = {1337, 4711};
    569  const uint16_t kAbortedRetransmissionsOnSsrc3[] = {123};
    570 
    571  EXPECT_CALL(rtp_1, OnAbortedRetransmissions(
    572                         ElementsAreArray(kAbortedRetransmissionsOnSsrc1)));
    573  EXPECT_CALL(rtp_2, OnAbortedRetransmissions(
    574                         ElementsAreArray(kAbortedRetransmissionsOnSsrc2)));
    575 
    576  packet_router_.OnAbortedRetransmissions(kSsrc1,
    577                                          kAbortedRetransmissionsOnSsrc1);
    578  packet_router_.OnAbortedRetransmissions(kSsrc2,
    579                                          kAbortedRetransmissionsOnSsrc2);
    580 
    581  // Should be noop and not cause any issues.
    582  packet_router_.OnAbortedRetransmissions(kInvalidSsrc,
    583                                          kAbortedRetransmissionsOnSsrc3);
    584 
    585  packet_router_.RemoveSendRtpModule(&rtp_1);
    586  packet_router_.RemoveSendRtpModule(&rtp_2);
    587 }
    588 
    589 TEST_F(PacketRouterTest, ReportsRtxSsrc) {
    590  NiceMock<MockRtpRtcpInterface> rtp_1;
    591  NiceMock<MockRtpRtcpInterface> rtp_2;
    592 
    593  const uint32_t kSsrc1 = 1234;
    594  const uint32_t kRtxSsrc1 = 1235;
    595  const uint32_t kSsrc2 = 2345;
    596  const uint32_t kInvalidSsrc = 3456;
    597 
    598  ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
    599  ON_CALL(rtp_1, RtxSsrc).WillByDefault(Return(kRtxSsrc1));
    600  ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2));
    601 
    602  packet_router_.AddSendRtpModule(&rtp_1, false);
    603  packet_router_.AddSendRtpModule(&rtp_2, false);
    604 
    605  EXPECT_EQ(packet_router_.GetRtxSsrcForMedia(kSsrc1), kRtxSsrc1);
    606  EXPECT_EQ(packet_router_.GetRtxSsrcForMedia(kRtxSsrc1), std::nullopt);
    607  EXPECT_EQ(packet_router_.GetRtxSsrcForMedia(kSsrc2), std::nullopt);
    608  EXPECT_EQ(packet_router_.GetRtxSsrcForMedia(kInvalidSsrc), std::nullopt);
    609 
    610  packet_router_.RemoveSendRtpModule(&rtp_1);
    611  packet_router_.RemoveSendRtpModule(&rtp_2);
    612 }
    613 
    614 TEST_F(PacketRouterTest, RoutesBatchCompleteToActiveModules) {
    615  NiceMock<MockRtpRtcpInterface> rtp_1;
    616  NiceMock<MockRtpRtcpInterface> rtp_2;
    617  constexpr uint32_t kSsrc1 = 4711;
    618  constexpr uint32_t kSsrc2 = 1234;
    619  ON_CALL(rtp_1, SSRC).WillByDefault(Return(kSsrc1));
    620  ON_CALL(rtp_2, SSRC).WillByDefault(Return(kSsrc2));
    621  packet_router_.AddSendRtpModule(&rtp_1, false);
    622  packet_router_.AddSendRtpModule(&rtp_2, false);
    623  EXPECT_CALL(rtp_1, CanSendPacket).WillOnce(Return(true));
    624  packet_router_.SendPacket(BuildRtpPacket(kSsrc1), PacedPacketInfo());
    625  EXPECT_CALL(rtp_1, OnBatchComplete);
    626  EXPECT_CALL(rtp_2, OnBatchComplete).Times(0);
    627  packet_router_.OnBatchComplete();
    628  packet_router_.RemoveSendRtpModule(&rtp_1);
    629  packet_router_.RemoveSendRtpModule(&rtp_2);
    630 }
    631 
    632 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
    633 using PacketRouterDeathTest = PacketRouterTest;
    634 TEST_F(PacketRouterDeathTest, DoubleRegistrationOfSendModuleDisallowed) {
    635  NiceMock<MockRtpRtcpInterface> module;
    636 
    637  constexpr bool remb_candidate = false;  // Value irrelevant.
    638  packet_router_.AddSendRtpModule(&module, remb_candidate);
    639  EXPECT_DEATH(packet_router_.AddSendRtpModule(&module, remb_candidate), "");
    640 
    641  // Test tear-down
    642  packet_router_.RemoveSendRtpModule(&module);
    643 }
    644 
    645 TEST_F(PacketRouterDeathTest, DoubleRegistrationOfReceiveModuleDisallowed) {
    646  NiceMock<MockRtpRtcpInterface> module;
    647 
    648  constexpr bool remb_candidate = false;  // Value irrelevant.
    649  packet_router_.AddReceiveRtpModule(&module, remb_candidate);
    650  EXPECT_DEATH(packet_router_.AddReceiveRtpModule(&module, remb_candidate), "");
    651 
    652  // Test tear-down
    653  packet_router_.RemoveReceiveRtpModule(&module);
    654 }
    655 
    656 TEST_F(PacketRouterDeathTest, RemovalOfNeverAddedReceiveModuleDisallowed) {
    657  NiceMock<MockRtpRtcpInterface> module;
    658 
    659  EXPECT_DEATH(packet_router_.RemoveReceiveRtpModule(&module), "");
    660 }
    661 #endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
    662 
    663 TEST_F(PacketRouterTest, RemovalOfNeverAddedSendModuleIgnored) {
    664  NiceMock<MockRtpRtcpInterface> module;
    665  packet_router_.RemoveSendRtpModule(&module);
    666 }
    667 
    668 TEST_F(PacketRouterTest, DuplicateRemovalOfSendModuleIgnored) {
    669  NiceMock<MockRtpRtcpInterface> module;
    670  packet_router_.AddSendRtpModule(&module, false);
    671  packet_router_.RemoveSendRtpModule(&module);
    672  packet_router_.RemoveSendRtpModule(&module);
    673 }
    674 
    675 TEST(PacketRouterRembTest, ChangeSendRtpModuleChangeRembSender) {
    676  ScopedFakeClock clock;
    677  NiceMock<MockRtpRtcpInterface> rtp_send;
    678  NiceMock<MockRtpRtcpInterface> rtp_recv;
    679  PacketRouter packet_router;
    680  packet_router.AddSendRtpModule(&rtp_send, true);
    681  packet_router.AddReceiveRtpModule(&rtp_recv, true);
    682 
    683  uint32_t bitrate_estimate = 456;
    684  std::vector<uint32_t> ssrcs = {1234, 5678};
    685 
    686  EXPECT_CALL(rtp_send, SetRemb(bitrate_estimate, ssrcs));
    687  packet_router.SendRemb(bitrate_estimate, ssrcs);
    688 
    689  // Remove the sending module -> should get remb on the second module.
    690  packet_router.RemoveSendRtpModule(&rtp_send);
    691 
    692  EXPECT_CALL(rtp_recv, SetRemb(bitrate_estimate, ssrcs));
    693  packet_router.SendRemb(bitrate_estimate, ssrcs);
    694 
    695  packet_router.RemoveReceiveRtpModule(&rtp_recv);
    696 }
    697 
    698 // Only register receiving modules and make sure we fallback to trigger a REMB
    699 // packet on this one.
    700 TEST(PacketRouterRembTest, NoSendingRtpModule) {
    701  ScopedFakeClock clock;
    702  NiceMock<MockRtpRtcpInterface> rtp;
    703  PacketRouter packet_router;
    704 
    705  packet_router.AddReceiveRtpModule(&rtp, true);
    706 
    707  uint32_t bitrate_estimate = 456;
    708  const std::vector<uint32_t> ssrcs = {1234};
    709 
    710  EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs));
    711  packet_router.SendRemb(bitrate_estimate, ssrcs);
    712 
    713  // Lower the estimate to trigger a new packet REMB packet.
    714  EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs));
    715  packet_router.SendRemb(bitrate_estimate, ssrcs);
    716 
    717  EXPECT_CALL(rtp, UnsetRemb());
    718  packet_router.RemoveReceiveRtpModule(&rtp);
    719 }
    720 
    721 TEST(PacketRouterRembTest, NonCandidateSendRtpModuleNotUsedForRemb) {
    722  ScopedFakeClock clock;
    723  PacketRouter packet_router;
    724  NiceMock<MockRtpRtcpInterface> module;
    725 
    726  constexpr bool remb_candidate = false;
    727 
    728  packet_router.AddSendRtpModule(&module, remb_candidate);
    729 
    730  constexpr uint32_t bitrate_estimate = 456;
    731  const std::vector<uint32_t> ssrcs = {1234};
    732  EXPECT_CALL(module, SetRemb(_, _)).Times(0);
    733  packet_router.SendRemb(bitrate_estimate, ssrcs);
    734 
    735  // Test tear-down
    736  packet_router.RemoveSendRtpModule(&module);
    737 }
    738 
    739 TEST(PacketRouterRembTest, CandidateSendRtpModuleUsedForRemb) {
    740  ScopedFakeClock clock;
    741  PacketRouter packet_router;
    742  NiceMock<MockRtpRtcpInterface> module;
    743 
    744  constexpr bool remb_candidate = true;
    745 
    746  packet_router.AddSendRtpModule(&module, remb_candidate);
    747 
    748  constexpr uint32_t bitrate_estimate = 456;
    749  const std::vector<uint32_t> ssrcs = {1234};
    750  EXPECT_CALL(module, SetRemb(bitrate_estimate, ssrcs));
    751  packet_router.SendRemb(bitrate_estimate, ssrcs);
    752 
    753  // Test tear-down
    754  packet_router.RemoveSendRtpModule(&module);
    755 }
    756 
    757 TEST(PacketRouterRembTest, NonCandidateReceiveRtpModuleNotUsedForRemb) {
    758  ScopedFakeClock clock;
    759  PacketRouter packet_router;
    760  NiceMock<MockRtpRtcpInterface> module;
    761 
    762  constexpr bool remb_candidate = false;
    763 
    764  packet_router.AddReceiveRtpModule(&module, remb_candidate);
    765 
    766  constexpr uint32_t bitrate_estimate = 456;
    767  const std::vector<uint32_t> ssrcs = {1234};
    768  EXPECT_CALL(module, SetRemb(_, _)).Times(0);
    769  packet_router.SendRemb(bitrate_estimate, ssrcs);
    770 
    771  // Test tear-down
    772  packet_router.RemoveReceiveRtpModule(&module);
    773 }
    774 
    775 TEST(PacketRouterRembTest, CandidateReceiveRtpModuleUsedForRemb) {
    776  ScopedFakeClock clock;
    777  PacketRouter packet_router;
    778  NiceMock<MockRtpRtcpInterface> module;
    779 
    780  constexpr bool remb_candidate = true;
    781 
    782  packet_router.AddReceiveRtpModule(&module, remb_candidate);
    783 
    784  constexpr uint32_t bitrate_estimate = 456;
    785  const std::vector<uint32_t> ssrcs = {1234};
    786  EXPECT_CALL(module, SetRemb(bitrate_estimate, ssrcs));
    787  packet_router.SendRemb(bitrate_estimate, ssrcs);
    788 
    789  // Test tear-down
    790  packet_router.RemoveReceiveRtpModule(&module);
    791 }
    792 
    793 TEST(PacketRouterRembTest,
    794     SendCandidatePreferredOverReceiveCandidate_SendModuleAddedFirst) {
    795  ScopedFakeClock clock;
    796  PacketRouter packet_router;
    797  NiceMock<MockRtpRtcpInterface> send_module;
    798  NiceMock<MockRtpRtcpInterface> receive_module;
    799 
    800  constexpr bool remb_candidate = true;
    801 
    802  // Send module added - activated.
    803  packet_router.AddSendRtpModule(&send_module, remb_candidate);
    804 
    805  // Receive module added - the send module remains the active one.
    806  packet_router.AddReceiveRtpModule(&receive_module, remb_candidate);
    807 
    808  constexpr uint32_t bitrate_estimate = 456;
    809  const std::vector<uint32_t> ssrcs = {1234};
    810  EXPECT_CALL(send_module, SetRemb(bitrate_estimate, ssrcs));
    811  EXPECT_CALL(receive_module, SetRemb(_, _)).Times(0);
    812 
    813  packet_router.SendRemb(bitrate_estimate, ssrcs);
    814 
    815  // Test tear-down
    816  packet_router.RemoveReceiveRtpModule(&receive_module);
    817  packet_router.RemoveSendRtpModule(&send_module);
    818 }
    819 
    820 TEST(PacketRouterRembTest,
    821     SendCandidatePreferredOverReceiveCandidate_ReceiveModuleAddedFirst) {
    822  ScopedFakeClock clock;
    823  PacketRouter packet_router;
    824  NiceMock<MockRtpRtcpInterface> send_module;
    825  NiceMock<MockRtpRtcpInterface> receive_module;
    826 
    827  constexpr bool remb_candidate = true;
    828 
    829  // Receive module added - activated.
    830  packet_router.AddReceiveRtpModule(&receive_module, remb_candidate);
    831 
    832  // Send module added - replaces receive module as active.
    833  packet_router.AddSendRtpModule(&send_module, remb_candidate);
    834 
    835  constexpr uint32_t bitrate_estimate = 456;
    836  const std::vector<uint32_t> ssrcs = {1234};
    837  EXPECT_CALL(send_module, SetRemb(bitrate_estimate, ssrcs));
    838  EXPECT_CALL(receive_module, SetRemb(_, _)).Times(0);
    839 
    840  clock.AdvanceTime(TimeDelta::Millis(1000));
    841  packet_router.SendRemb(bitrate_estimate, ssrcs);
    842 
    843  // Test tear-down
    844  packet_router.RemoveReceiveRtpModule(&receive_module);
    845  packet_router.RemoveSendRtpModule(&send_module);
    846 }
    847 
    848 TEST(PacketRouterRembTest, ReceiveModuleTakesOverWhenLastSendModuleRemoved) {
    849  ScopedFakeClock clock;
    850  PacketRouter packet_router;
    851  NiceMock<MockRtpRtcpInterface> send_module;
    852  NiceMock<MockRtpRtcpInterface> receive_module;
    853 
    854  constexpr bool remb_candidate = true;
    855 
    856  // Send module active, receive module inactive.
    857  packet_router.AddSendRtpModule(&send_module, remb_candidate);
    858  packet_router.AddReceiveRtpModule(&receive_module, remb_candidate);
    859 
    860  // Send module removed - receive module becomes active.
    861  packet_router.RemoveSendRtpModule(&send_module);
    862  constexpr uint32_t bitrate_estimate = 456;
    863  const std::vector<uint32_t> ssrcs = {1234};
    864  EXPECT_CALL(send_module, SetRemb(_, _)).Times(0);
    865  EXPECT_CALL(receive_module, SetRemb(bitrate_estimate, ssrcs));
    866  packet_router.SendRemb(bitrate_estimate, ssrcs);
    867 
    868  // Test tear-down
    869  packet_router.RemoveReceiveRtpModule(&receive_module);
    870 }
    871 
    872 }  // namespace webrtc
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE