[ tor-browser ].git.dasho

rtcp_transceiver_impl_unittest.cc (69191B)
      1 /*
      2 *  Copyright (c) 2017 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/rtcp_transceiver_impl.h"
     12 
     13 #include <cstddef>
     14 #include <cstdint>
     15 #include <functional>
     16 #include <memory>
     17 #include <optional>
     18 #include <utility>
     19 #include <vector>
     20 
     21 #include "api/array_view.h"
     22 #include "api/rtp_headers.h"
     23 #include "api/task_queue/task_queue_base.h"
     24 #include "api/task_queue/task_queue_factory.h"
     25 #include "api/test/create_time_controller.h"
     26 #include "api/test/time_controller.h"
     27 #include "api/units/data_rate.h"
     28 #include "api/units/time_delta.h"
     29 #include "api/units/timestamp.h"
     30 #include "api/video/video_bitrate_allocation.h"
     31 #include "api/video/video_codec_constants.h"
     32 #include "modules/rtp_rtcp/include/receive_statistics.h"
     33 #include "modules/rtp_rtcp/include/report_block_data.h"
     34 #include "modules/rtp_rtcp/mocks/mock_network_link_rtcp_observer.h"
     35 #include "modules/rtp_rtcp/source/ntp_time_util.h"
     36 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
     37 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
     38 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
     39 #include "modules/rtp_rtcp/source/rtcp_packet/congestion_control_feedback.h"
     40 #include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
     41 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
     42 #include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
     43 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
     44 #include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
     45 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
     46 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
     47 #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h"
     48 #include "modules/rtp_rtcp/source/rtcp_packet/rrtr.h"
     49 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
     50 #include "modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h"
     51 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
     52 #include "modules/rtp_rtcp/source/rtcp_transceiver_config.h"
     53 #include "system_wrappers/include/clock.h"
     54 #include "system_wrappers/include/ntp_time.h"
     55 #include "test/gmock.h"
     56 #include "test/gtest.h"
     57 #include "test/rtcp_packet_parser.h"
     58 
     59 namespace webrtc {
     60 namespace {
     61 
     62 using rtcp::Bye;
     63 using rtcp::CompoundPacket;
     64 using rtcp::ReportBlock;
     65 using rtcp::SenderReport;
     66 using test::RtcpPacketParser;
     67 using ::testing::_;
     68 using ::testing::ElementsAre;
     69 using ::testing::ElementsAreArray;
     70 using ::testing::Ge;
     71 using ::testing::MockFunction;
     72 using ::testing::NiceMock;
     73 using ::testing::Property;
     74 using ::testing::Return;
     75 using ::testing::SizeIs;
     76 using ::testing::StrictMock;
     77 using ::testing::UnorderedElementsAre;
     78 using ::testing::WithArg;
     79 
     80 class MockReceiveStatisticsProvider : public ReceiveStatisticsProvider {
     81 public:
     82  MOCK_METHOD(std::vector<ReportBlock>, RtcpReportBlocks, (size_t), (override));
     83 };
     84 
     85 class MockMediaReceiverRtcpObserver : public MediaReceiverRtcpObserver {
     86 public:
     87  MOCK_METHOD(void, OnSenderReport, (uint32_t, NtpTime, uint32_t), (override));
     88  MOCK_METHOD(void, OnBye, (uint32_t), (override));
     89  MOCK_METHOD(void,
     90              OnBitrateAllocation,
     91              (uint32_t, const VideoBitrateAllocation&),
     92              (override));
     93 };
     94 
     95 class MockRtpStreamRtcpHandler : public RtpStreamRtcpHandler {
     96 public:
     97  MockRtpStreamRtcpHandler() {
     98    // With each next call increase number of sent packets and bytes to simulate
     99    // active RTP sender.
    100    ON_CALL(*this, SentStats).WillByDefault([this] {
    101      RtpStats stats;
    102      stats.set_num_sent_packets(++num_calls_);
    103      stats.set_num_sent_bytes(1'000 * num_calls_);
    104      return stats;
    105    });
    106  }
    107 
    108  MOCK_METHOD(RtpStats, SentStats, (), (override));
    109  MOCK_METHOD(void,
    110              OnNack,
    111              (uint32_t, ArrayView<const uint16_t>),
    112              (override));
    113  MOCK_METHOD(void, OnFir, (uint32_t), (override));
    114  MOCK_METHOD(void, OnPli, (uint32_t), (override));
    115  MOCK_METHOD(void, OnReport, (const ReportBlockData&), (override));
    116 
    117 private:
    118  int num_calls_ = 0;
    119 };
    120 
    121 constexpr TimeDelta kReportPeriod = TimeDelta::Seconds(1);
    122 constexpr TimeDelta kAlmostForever = TimeDelta::Seconds(2);
    123 constexpr TimeDelta kTimePrecision = TimeDelta::Millis(1);
    124 
    125 MATCHER_P(Near, value, "") {
    126  return arg > value - kTimePrecision && arg < value + kTimePrecision;
    127 }
    128 
    129 // Helper to wait for an rtcp packet produced on a different thread/task queue.
    130 class FakeRtcpTransport {
    131 public:
    132  explicit FakeRtcpTransport(TimeController& time) : time_(time) {}
    133 
    134  std::function<void(ArrayView<const uint8_t>)> AsStdFunction() {
    135    return [this](ArrayView<const uint8_t>) { sent_rtcp_ = true; };
    136  }
    137 
    138  // Returns true when packet was received by the transport.
    139  bool WaitPacket() {
    140    bool got_packet = time_.Wait([this] { return sent_rtcp_; }, kAlmostForever);
    141    // Clear the 'event' to allow waiting for multiple packets.
    142    sent_rtcp_ = false;
    143    return got_packet;
    144  }
    145 
    146 private:
    147  TimeController& time_;
    148  bool sent_rtcp_ = false;
    149 };
    150 
    151 std::function<void(ArrayView<const uint8_t>)> RtcpParserTransport(
    152    RtcpPacketParser& parser) {
    153  return [&parser](ArrayView<const uint8_t> packet) {
    154    return parser.Parse(packet);
    155  };
    156 }
    157 
    158 class RtcpTransceiverImplTest : public ::testing::Test {
    159 public:
    160  RtcpTransceiverConfig DefaultTestConfig() {
    161    // RtcpTransceiverConfig default constructor sets default values for prod.
    162    // Test doesn't need to support all key features: Default test config
    163    // returns valid config with all features turned off.
    164    RtcpTransceiverConfig config;
    165    config.clock = time_->GetClock();
    166    config.schedule_periodic_compound_packets = false;
    167    config.initial_report_delay = kReportPeriod / 2;
    168    config.report_period = kReportPeriod;
    169    return config;
    170  }
    171 
    172  TimeController& time_controller() { return *time_; }
    173  Timestamp CurrentTime() { return time_->GetClock()->CurrentTime(); }
    174  void AdvanceTime(TimeDelta time) { time_->AdvanceTime(time); }
    175  std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue() {
    176    return time_->GetTaskQueueFactory()->CreateTaskQueue(
    177        "rtcp", TaskQueueFactory::Priority::NORMAL);
    178  }
    179 
    180 private:
    181  std::unique_ptr<TimeController> time_ = CreateSimulatedTimeController();
    182 };
    183 
    184 TEST_F(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
    185  FakeRtcpTransport transport(time_controller());
    186  auto queue = CreateTaskQueue();
    187  RtcpTransceiverConfig config = DefaultTestConfig();
    188  config.task_queue = queue.get();
    189  config.schedule_periodic_compound_packets = true;
    190  config.rtcp_transport = transport.AsStdFunction();
    191  auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
    192  // Wait for a periodic packet.
    193  EXPECT_TRUE(transport.WaitPacket());
    194 
    195  bool done = false;
    196  queue->PostTask([rtcp_transceiver, &done] {
    197    rtcp_transceiver->StopPeriodicTask();
    198    delete rtcp_transceiver;
    199    done = true;
    200  });
    201  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
    202 }
    203 
    204 TEST_F(RtcpTransceiverImplTest, CanBeDestroyedRightAfterCreation) {
    205  FakeRtcpTransport transport(time_controller());
    206  auto queue = CreateTaskQueue();
    207  RtcpTransceiverConfig config = DefaultTestConfig();
    208  config.task_queue = queue.get();
    209  config.schedule_periodic_compound_packets = true;
    210  config.rtcp_transport = transport.AsStdFunction();
    211 
    212  bool done = false;
    213  queue->PostTask([&] {
    214    RtcpTransceiverImpl rtcp_transceiver(config);
    215    rtcp_transceiver.StopPeriodicTask();
    216    done = true;
    217  });
    218  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
    219 }
    220 
    221 TEST_F(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
    222  FakeRtcpTransport transport(time_controller());
    223  auto queue = CreateTaskQueue();
    224 
    225  RtcpTransceiverConfig config = DefaultTestConfig();
    226  config.task_queue = queue.get();
    227  config.schedule_periodic_compound_packets = true;
    228  config.rtcp_transport = transport.AsStdFunction();
    229  auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
    230  // Wait for a periodic packet.
    231  EXPECT_TRUE(transport.WaitPacket());
    232 
    233  queue = nullptr;
    234  delete rtcp_transceiver;
    235 }
    236 
    237 TEST_F(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
    238  auto queue = CreateTaskQueue();
    239  FakeRtcpTransport transport(time_controller());
    240  RtcpTransceiverConfig config = DefaultTestConfig();
    241  config.schedule_periodic_compound_packets = true;
    242  config.rtcp_transport = transport.AsStdFunction();
    243  config.initial_report_delay = TimeDelta::Millis(10);
    244  config.task_queue = queue.get();
    245  std::optional<RtcpTransceiverImpl> rtcp_transceiver;
    246 
    247  Timestamp started = CurrentTime();
    248  queue->PostTask([&] { rtcp_transceiver.emplace(config); });
    249  EXPECT_TRUE(transport.WaitPacket());
    250 
    251  EXPECT_GE(CurrentTime() - started, config.initial_report_delay);
    252 
    253  // Cleanup.
    254  bool done = false;
    255  queue->PostTask([&] {
    256    rtcp_transceiver->StopPeriodicTask();
    257    rtcp_transceiver.reset();
    258    done = true;
    259  });
    260  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
    261 }
    262 
    263 TEST_F(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
    264  auto queue = CreateTaskQueue();
    265  FakeRtcpTransport transport(time_controller());
    266  RtcpTransceiverConfig config = DefaultTestConfig();
    267  config.schedule_periodic_compound_packets = true;
    268  config.rtcp_transport = transport.AsStdFunction();
    269  config.initial_report_delay = TimeDelta::Zero();
    270  config.report_period = kReportPeriod;
    271  config.task_queue = queue.get();
    272  std::optional<RtcpTransceiverImpl> rtcp_transceiver;
    273  Timestamp time_just_before_1st_packet = Timestamp::MinusInfinity();
    274  queue->PostTask([&] {
    275    // Because initial_report_delay_ms is set to 0, time_just_before_the_packet
    276    // should be very close to the time_of_the_packet.
    277    time_just_before_1st_packet = CurrentTime();
    278    rtcp_transceiver.emplace(config);
    279  });
    280 
    281  EXPECT_TRUE(transport.WaitPacket());
    282  EXPECT_TRUE(transport.WaitPacket());
    283  Timestamp time_just_after_2nd_packet = CurrentTime();
    284 
    285  EXPECT_GE(time_just_after_2nd_packet - time_just_before_1st_packet,
    286            config.report_period);
    287 
    288  // Cleanup.
    289  bool done = false;
    290  queue->PostTask([&] {
    291    rtcp_transceiver->StopPeriodicTask();
    292    rtcp_transceiver.reset();
    293    done = true;
    294  });
    295  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
    296 }
    297 
    298 TEST_F(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
    299  auto queue = CreateTaskQueue();
    300  FakeRtcpTransport transport(time_controller());
    301  RtcpTransceiverConfig config = DefaultTestConfig();
    302  config.schedule_periodic_compound_packets = true;
    303  config.rtcp_transport = transport.AsStdFunction();
    304  config.initial_report_delay = TimeDelta::Zero();
    305  config.report_period = kReportPeriod;
    306  config.task_queue = queue.get();
    307  std::optional<RtcpTransceiverImpl> rtcp_transceiver;
    308  queue->PostTask([&] { rtcp_transceiver.emplace(config); });
    309 
    310  // Wait for the first packet.
    311  EXPECT_TRUE(transport.WaitPacket());
    312  // Send non periodic one after half period.
    313  bool non_periodic = false;
    314  Timestamp time_of_non_periodic_packet = Timestamp::MinusInfinity();
    315  queue->PostDelayedTask(
    316      [&] {
    317        time_of_non_periodic_packet = CurrentTime();
    318        rtcp_transceiver->SendCompoundPacket();
    319        non_periodic = true;
    320      },
    321      config.report_period / 2);
    322  // Though non-periodic packet is scheduled just in between periodic, due to
    323  // small period and task queue flakiness it migth end-up 1ms after next
    324  // periodic packet. To be sure duration after non-periodic packet is tested
    325  // wait for transport after ensuring non-periodic packet was sent.
    326  EXPECT_TRUE(
    327      time_controller().Wait([&] { return non_periodic; }, kAlmostForever));
    328  EXPECT_TRUE(transport.WaitPacket());
    329  // Wait for next periodic packet.
    330  EXPECT_TRUE(transport.WaitPacket());
    331  Timestamp time_of_last_periodic_packet = CurrentTime();
    332  EXPECT_GE(time_of_last_periodic_packet - time_of_non_periodic_packet,
    333            config.report_period);
    334 
    335  // Cleanup.
    336  bool done = false;
    337  queue->PostTask([&] {
    338    rtcp_transceiver->StopPeriodicTask();
    339    rtcp_transceiver.reset();
    340    done = true;
    341  });
    342  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
    343 }
    344 
    345 TEST_F(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
    346  MockFunction<void(ArrayView<const uint8_t>)> mock_transport;
    347  RtcpTransceiverConfig config = DefaultTestConfig();
    348  config.initial_ready_to_send = false;
    349  config.rtcp_transport = mock_transport.AsStdFunction();
    350  RtcpTransceiverImpl rtcp_transceiver(config);
    351 
    352  EXPECT_CALL(mock_transport, Call).Times(0);
    353 
    354  const std::vector<uint16_t> sequence_numbers = {45, 57};
    355  const uint32_t ssrcs[] = {123};
    356  rtcp_transceiver.SendCompoundPacket();
    357  rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
    358  rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
    359  rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
    360 }
    361 
    362 TEST_F(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
    363  MockFunction<void(ArrayView<const uint8_t>)> mock_transport;
    364  RtcpTransceiverConfig config = DefaultTestConfig();
    365  config.initial_ready_to_send = false;
    366  config.rtcp_transport = mock_transport.AsStdFunction();
    367  RtcpTransceiverImpl rtcp_transceiver(config);
    368 
    369  rtcp_transceiver.SetReadyToSend(true);
    370 
    371  EXPECT_CALL(mock_transport, Call).Times(4);
    372 
    373  const std::vector<uint16_t> sequence_numbers = {45, 57};
    374  const uint32_t ssrcs[] = {123};
    375  rtcp_transceiver.SendCompoundPacket();
    376  rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
    377  rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
    378  rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
    379 }
    380 
    381 TEST_F(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
    382  auto queue = CreateTaskQueue();
    383  FakeRtcpTransport transport(time_controller());
    384  RtcpTransceiverConfig config = DefaultTestConfig();
    385  config.schedule_periodic_compound_packets = true;
    386  config.initial_ready_to_send = false;
    387  config.rtcp_transport = transport.AsStdFunction();
    388  config.task_queue = queue.get();
    389  std::optional<RtcpTransceiverImpl> rtcp_transceiver;
    390  rtcp_transceiver.emplace(config);
    391 
    392  queue->PostTask([&] { rtcp_transceiver->SetReadyToSend(true); });
    393 
    394  EXPECT_TRUE(transport.WaitPacket());
    395 
    396  // Cleanup.
    397  bool done = false;
    398  queue->PostTask([&] {
    399    rtcp_transceiver->StopPeriodicTask();
    400    rtcp_transceiver.reset();
    401    done = true;
    402  });
    403  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
    404 }
    405 
    406 TEST_F(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
    407  const uint32_t kSenderSsrc = 12345;
    408  RtcpTransceiverConfig config = DefaultTestConfig();
    409  config.feedback_ssrc = kSenderSsrc;
    410  config.cname = "cname";
    411  RtcpPacketParser rtcp_parser;
    412  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    413  config.schedule_periodic_compound_packets = false;
    414  RtcpTransceiverImpl rtcp_transceiver(config);
    415 
    416  rtcp_transceiver.SendCompoundPacket();
    417 
    418  // Minimal compound RTCP packet contains sender or receiver report and sdes
    419  // with cname.
    420  ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
    421  EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
    422  ASSERT_GT(rtcp_parser.sdes()->num_packets(), 0);
    423  ASSERT_EQ(rtcp_parser.sdes()->chunks().size(), 1u);
    424  EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].ssrc, kSenderSsrc);
    425  EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].cname, config.cname);
    426 }
    427 
    428 TEST_F(RtcpTransceiverImplTest, AvoidsEmptyPacketsInReducedMode) {
    429  MockFunction<void(ArrayView<const uint8_t>)> transport;
    430  EXPECT_CALL(transport, Call).Times(0);
    431  NiceMock<MockReceiveStatisticsProvider> receive_statistics;
    432 
    433  RtcpTransceiverConfig config = DefaultTestConfig();
    434  config.rtcp_transport = transport.AsStdFunction();
    435  config.rtcp_mode = RtcpMode::kReducedSize;
    436  config.receive_statistics = &receive_statistics;
    437  RtcpTransceiverImpl rtcp_transceiver(config);
    438 
    439  rtcp_transceiver.SendCompoundPacket();
    440 }
    441 
    442 TEST_F(RtcpTransceiverImplTest, AvoidsEmptyReceiverReportsInReducedMode) {
    443  RtcpPacketParser rtcp_parser;
    444  NiceMock<MockReceiveStatisticsProvider> receive_statistics;
    445 
    446  RtcpTransceiverConfig config = DefaultTestConfig();
    447  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    448  config.rtcp_mode = RtcpMode::kReducedSize;
    449  config.receive_statistics = &receive_statistics;
    450  // Set it to produce something (RRTR) in the "periodic" rtcp packets.
    451  config.non_sender_rtt_measurement = true;
    452  RtcpTransceiverImpl rtcp_transceiver(config);
    453 
    454  // Rather than waiting for the right time to produce the periodic packet,
    455  // trigger it manually.
    456  rtcp_transceiver.SendCompoundPacket();
    457 
    458  EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
    459  EXPECT_GT(rtcp_parser.xr()->num_packets(), 0);
    460 }
    461 
    462 TEST_F(RtcpTransceiverImplTest, SendsNoRembInitially) {
    463  const uint32_t kSenderSsrc = 12345;
    464  RtcpTransceiverConfig config = DefaultTestConfig();
    465  config.feedback_ssrc = kSenderSsrc;
    466  RtcpPacketParser rtcp_parser;
    467  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    468  config.schedule_periodic_compound_packets = false;
    469  RtcpTransceiverImpl rtcp_transceiver(config);
    470 
    471  rtcp_transceiver.SendCompoundPacket();
    472 
    473  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
    474  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 0);
    475 }
    476 
    477 TEST_F(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
    478  const uint32_t kSenderSsrc = 12345;
    479  RtcpTransceiverConfig config = DefaultTestConfig();
    480  config.feedback_ssrc = kSenderSsrc;
    481  RtcpPacketParser rtcp_parser;
    482  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    483  config.schedule_periodic_compound_packets = false;
    484  RtcpTransceiverImpl rtcp_transceiver(config);
    485 
    486  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
    487  rtcp_transceiver.SendCompoundPacket();
    488 
    489  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
    490  EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
    491  EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
    492  EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
    493 }
    494 
    495 TEST_F(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
    496  const uint32_t kSenderSsrc = 12345;
    497  RtcpTransceiverConfig config = DefaultTestConfig();
    498  config.feedback_ssrc = kSenderSsrc;
    499  RtcpPacketParser rtcp_parser;
    500  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    501  config.schedule_periodic_compound_packets = false;
    502  RtcpTransceiverImpl rtcp_transceiver(config);
    503 
    504  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
    505  rtcp_transceiver.SendCompoundPacket();
    506 
    507  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
    508  EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
    509  EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
    510 
    511  rtcp_transceiver.SetRemb(/*bitrate_bps=*/70000, /*ssrcs=*/{67321});
    512  rtcp_transceiver.SendCompoundPacket();
    513 
    514  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
    515  EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 70000);
    516  EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(67321));
    517 }
    518 
    519 TEST_F(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
    520  const uint32_t kSenderSsrc = 12345;
    521  RtcpTransceiverConfig config = DefaultTestConfig();
    522  config.send_remb_on_change = true;
    523  config.feedback_ssrc = kSenderSsrc;
    524  RtcpPacketParser rtcp_parser;
    525  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    526  config.schedule_periodic_compound_packets = false;
    527  RtcpTransceiverImpl rtcp_transceiver(config);
    528 
    529  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
    530  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
    531  EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
    532  EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
    533 
    534  // If there is no change, the packet is not sent immediately.
    535  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
    536  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
    537 
    538  rtcp_transceiver.SetRemb(/*bitrate_bps=*/20000, /*ssrcs=*/{});
    539  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
    540  EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 20000);
    541 }
    542 
    543 TEST_F(RtcpTransceiverImplTest,
    544       SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
    545  const uint32_t kSenderSsrc = 12345;
    546  RtcpTransceiverConfig config = DefaultTestConfig();
    547  config.send_remb_on_change = true;
    548  config.rtcp_mode = RtcpMode::kReducedSize;
    549  config.feedback_ssrc = kSenderSsrc;
    550  RtcpPacketParser rtcp_parser;
    551  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    552  config.schedule_periodic_compound_packets = false;
    553  RtcpTransceiverImpl rtcp_transceiver(config);
    554 
    555  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
    556  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
    557  EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
    558  EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
    559 }
    560 
    561 TEST_F(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
    562  const uint32_t kSenderSsrc = 12345;
    563  RtcpTransceiverConfig config = DefaultTestConfig();
    564  config.feedback_ssrc = kSenderSsrc;
    565  RtcpPacketParser rtcp_parser;
    566  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    567  config.schedule_periodic_compound_packets = false;
    568  RtcpTransceiverImpl rtcp_transceiver(config);
    569 
    570  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
    571  rtcp_transceiver.SendCompoundPacket();
    572  rtcp_transceiver.SendCompoundPacket();
    573 
    574  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{2});
    575  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
    576 }
    577 
    578 TEST_F(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
    579  const uint32_t kSenderSsrc = 12345;
    580  RtcpTransceiverConfig config = DefaultTestConfig();
    581  config.feedback_ssrc = kSenderSsrc;
    582  RtcpPacketParser rtcp_parser;
    583  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    584  config.schedule_periodic_compound_packets = false;
    585  RtcpTransceiverImpl rtcp_transceiver(config);
    586 
    587  rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
    588  rtcp_transceiver.SendCompoundPacket();
    589  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
    590  ASSERT_EQ(rtcp_parser.remb()->num_packets(), 1);
    591 
    592  rtcp_transceiver.UnsetRemb();
    593  rtcp_transceiver.SendCompoundPacket();
    594 
    595  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{2});
    596  EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
    597 }
    598 
    599 TEST_F(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
    600  const uint32_t kSenderSsrc = 12345;
    601  const uint32_t kMediaSsrc = 54321;
    602  MockReceiveStatisticsProvider receive_statistics;
    603  std::vector<ReportBlock> report_blocks(1);
    604  report_blocks[0].SetMediaSsrc(kMediaSsrc);
    605  EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
    606      .WillRepeatedly(Return(report_blocks));
    607 
    608  RtcpTransceiverConfig config = DefaultTestConfig();
    609  config.feedback_ssrc = kSenderSsrc;
    610  RtcpPacketParser rtcp_parser;
    611  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    612  config.receive_statistics = &receive_statistics;
    613  config.schedule_periodic_compound_packets = false;
    614  RtcpTransceiverImpl rtcp_transceiver(config);
    615 
    616  rtcp_transceiver.SendCompoundPacket();
    617 
    618  ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
    619  EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
    620  ASSERT_THAT(rtcp_parser.receiver_report()->report_blocks(),
    621              SizeIs(report_blocks.size()));
    622  EXPECT_EQ(rtcp_parser.receiver_report()->report_blocks()[0].source_ssrc(),
    623            kMediaSsrc);
    624 }
    625 
    626 TEST_F(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
    627  const uint32_t kRemoteSsrc = 12345;
    628  StrictMock<MockMediaReceiverRtcpObserver> observer1;
    629  StrictMock<MockMediaReceiverRtcpObserver> observer2;
    630  RtcpTransceiverConfig config = DefaultTestConfig();
    631  RtcpTransceiverImpl rtcp_transceiver(config);
    632  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
    633  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
    634 
    635  const NtpTime kRemoteNtp(0x9876543211);
    636  const uint32_t kRemoteRtp = 0x444555;
    637  SenderReport sr;
    638  sr.SetSenderSsrc(kRemoteSsrc);
    639  sr.SetNtp(kRemoteNtp);
    640  sr.SetRtpTimestamp(kRemoteRtp);
    641  auto raw_packet = sr.Build();
    642 
    643  EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
    644  EXPECT_CALL(observer2, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
    645  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    646 }
    647 
    648 TEST_F(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
    649  const uint32_t kRemoteSsrc = 12345;
    650  StrictMock<MockMediaReceiverRtcpObserver> observer1;
    651  StrictMock<MockMediaReceiverRtcpObserver> observer2;
    652  RtcpTransceiverConfig config = DefaultTestConfig();
    653  RtcpTransceiverImpl rtcp_transceiver(config);
    654  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
    655  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
    656 
    657  SenderReport sr;
    658  sr.SetSenderSsrc(kRemoteSsrc);
    659  auto raw_packet = sr.Build();
    660 
    661  rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
    662 
    663  EXPECT_CALL(observer1, OnSenderReport(_, _, _)).Times(0);
    664  EXPECT_CALL(observer2, OnSenderReport(_, _, _));
    665  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    666 }
    667 
    668 TEST_F(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
    669  const uint32_t kRemoteSsrc1 = 12345;
    670  const uint32_t kRemoteSsrc2 = 22345;
    671  StrictMock<MockMediaReceiverRtcpObserver> observer1;
    672  StrictMock<MockMediaReceiverRtcpObserver> observer2;
    673  RtcpTransceiverConfig config = DefaultTestConfig();
    674  RtcpTransceiverImpl rtcp_transceiver(config);
    675  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
    676  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
    677 
    678  const NtpTime kRemoteNtp(0x9876543211);
    679  const uint32_t kRemoteRtp = 0x444555;
    680  SenderReport sr;
    681  sr.SetSenderSsrc(kRemoteSsrc1);
    682  sr.SetNtp(kRemoteNtp);
    683  sr.SetRtpTimestamp(kRemoteRtp);
    684  auto raw_packet = sr.Build();
    685 
    686  EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc1, kRemoteNtp, kRemoteRtp));
    687  EXPECT_CALL(observer2, OnSenderReport).Times(0);
    688  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    689 }
    690 
    691 TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
    692  const uint32_t kRemoteSsrc1 = 12345;
    693  const uint32_t kRemoteSsrc2 = 22345;
    694  StrictMock<MockMediaReceiverRtcpObserver> observer1;
    695  StrictMock<MockMediaReceiverRtcpObserver> observer2;
    696  RtcpTransceiverConfig config = DefaultTestConfig();
    697  RtcpTransceiverImpl rtcp_transceiver(config);
    698  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
    699  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
    700 
    701  Bye bye;
    702  bye.SetSenderSsrc(kRemoteSsrc1);
    703  auto raw_packet = bye.Build();
    704 
    705  EXPECT_CALL(observer1, OnBye(kRemoteSsrc1));
    706  EXPECT_CALL(observer2, OnBye(_)).Times(0);
    707  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    708 }
    709 
    710 TEST_F(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
    711  const uint32_t kRemoteSsrc1 = 12345;
    712  const uint32_t kRemoteSsrc2 = 22345;
    713  StrictMock<MockMediaReceiverRtcpObserver> observer1;
    714  StrictMock<MockMediaReceiverRtcpObserver> observer2;
    715  RtcpTransceiverConfig config = DefaultTestConfig();
    716  RtcpTransceiverImpl rtcp_transceiver(config);
    717  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
    718  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
    719 
    720  rtcp::TargetBitrate target_bitrate;
    721  target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
    722  target_bitrate.AddTargetBitrate(0, 1, /*target_bitrate_kbps=*/20);
    723  target_bitrate.AddTargetBitrate(1, 0, /*target_bitrate_kbps=*/40);
    724  target_bitrate.AddTargetBitrate(1, 1, /*target_bitrate_kbps=*/80);
    725  rtcp::ExtendedReports xr;
    726  xr.SetSenderSsrc(kRemoteSsrc1);
    727  xr.SetTargetBitrate(target_bitrate);
    728  auto raw_packet = xr.Build();
    729 
    730  VideoBitrateAllocation bitrate_allocation;
    731  bitrate_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
    732  bitrate_allocation.SetBitrate(0, 1, /*bitrate_bps=*/20000);
    733  bitrate_allocation.SetBitrate(1, 0, /*bitrate_bps=*/40000);
    734  bitrate_allocation.SetBitrate(1, 1, /*bitrate_bps=*/80000);
    735  EXPECT_CALL(observer1, OnBitrateAllocation(kRemoteSsrc1, bitrate_allocation));
    736  EXPECT_CALL(observer2, OnBitrateAllocation(_, _)).Times(0);
    737  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    738 }
    739 
    740 TEST_F(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
    741  const uint32_t kRemoteSsrc = 12345;
    742  MockMediaReceiverRtcpObserver observer;
    743  RtcpTransceiverConfig config = DefaultTestConfig();
    744  RtcpTransceiverImpl rtcp_transceiver(config);
    745  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
    746 
    747  rtcp::TargetBitrate target_bitrate;
    748  target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
    749  target_bitrate.AddTargetBitrate(0, kMaxTemporalStreams, 20);
    750  target_bitrate.AddTargetBitrate(kMaxSpatialLayers, 0, 40);
    751 
    752  rtcp::ExtendedReports xr;
    753  xr.SetTargetBitrate(target_bitrate);
    754  xr.SetSenderSsrc(kRemoteSsrc);
    755  auto raw_packet = xr.Build();
    756 
    757  VideoBitrateAllocation expected_allocation;
    758  expected_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
    759  EXPECT_CALL(observer, OnBitrateAllocation(kRemoteSsrc, expected_allocation));
    760  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    761 }
    762 
    763 TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
    764  const uint32_t kRemoteSsrc = 12345;
    765  MockMediaReceiverRtcpObserver observer;
    766  RtcpTransceiverConfig config = DefaultTestConfig();
    767  RtcpTransceiverImpl rtcp_transceiver(config);
    768  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
    769 
    770  CompoundPacket compound;
    771  auto sr = std::make_unique<SenderReport>();
    772  sr->SetSenderSsrc(kRemoteSsrc);
    773  compound.Append(std::move(sr));
    774  auto bye = std::make_unique<Bye>();
    775  bye->SetSenderSsrc(kRemoteSsrc);
    776  compound.Append(std::move(bye));
    777  auto raw_packet = compound.Build();
    778 
    779  EXPECT_CALL(observer, OnBye(kRemoteSsrc));
    780  EXPECT_CALL(observer, OnSenderReport(kRemoteSsrc, _, _));
    781  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    782 }
    783 
    784 TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
    785  const uint32_t kRemoteSsrc = 12345;
    786  MockMediaReceiverRtcpObserver observer;
    787  RtcpTransceiverConfig config = DefaultTestConfig();
    788  RtcpTransceiverImpl rtcp_transceiver(config);
    789  rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
    790 
    791  CompoundPacket compound;
    792  // Use Application-Defined rtcp packet as unknown.
    793  auto app = std::make_unique<rtcp::App>();
    794  compound.Append(std::move(app));
    795  auto bye = std::make_unique<Bye>();
    796  bye->SetSenderSsrc(kRemoteSsrc);
    797  compound.Append(std::move(bye));
    798  auto raw_packet = compound.Build();
    799 
    800  EXPECT_CALL(observer, OnBye(kRemoteSsrc));
    801  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    802 }
    803 
    804 TEST_F(RtcpTransceiverImplTest,
    805       WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc) {
    806  const uint32_t kRemoteSsrc1 = 4321;
    807  const uint32_t kRemoteSsrc2 = 5321;
    808  std::vector<ReportBlock> statistics_report_blocks(2);
    809  statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
    810  statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
    811  MockReceiveStatisticsProvider receive_statistics;
    812  EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
    813      .WillOnce(Return(statistics_report_blocks));
    814 
    815  RtcpTransceiverConfig config = DefaultTestConfig();
    816  config.schedule_periodic_compound_packets = false;
    817  RtcpPacketParser rtcp_parser;
    818  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    819  config.receive_statistics = &receive_statistics;
    820  RtcpTransceiverImpl rtcp_transceiver(config);
    821 
    822  const NtpTime kRemoteNtp(0x9876543211);
    823  // Receive SenderReport for RemoteSsrc1, but no report for RemoteSsrc2.
    824  SenderReport sr;
    825  sr.SetSenderSsrc(kRemoteSsrc1);
    826  sr.SetNtp(kRemoteNtp);
    827  auto raw_packet = sr.Build();
    828  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
    829 
    830  // Trigger sending ReceiverReport.
    831  rtcp_transceiver.SendCompoundPacket();
    832 
    833  EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
    834  const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
    835  ASSERT_EQ(report_blocks.size(), 2u);
    836  // RtcpTransceiverImpl doesn't guarantee order of the report blocks
    837  // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
    838  // but for simplicity of the test asume it is the same.
    839  ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
    840  EXPECT_EQ(report_blocks[0].last_sr(), CompactNtp(kRemoteNtp));
    841 
    842  ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
    843  // No matching Sender Report for kRemoteSsrc2, LastSR fields has to be 0.
    844  EXPECT_EQ(report_blocks[1].last_sr(), 0u);
    845 }
    846 
    847 TEST_F(RtcpTransceiverImplTest,
    848       WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
    849  const uint32_t kRemoteSsrc1 = 4321;
    850  const uint32_t kRemoteSsrc2 = 5321;
    851 
    852  std::vector<ReportBlock> statistics_report_blocks(2);
    853  statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
    854  statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
    855  MockReceiveStatisticsProvider receive_statistics;
    856  EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
    857      .WillOnce(Return(statistics_report_blocks));
    858 
    859  RtcpTransceiverConfig config = DefaultTestConfig();
    860  config.schedule_periodic_compound_packets = false;
    861  RtcpPacketParser rtcp_parser;
    862  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    863  config.receive_statistics = &receive_statistics;
    864  RtcpTransceiverImpl rtcp_transceiver(config);
    865 
    866  auto receive_sender_report = [&](uint32_t remote_ssrc) {
    867    SenderReport sr;
    868    sr.SetSenderSsrc(remote_ssrc);
    869    rtcp_transceiver.ReceivePacket(sr.Build(), CurrentTime());
    870  };
    871 
    872  receive_sender_report(kRemoteSsrc1);
    873  time_controller().AdvanceTime(TimeDelta::Millis(100));
    874 
    875  receive_sender_report(kRemoteSsrc2);
    876  time_controller().AdvanceTime(TimeDelta::Millis(100));
    877 
    878  // Trigger ReceiverReport back.
    879  rtcp_transceiver.SendCompoundPacket();
    880 
    881  EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
    882  const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
    883  ASSERT_EQ(report_blocks.size(), 2u);
    884  // RtcpTransceiverImpl doesn't guarantee order of the report blocks
    885  // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
    886  // but for simplicity of the test asume it is the same.
    887  ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
    888  EXPECT_THAT(CompactNtpRttToTimeDelta(report_blocks[0].delay_since_last_sr()),
    889              Near(TimeDelta::Millis(200)));
    890 
    891  ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
    892  EXPECT_THAT(CompactNtpRttToTimeDelta(report_blocks[1].delay_since_last_sr()),
    893              Near(TimeDelta::Millis(100)));
    894 }
    895 
    896 TEST_F(RtcpTransceiverImplTest, MaySendMultipleReceiverReportInSinglePacket) {
    897  std::vector<ReportBlock> statistics_report_blocks(40);
    898  MockReceiveStatisticsProvider receive_statistics;
    899  EXPECT_CALL(receive_statistics, RtcpReportBlocks(/*max_blocks=*/Ge(40u)))
    900      .WillOnce(Return(statistics_report_blocks));
    901 
    902  RtcpTransceiverConfig config = DefaultTestConfig();
    903  RtcpPacketParser rtcp_parser;
    904  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    905  config.receive_statistics = &receive_statistics;
    906  RtcpTransceiverImpl rtcp_transceiver(config);
    907 
    908  // Trigger ReceiverReports.
    909  rtcp_transceiver.SendCompoundPacket();
    910 
    911  // Expect a single RTCP packet with multiple receiver reports in it.
    912  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
    913  // Receiver report may contain up to 31 report blocks, thus 2 reports are
    914  // needed to carry 40 blocks: 31 in the first, 9 in the last.
    915  EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 2);
    916  // RtcpParser remembers just the last receiver report, thus can't check number
    917  // of blocks in the first receiver report.
    918  EXPECT_THAT(rtcp_parser.receiver_report()->report_blocks(), SizeIs(9));
    919 }
    920 
    921 TEST_F(RtcpTransceiverImplTest, AttachMaxNumberOfReportBlocksToCompoundPacket) {
    922  MockReceiveStatisticsProvider receive_statistics;
    923  EXPECT_CALL(receive_statistics, RtcpReportBlocks)
    924      .WillOnce([](size_t max_blocks) {
    925        return std::vector<ReportBlock>(max_blocks);
    926      });
    927  RtcpTransceiverConfig config = DefaultTestConfig();
    928  config.rtcp_mode = RtcpMode::kCompound;
    929  RtcpPacketParser rtcp_parser;
    930  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    931  config.receive_statistics = &receive_statistics;
    932  RtcpTransceiverImpl rtcp_transceiver(config);
    933 
    934  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{0});
    935  // Send some fast feedback message. Because of compound mode, report blocks
    936  // should be attached.
    937  rtcp_transceiver.SendPictureLossIndication(/*ssrc=*/123);
    938 
    939  // Expect single RTCP packet with multiple receiver reports and a PLI.
    940  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
    941  EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 1);
    942  EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
    943 }
    944 
    945 TEST_F(RtcpTransceiverImplTest, SendsNack) {
    946  const uint32_t kSenderSsrc = 1234;
    947  const uint32_t kRemoteSsrc = 4321;
    948  std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
    949  RtcpTransceiverConfig config = DefaultTestConfig();
    950  config.feedback_ssrc = kSenderSsrc;
    951  config.schedule_periodic_compound_packets = false;
    952  RtcpPacketParser rtcp_parser;
    953  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    954  RtcpTransceiverImpl rtcp_transceiver(config);
    955 
    956  rtcp_transceiver.SendNack(kRemoteSsrc, kMissingSequenceNumbers);
    957 
    958  EXPECT_EQ(rtcp_parser.nack()->num_packets(), 1);
    959  EXPECT_EQ(rtcp_parser.nack()->sender_ssrc(), kSenderSsrc);
    960  EXPECT_EQ(rtcp_parser.nack()->media_ssrc(), kRemoteSsrc);
    961  EXPECT_EQ(rtcp_parser.nack()->packet_ids(), kMissingSequenceNumbers);
    962 }
    963 
    964 TEST_F(RtcpTransceiverImplTest, ReceivesNack) {
    965  static constexpr uint32_t kRemoteSsrc = 4321;
    966  static constexpr uint32_t kMediaSsrc1 = 1234;
    967  static constexpr uint32_t kMediaSsrc2 = 1235;
    968  std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
    969  RtcpTransceiverConfig config = DefaultTestConfig();
    970  RtcpTransceiverImpl rtcp_transceiver(config);
    971 
    972  MockRtpStreamRtcpHandler local_stream1;
    973  MockRtpStreamRtcpHandler local_stream2;
    974  EXPECT_CALL(local_stream1,
    975              OnNack(kRemoteSsrc, ElementsAreArray(kMissingSequenceNumbers)));
    976  EXPECT_CALL(local_stream2, OnNack).Times(0);
    977 
    978  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
    979  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
    980 
    981  rtcp::Nack nack;
    982  nack.SetSenderSsrc(kRemoteSsrc);
    983  nack.SetMediaSsrc(kMediaSsrc1);
    984  nack.SetPacketIds(kMissingSequenceNumbers);
    985  rtcp_transceiver.ReceivePacket(nack.Build(), config.clock->CurrentTime());
    986 }
    987 
    988 TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
    989  const uint32_t kSenderSsrc = 1234;
    990  const uint32_t kRemoteSsrc = 4321;
    991  RtcpTransceiverConfig config = DefaultTestConfig();
    992  config.feedback_ssrc = kSenderSsrc;
    993  config.schedule_periodic_compound_packets = false;
    994  RtcpPacketParser rtcp_parser;
    995  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
    996  RtcpTransceiverImpl rtcp_transceiver(config);
    997 
    998  rtcp_transceiver.SendPictureLossIndication(kRemoteSsrc);
    999 
   1000  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
   1001  EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
   1002  EXPECT_EQ(rtcp_parser.pli()->sender_ssrc(), kSenderSsrc);
   1003  EXPECT_EQ(rtcp_parser.pli()->media_ssrc(), kRemoteSsrc);
   1004 }
   1005 
   1006 TEST_F(RtcpTransceiverImplTest, ReceivesPictureLossIndication) {
   1007  static constexpr uint32_t kRemoteSsrc = 4321;
   1008  static constexpr uint32_t kMediaSsrc1 = 1234;
   1009  static constexpr uint32_t kMediaSsrc2 = 1235;
   1010  RtcpTransceiverConfig config = DefaultTestConfig();
   1011  RtcpTransceiverImpl rtcp_transceiver(config);
   1012 
   1013  MockRtpStreamRtcpHandler local_stream1;
   1014  MockRtpStreamRtcpHandler local_stream2;
   1015  EXPECT_CALL(local_stream1, OnPli(kRemoteSsrc));
   1016  EXPECT_CALL(local_stream2, OnPli).Times(0);
   1017 
   1018  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
   1019  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
   1020 
   1021  rtcp::Pli pli;
   1022  pli.SetSenderSsrc(kRemoteSsrc);
   1023  pli.SetMediaSsrc(kMediaSsrc1);
   1024  rtcp_transceiver.ReceivePacket(pli.Build(), config.clock->CurrentTime());
   1025 }
   1026 
   1027 TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
   1028  const uint32_t kSenderSsrc = 1234;
   1029  const uint32_t kRemoteSsrcs[] = {4321, 5321};
   1030  RtcpTransceiverConfig config = DefaultTestConfig();
   1031  config.feedback_ssrc = kSenderSsrc;
   1032  config.schedule_periodic_compound_packets = false;
   1033  RtcpPacketParser rtcp_parser;
   1034  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1035  RtcpTransceiverImpl rtcp_transceiver(config);
   1036 
   1037  rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
   1038 
   1039  EXPECT_EQ(rtcp_parser.fir()->num_packets(), 1);
   1040  EXPECT_EQ(rtcp_parser.fir()->sender_ssrc(), kSenderSsrc);
   1041  EXPECT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kRemoteSsrcs[0]);
   1042  EXPECT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kRemoteSsrcs[1]);
   1043 }
   1044 
   1045 TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
   1046  RtcpTransceiverConfig config = DefaultTestConfig();
   1047  config.schedule_periodic_compound_packets = false;
   1048  RtcpPacketParser rtcp_parser;
   1049  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1050  RtcpTransceiverImpl rtcp_transceiver(config);
   1051 
   1052  const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
   1053  const uint32_t kOneRemoteSsrc[] = {4321};
   1054 
   1055  rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
   1056  ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
   1057  uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
   1058  ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
   1059  uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
   1060 
   1061  rtcp_transceiver.SendFullIntraRequest(kOneRemoteSsrc, true);
   1062  ASSERT_EQ(rtcp_parser.fir()->requests().size(), 1u);
   1063  ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
   1064  EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 1);
   1065 
   1066  rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
   1067  ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
   1068  ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
   1069  EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 2);
   1070  ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
   1071  EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1 + 1);
   1072 }
   1073 
   1074 TEST_F(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
   1075  RtcpTransceiverConfig config = DefaultTestConfig();
   1076  config.schedule_periodic_compound_packets = false;
   1077  RtcpPacketParser rtcp_parser;
   1078  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1079  RtcpTransceiverImpl rtcp_transceiver(config);
   1080 
   1081  const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
   1082 
   1083  rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
   1084  ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
   1085  ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
   1086  uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
   1087  ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
   1088  uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
   1089 
   1090  rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, false);
   1091  ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
   1092  ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
   1093  EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0);
   1094  ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
   1095  EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1);
   1096 }
   1097 
   1098 TEST_F(RtcpTransceiverImplTest, ReceivesFir) {
   1099  static constexpr uint32_t kRemoteSsrc = 4321;
   1100  static constexpr uint32_t kMediaSsrc1 = 1234;
   1101  static constexpr uint32_t kMediaSsrc2 = 1235;
   1102  RtcpTransceiverConfig config = DefaultTestConfig();
   1103  RtcpTransceiverImpl rtcp_transceiver(config);
   1104 
   1105  MockRtpStreamRtcpHandler local_stream1;
   1106  MockRtpStreamRtcpHandler local_stream2;
   1107  EXPECT_CALL(local_stream1, OnFir(kRemoteSsrc));
   1108  EXPECT_CALL(local_stream2, OnFir).Times(0);
   1109 
   1110  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
   1111  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
   1112 
   1113  rtcp::Fir fir;
   1114  fir.SetSenderSsrc(kRemoteSsrc);
   1115  fir.AddRequestTo(kMediaSsrc1, /*seq_num=*/13);
   1116 
   1117  rtcp_transceiver.ReceivePacket(fir.Build(), config.clock->CurrentTime());
   1118 }
   1119 
   1120 TEST_F(RtcpTransceiverImplTest, IgnoresReceivedFirWithRepeatedSequenceNumber) {
   1121  static constexpr uint32_t kRemoteSsrc = 4321;
   1122  static constexpr uint32_t kMediaSsrc1 = 1234;
   1123  static constexpr uint32_t kMediaSsrc2 = 1235;
   1124  RtcpTransceiverConfig config = DefaultTestConfig();
   1125  RtcpTransceiverImpl rtcp_transceiver(config);
   1126 
   1127  MockRtpStreamRtcpHandler local_stream1;
   1128  MockRtpStreamRtcpHandler local_stream2;
   1129  EXPECT_CALL(local_stream1, OnFir(kRemoteSsrc)).Times(1);
   1130  EXPECT_CALL(local_stream2, OnFir(kRemoteSsrc)).Times(2);
   1131 
   1132  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
   1133  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc2, &local_stream2));
   1134 
   1135  rtcp::Fir fir1;
   1136  fir1.SetSenderSsrc(kRemoteSsrc);
   1137  fir1.AddRequestTo(kMediaSsrc1, /*seq_num=*/132);
   1138  fir1.AddRequestTo(kMediaSsrc2, /*seq_num=*/10);
   1139  rtcp_transceiver.ReceivePacket(fir1.Build(), config.clock->CurrentTime());
   1140 
   1141  // Repeat request for MediaSsrc1 - expect it to be ignored,
   1142  // Change FIR sequence number for MediaSsrc2 - expect a 2nd callback.
   1143  rtcp::Fir fir2;
   1144  fir2.SetSenderSsrc(kRemoteSsrc);
   1145  fir2.AddRequestTo(kMediaSsrc1, /*seq_num=*/132);
   1146  fir2.AddRequestTo(kMediaSsrc2, /*seq_num=*/13);
   1147  rtcp_transceiver.ReceivePacket(fir2.Build(), config.clock->CurrentTime());
   1148 }
   1149 
   1150 TEST_F(RtcpTransceiverImplTest, ReceivedFirTracksSequenceNumberPerRemoteSsrc) {
   1151  static constexpr uint32_t kRemoteSsrc1 = 4321;
   1152  static constexpr uint32_t kRemoteSsrc2 = 4323;
   1153  static constexpr uint32_t kMediaSsrc = 1234;
   1154  RtcpTransceiverConfig config = DefaultTestConfig();
   1155  RtcpTransceiverImpl rtcp_transceiver(config);
   1156 
   1157  MockRtpStreamRtcpHandler local_stream;
   1158  EXPECT_CALL(local_stream, OnFir(kRemoteSsrc1));
   1159  EXPECT_CALL(local_stream, OnFir(kRemoteSsrc2));
   1160 
   1161  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc, &local_stream));
   1162 
   1163  rtcp::Fir fir1;
   1164  fir1.SetSenderSsrc(kRemoteSsrc1);
   1165  fir1.AddRequestTo(kMediaSsrc, /*seq_num=*/13);
   1166  rtcp_transceiver.ReceivePacket(fir1.Build(), config.clock->CurrentTime());
   1167 
   1168  // Use the same FIR sequence number, but different sender SSRC.
   1169  rtcp::Fir fir2;
   1170  fir2.SetSenderSsrc(kRemoteSsrc2);
   1171  fir2.AddRequestTo(kMediaSsrc, /*seq_num=*/13);
   1172  rtcp_transceiver.ReceivePacket(fir2.Build(), config.clock->CurrentTime());
   1173 }
   1174 
   1175 TEST_F(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
   1176  const uint32_t kRemoteSsrcs[] = {4321};
   1177  RtcpTransceiverConfig config = DefaultTestConfig();
   1178  // Turn periodic off to ensure sent rtcp packet is explicitly requested.
   1179  config.schedule_periodic_compound_packets = false;
   1180  RtcpPacketParser rtcp_parser;
   1181  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1182 
   1183  config.rtcp_mode = RtcpMode::kCompound;
   1184 
   1185  RtcpTransceiverImpl rtcp_transceiver(config);
   1186  rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
   1187 
   1188  // Test sent packet is compound by expecting presense of receiver report.
   1189  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
   1190  EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
   1191 }
   1192 
   1193 TEST_F(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
   1194  const uint32_t kRemoteSsrcs[] = {4321};
   1195  RtcpTransceiverConfig config = DefaultTestConfig();
   1196  // Turn periodic off to ensure sent rtcp packet is explicitly requested.
   1197  config.schedule_periodic_compound_packets = false;
   1198  RtcpPacketParser rtcp_parser;
   1199  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1200 
   1201  config.rtcp_mode = RtcpMode::kReducedSize;
   1202 
   1203  RtcpTransceiverImpl rtcp_transceiver(config);
   1204  rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
   1205 
   1206  // Test sent packet is reduced size by expecting absense of receiver report.
   1207  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
   1208  EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
   1209 }
   1210 
   1211 TEST_F(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
   1212  const uint32_t kSenderSsrc = 4321;
   1213  RtcpTransceiverConfig config = DefaultTestConfig();
   1214  config.feedback_ssrc = kSenderSsrc;
   1215  config.schedule_periodic_compound_packets = false;
   1216  RtcpPacketParser rtcp_parser;
   1217  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1218  config.non_sender_rtt_measurement = true;
   1219  RtcpTransceiverImpl rtcp_transceiver(config);
   1220 
   1221  rtcp_transceiver.SendCompoundPacket();
   1222  NtpTime ntp_time_now = config.clock->CurrentNtpTime();
   1223 
   1224  EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
   1225  EXPECT_EQ(rtcp_parser.xr()->sender_ssrc(), kSenderSsrc);
   1226  ASSERT_TRUE(rtcp_parser.xr()->rrtr());
   1227  EXPECT_EQ(rtcp_parser.xr()->rrtr()->ntp(), ntp_time_now);
   1228 }
   1229 
   1230 TEST_F(RtcpTransceiverImplTest, RepliesToRrtrWhenEnabled) {
   1231  static constexpr uint32_t kSenderSsrc[] = {4321, 9876};
   1232  RtcpTransceiverConfig config = DefaultTestConfig();
   1233  config.reply_to_non_sender_rtt_measurement = true;
   1234  RtcpPacketParser rtcp_parser;
   1235  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1236  RtcpTransceiverImpl rtcp_transceiver(config);
   1237 
   1238  rtcp::ExtendedReports xr;
   1239  rtcp::Rrtr rrtr;
   1240  rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
   1241  xr.SetRrtr(rrtr);
   1242  xr.SetSenderSsrc(kSenderSsrc[0]);
   1243  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
   1244  AdvanceTime(TimeDelta::Millis(1'500));
   1245 
   1246  rrtr.SetNtp(NtpTime(uint64_t{0x4444'5555'6666'7777}));
   1247  xr.SetRrtr(rrtr);
   1248  xr.SetSenderSsrc(kSenderSsrc[1]);
   1249  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
   1250  AdvanceTime(TimeDelta::Millis(500));
   1251 
   1252  rtcp_transceiver.SendCompoundPacket();
   1253 
   1254  EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
   1255  static constexpr uint32_t kComactNtpOneSecond = 0x0001'0000;
   1256  EXPECT_THAT(rtcp_parser.xr()->dlrr().sub_blocks(),
   1257              UnorderedElementsAre(
   1258                  rtcp::ReceiveTimeInfo(kSenderSsrc[0], 0x2222'3333,
   1259                                        /*delay=*/2 * kComactNtpOneSecond),
   1260                  rtcp::ReceiveTimeInfo(kSenderSsrc[1], 0x5555'6666,
   1261                                        /*delay=*/kComactNtpOneSecond / 2)));
   1262 }
   1263 
   1264 TEST_F(RtcpTransceiverImplTest, CanReplyToRrtrOnceForAllLocalSsrcs) {
   1265  static constexpr uint32_t kRemoteSsrc = 4321;
   1266  static constexpr uint32_t kLocalSsrcs[] = {1234, 5678};
   1267  RtcpTransceiverConfig config = DefaultTestConfig();
   1268  config.reply_to_non_sender_rtt_measurement = true;
   1269  config.reply_to_non_sender_rtt_mesaurments_on_all_ssrcs = false;
   1270  RtcpPacketParser rtcp_parser;
   1271  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1272  RtcpTransceiverImpl rtcp_transceiver(config);
   1273 
   1274  MockRtpStreamRtcpHandler local_sender0;
   1275  MockRtpStreamRtcpHandler local_sender1;
   1276  rtcp_transceiver.AddMediaSender(kLocalSsrcs[0], &local_sender0);
   1277  rtcp_transceiver.AddMediaSender(kLocalSsrcs[1], &local_sender1);
   1278 
   1279  rtcp::ExtendedReports xr;
   1280  rtcp::Rrtr rrtr;
   1281  rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
   1282  xr.SetRrtr(rrtr);
   1283  xr.SetSenderSsrc(kRemoteSsrc);
   1284  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
   1285  AdvanceTime(TimeDelta::Millis(1'500));
   1286 
   1287  rtcp_transceiver.SendCompoundPacket();
   1288 
   1289  EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
   1290 }
   1291 
   1292 TEST_F(RtcpTransceiverImplTest, CanReplyToRrtrForEachLocalSsrc) {
   1293  static constexpr uint32_t kRemoteSsrc = 4321;
   1294  static constexpr uint32_t kLocalSsrc[] = {1234, 5678};
   1295  RtcpTransceiverConfig config = DefaultTestConfig();
   1296  config.reply_to_non_sender_rtt_measurement = true;
   1297  config.reply_to_non_sender_rtt_mesaurments_on_all_ssrcs = true;
   1298  RtcpPacketParser rtcp_parser;
   1299  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1300  RtcpTransceiverImpl rtcp_transceiver(config);
   1301 
   1302  MockRtpStreamRtcpHandler local_sender0;
   1303  MockRtpStreamRtcpHandler local_sender1;
   1304  rtcp_transceiver.AddMediaSender(kLocalSsrc[0], &local_sender0);
   1305  rtcp_transceiver.AddMediaSender(kLocalSsrc[1], &local_sender1);
   1306 
   1307  rtcp::ExtendedReports xr;
   1308  rtcp::Rrtr rrtr;
   1309  rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
   1310  xr.SetRrtr(rrtr);
   1311  xr.SetSenderSsrc(kRemoteSsrc);
   1312  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
   1313  AdvanceTime(TimeDelta::Millis(1'500));
   1314 
   1315  rtcp_transceiver.SendCompoundPacket();
   1316 
   1317  EXPECT_EQ(rtcp_parser.xr()->num_packets(), 2);
   1318 }
   1319 
   1320 TEST_F(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
   1321  RtcpTransceiverConfig config = DefaultTestConfig();
   1322  config.schedule_periodic_compound_packets = false;
   1323  RtcpPacketParser rtcp_parser;
   1324  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1325  config.non_sender_rtt_measurement = false;
   1326  RtcpTransceiverImpl rtcp_transceiver(config);
   1327 
   1328  rtcp_transceiver.SendCompoundPacket();
   1329 
   1330  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
   1331  // Extended reports rtcp packet might be included for another reason,
   1332  // but it shouldn't contain rrtr block.
   1333  EXPECT_FALSE(rtcp_parser.xr()->rrtr());
   1334 }
   1335 
   1336 TEST_F(RtcpTransceiverImplTest, PassRttFromDlrrToLinkObserver) {
   1337  const uint32_t kSenderSsrc = 4321;
   1338  MockNetworkLinkRtcpObserver link_observer;
   1339  RtcpTransceiverConfig config = DefaultTestConfig();
   1340  config.feedback_ssrc = kSenderSsrc;
   1341  config.network_link_observer = &link_observer;
   1342  config.non_sender_rtt_measurement = true;
   1343  RtcpTransceiverImpl rtcp_transceiver(config);
   1344 
   1345  Timestamp send_time = Timestamp::Seconds(5678);
   1346  Timestamp receive_time = send_time + TimeDelta::Millis(110);
   1347  rtcp::ReceiveTimeInfo rti;
   1348  rti.ssrc = kSenderSsrc;
   1349  rti.last_rr = CompactNtp(config.clock->ConvertTimestampToNtpTime(send_time));
   1350  rti.delay_since_last_rr = SaturatedToCompactNtp(TimeDelta::Millis(10));
   1351  rtcp::ExtendedReports xr;
   1352  xr.AddDlrrItem(rti);
   1353 
   1354  EXPECT_CALL(link_observer,
   1355              OnRttUpdate(receive_time, Near(TimeDelta::Millis(100))));
   1356  rtcp_transceiver.ReceivePacket(xr.Build(), receive_time);
   1357 }
   1358 
   1359 TEST_F(RtcpTransceiverImplTest, CalculatesRoundTripTimeFromReportBlocks) {
   1360  MockNetworkLinkRtcpObserver link_observer;
   1361  RtcpTransceiverConfig config = DefaultTestConfig();
   1362  config.network_link_observer = &link_observer;
   1363  RtcpTransceiverImpl rtcp_transceiver(config);
   1364 
   1365  TimeDelta rtt = TimeDelta::Millis(100);
   1366  Timestamp send_time = Timestamp::Seconds(5678);
   1367  Timestamp receive_time = send_time + TimeDelta::Millis(110);
   1368  rtcp::ReceiverReport rr;
   1369  rtcp::ReportBlock rb1;
   1370  rb1.SetLastSr(CompactNtp(config.clock->ConvertTimestampToNtpTime(
   1371      receive_time - rtt - TimeDelta::Millis(10))));
   1372  rb1.SetDelayLastSr(SaturatedToCompactNtp(TimeDelta::Millis(10)));
   1373  rr.AddReportBlock(rb1);
   1374  rtcp::ReportBlock rb2;
   1375  rb2.SetLastSr(CompactNtp(config.clock->ConvertTimestampToNtpTime(
   1376      receive_time - rtt - TimeDelta::Millis(20))));
   1377  rb2.SetDelayLastSr(SaturatedToCompactNtp(TimeDelta::Millis(20)));
   1378  rr.AddReportBlock(rb2);
   1379 
   1380  EXPECT_CALL(link_observer, OnRttUpdate(receive_time, Near(rtt)));
   1381  rtcp_transceiver.ReceivePacket(rr.Build(), receive_time);
   1382 }
   1383 
   1384 TEST_F(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
   1385  const uint32_t kSenderSsrc = 4321;
   1386  const uint32_t kUnknownSsrc = 4322;
   1387  MockNetworkLinkRtcpObserver link_observer;
   1388  RtcpTransceiverConfig config = DefaultTestConfig();
   1389  config.feedback_ssrc = kSenderSsrc;
   1390  config.schedule_periodic_compound_packets = false;
   1391  config.non_sender_rtt_measurement = true;
   1392  config.network_link_observer = &link_observer;
   1393  RtcpTransceiverImpl rtcp_transceiver(config);
   1394 
   1395  Timestamp time = Timestamp::Micros(12345678);
   1396  rtcp::ReceiveTimeInfo rti;
   1397  rti.ssrc = kUnknownSsrc;
   1398  rti.last_rr = CompactNtp(config.clock->ConvertTimestampToNtpTime(time));
   1399  rtcp::ExtendedReports xr;
   1400  xr.AddDlrrItem(rti);
   1401  auto raw_packet = xr.Build();
   1402 
   1403  EXPECT_CALL(link_observer, OnRttUpdate).Times(0);
   1404  rtcp_transceiver.ReceivePacket(raw_packet, time + TimeDelta::Millis(100));
   1405 }
   1406 
   1407 TEST_F(RtcpTransceiverImplTest, ParsesTransportFeedback) {
   1408  MockNetworkLinkRtcpObserver link_observer;
   1409  RtcpTransceiverConfig config = DefaultTestConfig();
   1410  config.network_link_observer = &link_observer;
   1411  Timestamp receive_time = Timestamp::Seconds(5678);
   1412  RtcpTransceiverImpl rtcp_transceiver(config);
   1413 
   1414  EXPECT_CALL(link_observer, OnTransportFeedback(receive_time, _))
   1415      .WillOnce(WithArg<1>([](const rtcp::TransportFeedback& message) {
   1416        EXPECT_EQ(message.GetBaseSequence(), 321);
   1417        EXPECT_THAT(message.GetReceivedPackets(), SizeIs(2));
   1418      }));
   1419 
   1420  rtcp::TransportFeedback tb;
   1421  tb.SetBase(/*base_sequence=*/321, Timestamp::Micros(15));
   1422  tb.AddReceivedPacket(/*base_sequence=*/321, Timestamp::Micros(15));
   1423  tb.AddReceivedPacket(/*base_sequence=*/322, Timestamp::Micros(17));
   1424  rtcp_transceiver.ReceivePacket(tb.Build(), receive_time);
   1425 }
   1426 
   1427 TEST_F(RtcpTransceiverImplTest, ParsesCongestionControlFeedback) {
   1428  MockNetworkLinkRtcpObserver link_observer;
   1429  RtcpTransceiverConfig config = DefaultTestConfig();
   1430  config.network_link_observer = &link_observer;
   1431  const uint32_t receive_time_ntp = 5678;
   1432  Timestamp receive_time = Timestamp::Seconds(9843);
   1433  RtcpTransceiverImpl rtcp_transceiver(config);
   1434 
   1435  EXPECT_CALL(link_observer, OnCongestionControlFeedback(receive_time, _))
   1436      .WillOnce(WithArg<1>([](const rtcp::CongestionControlFeedback& message) {
   1437        EXPECT_EQ(message.report_timestamp_compact_ntp(), 5678u);
   1438        EXPECT_THAT(message.packets(), SizeIs(2));
   1439      }));
   1440 
   1441  std::vector<rtcp::CongestionControlFeedback::PacketInfo> packets = {
   1442      {.ssrc = 1,
   1443       .sequence_number = 321,
   1444       .arrival_time_offset = TimeDelta::Millis(15)},
   1445      {.ssrc = 1,
   1446       .sequence_number = 322,
   1447       .arrival_time_offset = TimeDelta::Millis(17)}};
   1448  rtcp::CongestionControlFeedback ccfb(std::move(packets), receive_time_ntp);
   1449  rtcp_transceiver.ReceivePacket(ccfb.Build(), receive_time);
   1450 }
   1451 
   1452 TEST_F(RtcpTransceiverImplTest, ParsesRemb) {
   1453  MockNetworkLinkRtcpObserver link_observer;
   1454  RtcpTransceiverConfig config = DefaultTestConfig();
   1455  config.network_link_observer = &link_observer;
   1456  Timestamp receive_time = Timestamp::Seconds(5678);
   1457  RtcpTransceiverImpl rtcp_transceiver(config);
   1458 
   1459  EXPECT_CALL(link_observer,
   1460              OnReceiverEstimatedMaxBitrate(receive_time,
   1461                                            DataRate::BitsPerSec(1'234'000)));
   1462 
   1463  rtcp::Remb remb;
   1464  remb.SetBitrateBps(1'234'000);
   1465  rtcp_transceiver.ReceivePacket(remb.Build(), receive_time);
   1466 }
   1467 
   1468 TEST_F(RtcpTransceiverImplTest,
   1469       CombinesReportBlocksFromSenderAndRecieverReports) {
   1470  MockNetworkLinkRtcpObserver link_observer;
   1471  RtcpTransceiverConfig config = DefaultTestConfig();
   1472  config.network_link_observer = &link_observer;
   1473  Timestamp receive_time = Timestamp::Seconds(5678);
   1474  RtcpTransceiverImpl rtcp_transceiver(config);
   1475 
   1476  // Assemble compound packet with multiple rtcp packets in it.
   1477  rtcp::CompoundPacket packet;
   1478  auto sr = std::make_unique<rtcp::SenderReport>();
   1479  sr->SetSenderSsrc(1234);
   1480  sr->SetReportBlocks(std::vector<ReportBlock>(31));
   1481  packet.Append(std::move(sr));
   1482  auto rr1 = std::make_unique<rtcp::ReceiverReport>();
   1483  rr1->SetReportBlocks(std::vector<ReportBlock>(31));
   1484  packet.Append(std::move(rr1));
   1485  auto rr2 = std::make_unique<rtcp::ReceiverReport>();
   1486  rr2->SetReportBlocks(std::vector<ReportBlock>(2));
   1487  packet.Append(std::move(rr2));
   1488 
   1489  EXPECT_CALL(link_observer, OnReport(receive_time, SizeIs(64)));
   1490 
   1491  rtcp_transceiver.ReceivePacket(packet.Build(), receive_time);
   1492 }
   1493 
   1494 TEST_F(RtcpTransceiverImplTest,
   1495       CallbackOnReportBlocksFromSenderAndReceiverReports) {
   1496  static constexpr uint32_t kRemoteSsrc = 5678;
   1497  // Has registered sender, report block attached to sender report.
   1498  static constexpr uint32_t kMediaSsrc1 = 1234;
   1499  // No registered sender, report block attached to receiver report.
   1500  // Such report block shouldn't prevent handling following report block.
   1501  static constexpr uint32_t kMediaSsrc2 = 1235;
   1502  // Has registered sender, no report block attached.
   1503  static constexpr uint32_t kMediaSsrc3 = 1236;
   1504  // Has registered sender, report block attached to receiver report.
   1505  static constexpr uint32_t kMediaSsrc4 = 1237;
   1506 
   1507  MockNetworkLinkRtcpObserver link_observer;
   1508  RtcpTransceiverConfig config = DefaultTestConfig();
   1509  Timestamp receive_time = Timestamp::Seconds(5678);
   1510  RtcpTransceiverImpl rtcp_transceiver(config);
   1511 
   1512  MockRtpStreamRtcpHandler local_stream1;
   1513  MockRtpStreamRtcpHandler local_stream3;
   1514  MockRtpStreamRtcpHandler local_stream4;
   1515  EXPECT_CALL(local_stream1,
   1516              OnReport(Property(&ReportBlockData::sender_ssrc, kRemoteSsrc)));
   1517  EXPECT_CALL(local_stream3, OnReport).Times(0);
   1518  EXPECT_CALL(local_stream4,
   1519              OnReport(Property(&ReportBlockData::sender_ssrc, kRemoteSsrc)));
   1520 
   1521  ASSERT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc1, &local_stream1));
   1522  ASSERT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc3, &local_stream3));
   1523  ASSERT_TRUE(rtcp_transceiver.AddMediaSender(kMediaSsrc4, &local_stream4));
   1524 
   1525  // Assemble compound packet with multiple RTCP packets in it.
   1526  rtcp::CompoundPacket packet;
   1527  auto sr = std::make_unique<rtcp::SenderReport>();
   1528  sr->SetSenderSsrc(kRemoteSsrc);
   1529  std::vector<ReportBlock> rb(1);
   1530  rb[0].SetMediaSsrc(kMediaSsrc1);
   1531  sr->SetReportBlocks(std::move(rb));
   1532  packet.Append(std::move(sr));
   1533  auto rr = std::make_unique<rtcp::ReceiverReport>();
   1534  rr->SetSenderSsrc(kRemoteSsrc);
   1535  rb = std::vector<ReportBlock>(2);
   1536  rb[0].SetMediaSsrc(kMediaSsrc2);
   1537  rb[1].SetMediaSsrc(kMediaSsrc4);
   1538  rr->SetReportBlocks(std::move(rb));
   1539  packet.Append(std::move(rr));
   1540 
   1541  rtcp_transceiver.ReceivePacket(packet.Build(), receive_time);
   1542 }
   1543 
   1544 TEST_F(RtcpTransceiverImplTest, FailsToRegisterTwoSendersWithTheSameSsrc) {
   1545  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
   1546  MockRtpStreamRtcpHandler sender1;
   1547  MockRtpStreamRtcpHandler sender2;
   1548 
   1549  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(/*local_ssrc=*/10001, &sender1));
   1550  EXPECT_FALSE(rtcp_transceiver.AddMediaSender(/*local_ssrc=*/10001, &sender2));
   1551  EXPECT_TRUE(rtcp_transceiver.AddMediaSender(/*local_ssrc=*/10002, &sender2));
   1552 
   1553  EXPECT_TRUE(rtcp_transceiver.RemoveMediaSender(/*local_ssrc=*/10001));
   1554  EXPECT_FALSE(rtcp_transceiver.RemoveMediaSender(/*local_ssrc=*/10001));
   1555 }
   1556 
   1557 TEST_F(RtcpTransceiverImplTest, SendsSenderReport) {
   1558  static constexpr uint32_t kFeedbackSsrc = 123;
   1559  static constexpr uint32_t kSenderSsrc = 12345;
   1560  RtcpTransceiverConfig config = DefaultTestConfig();
   1561  config.feedback_ssrc = kFeedbackSsrc;
   1562  RtcpPacketParser rtcp_parser;
   1563  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1564  config.schedule_periodic_compound_packets = false;
   1565  RtcpTransceiverImpl rtcp_transceiver(config);
   1566 
   1567  RtpStreamRtcpHandler::RtpStats sender_stats;
   1568  sender_stats.set_num_sent_packets(10);
   1569  sender_stats.set_num_sent_bytes(1000);
   1570  sender_stats.set_last_rtp_timestamp(0x3333);
   1571  sender_stats.set_last_capture_time(CurrentTime() - TimeDelta::Seconds(2));
   1572  sender_stats.set_last_clock_rate(0x1000);
   1573  MockRtpStreamRtcpHandler sender;
   1574  ON_CALL(sender, SentStats).WillByDefault(Return(sender_stats));
   1575  rtcp_transceiver.AddMediaSender(kSenderSsrc, &sender);
   1576 
   1577  rtcp_transceiver.SendCompoundPacket();
   1578 
   1579  ASSERT_GT(rtcp_parser.sender_report()->num_packets(), 0);
   1580  EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc);
   1581  EXPECT_EQ(rtcp_parser.sender_report()->ntp(),
   1582            time_controller().GetClock()->CurrentNtpTime());
   1583  EXPECT_EQ(rtcp_parser.sender_report()->rtp_timestamp(), 0x3333u + 0x2000u);
   1584  EXPECT_EQ(rtcp_parser.sender_report()->sender_packet_count(), 10u);
   1585  EXPECT_EQ(rtcp_parser.sender_report()->sender_octet_count(), 1000u);
   1586 }
   1587 
   1588 TEST_F(RtcpTransceiverImplTest,
   1589       MaySendBothSenderReportAndReceiverReportInTheSamePacket) {
   1590  RtcpPacketParser rtcp_parser;
   1591  std::vector<ReportBlock> statistics_report_blocks(40);
   1592  MockReceiveStatisticsProvider receive_statistics;
   1593  EXPECT_CALL(receive_statistics, RtcpReportBlocks(/*max_blocks=*/Ge(40u)))
   1594      .WillOnce(Return(statistics_report_blocks));
   1595  RtcpTransceiverConfig config = DefaultTestConfig();
   1596  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1597  config.receive_statistics = &receive_statistics;
   1598  RtcpTransceiverImpl rtcp_transceiver(config);
   1599 
   1600  MockRtpStreamRtcpHandler sender;
   1601  rtcp_transceiver.AddMediaSender(/*ssrc=*/12345, &sender);
   1602 
   1603  rtcp_transceiver.SendCompoundPacket();
   1604 
   1605  // Expect a single RTCP packet with a sender and a receiver reports in it.
   1606  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
   1607  ASSERT_EQ(rtcp_parser.sender_report()->num_packets(), 1);
   1608  ASSERT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
   1609  // Sender report may contain up to 31 report blocks, thus remaining 9 report
   1610  // block should be attached to the receiver report.
   1611  EXPECT_THAT(rtcp_parser.sender_report()->report_blocks(), SizeIs(31));
   1612  EXPECT_THAT(rtcp_parser.receiver_report()->report_blocks(), SizeIs(9));
   1613 }
   1614 
   1615 TEST_F(RtcpTransceiverImplTest, RotatesSendersWhenAllSenderReportDoNotFit) {
   1616  // Send 6 compound packet, each should contain 5 sender reports,
   1617  // each of 6 senders should be mentioned 5 times.
   1618  static constexpr int kNumSenders = 6;
   1619  static constexpr uint32_t kSenderSsrc[kNumSenders] = {10, 20, 30, 40, 50, 60};
   1620  static constexpr int kSendersPerPacket = 5;
   1621  // RtcpPacketParser remembers only latest block for each type, but this test
   1622  // is about sending multiple sender reports in the same packet, thus need
   1623  // a more advance parser: RtcpTranceiver
   1624  RtcpTransceiverConfig receiver_config = DefaultTestConfig();
   1625  RtcpTransceiverImpl rtcp_receiver(receiver_config);
   1626  // Main expectatation: all senders are spread equally across multiple packets.
   1627  NiceMock<MockMediaReceiverRtcpObserver> receiver[kNumSenders];
   1628  for (int i = 0; i < kNumSenders; ++i) {
   1629    SCOPED_TRACE(i);
   1630    EXPECT_CALL(receiver[i], OnSenderReport(kSenderSsrc[i], _, _))
   1631        .Times(kSendersPerPacket);
   1632    rtcp_receiver.AddMediaReceiverRtcpObserver(kSenderSsrc[i], &receiver[i]);
   1633  }
   1634 
   1635  MockFunction<void(ArrayView<const uint8_t>)> transport;
   1636  EXPECT_CALL(transport, Call)
   1637      .Times(kNumSenders)
   1638      .WillRepeatedly([&](ArrayView<const uint8_t> packet) {
   1639        rtcp_receiver.ReceivePacket(packet, CurrentTime());
   1640        return true;
   1641      });
   1642  RtcpTransceiverConfig config = DefaultTestConfig();
   1643  config.rtcp_transport = transport.AsStdFunction();
   1644  // Limit packet to have space just for kSendersPerPacket sender reports.
   1645  // Sender report without report blocks require 28 bytes.
   1646  config.max_packet_size = kSendersPerPacket * 28;
   1647  RtcpTransceiverImpl rtcp_transceiver(config);
   1648  NiceMock<MockRtpStreamRtcpHandler> sender[kNumSenders];
   1649  for (int i = 0; i < kNumSenders; ++i) {
   1650    rtcp_transceiver.AddMediaSender(kSenderSsrc[i], &sender[i]);
   1651  }
   1652 
   1653  for (int i = 1; i <= kNumSenders; ++i) {
   1654    SCOPED_TRACE(i);
   1655    rtcp_transceiver.SendCompoundPacket();
   1656  }
   1657 }
   1658 
   1659 TEST_F(RtcpTransceiverImplTest, SkipsSenderReportForInactiveSender) {
   1660  static constexpr uint32_t kSenderSsrc[] = {12345, 23456};
   1661  RtcpTransceiverConfig config = DefaultTestConfig();
   1662  RtcpPacketParser rtcp_parser;
   1663  config.rtcp_transport = RtcpParserTransport(rtcp_parser);
   1664  RtcpTransceiverImpl rtcp_transceiver(config);
   1665 
   1666  RtpStreamRtcpHandler::RtpStats sender_stats[2];
   1667  NiceMock<MockRtpStreamRtcpHandler> sender[2];
   1668  ON_CALL(sender[0], SentStats).WillByDefault([&] { return sender_stats[0]; });
   1669  ON_CALL(sender[1], SentStats).WillByDefault([&] { return sender_stats[1]; });
   1670  rtcp_transceiver.AddMediaSender(kSenderSsrc[0], &sender[0]);
   1671  rtcp_transceiver.AddMediaSender(kSenderSsrc[1], &sender[1]);
   1672 
   1673  // Start with both senders beeing active.
   1674  sender_stats[0].set_num_sent_packets(10);
   1675  sender_stats[0].set_num_sent_bytes(1'000);
   1676  sender_stats[1].set_num_sent_packets(5);
   1677  sender_stats[1].set_num_sent_bytes(2'000);
   1678  rtcp_transceiver.SendCompoundPacket();
   1679  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{1});
   1680  EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 2);
   1681 
   1682  // Keep 1st sender active, but make 2nd second look inactive by returning the
   1683  // same RtpStats.
   1684  sender_stats[0].set_num_sent_packets(15);
   1685  sender_stats[0].set_num_sent_bytes(2'000);
   1686  rtcp_transceiver.SendCompoundPacket();
   1687  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{2});
   1688  EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 3);
   1689  EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc[0]);
   1690 
   1691  // Swap active sender.
   1692  sender_stats[1].set_num_sent_packets(20);
   1693  sender_stats[1].set_num_sent_bytes(3'000);
   1694  rtcp_transceiver.SendCompoundPacket();
   1695  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{3});
   1696  EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 4);
   1697  EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc[1]);
   1698 
   1699  // Activate both senders again.
   1700  sender_stats[0].set_num_sent_packets(20);
   1701  sender_stats[0].set_num_sent_bytes(3'000);
   1702  sender_stats[1].set_num_sent_packets(25);
   1703  sender_stats[1].set_num_sent_bytes(3'500);
   1704  rtcp_transceiver.SendCompoundPacket();
   1705  EXPECT_EQ(rtcp_parser.processed_rtcp_packets(), size_t{4});
   1706  EXPECT_EQ(rtcp_parser.sender_report()->num_packets(), 6);
   1707 }
   1708 
   1709 }  // namespace
   1710 }  // namespace webrtc
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE