1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "modules/rtp_rtcp/source/rtcp_sender.h"
12 
13 #include <memory>
14 #include <utility>
15 
16 #include "absl/base/macros.h"
17 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
18 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
19 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
20 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
21 #include "modules/rtp_rtcp/source/rtp_rtcp_impl.h"
22 #include "modules/rtp_rtcp/source/time_util.h"
23 #include "rtc_base/rate_limiter.h"
24 #include "test/gmock.h"
25 #include "test/gtest.h"
26 #include "test/mock_transport.h"
27 #include "test/rtcp_packet_parser.h"
28 
29 using ::testing::_;
30 using ::testing::ElementsAre;
31 using ::testing::Invoke;
32 using ::testing::SizeIs;
33 
34 namespace webrtc {
35 
36 class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver {
37  public:
RtcpPacketTypeCounterObserverImpl()38   RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {}
39   ~RtcpPacketTypeCounterObserverImpl() override = default;
RtcpPacketTypesCounterUpdated(uint32_t ssrc,const RtcpPacketTypeCounter & packet_counter)40   void RtcpPacketTypesCounterUpdated(
41       uint32_t ssrc,
42       const RtcpPacketTypeCounter& packet_counter) override {
43     ssrc_ = ssrc;
44     counter_ = packet_counter;
45   }
46   uint32_t ssrc_;
47   RtcpPacketTypeCounter counter_;
48 };
49 
50 class TestTransport : public Transport {
51  public:
TestTransport()52   TestTransport() {}
53 
SendRtp(const uint8_t *,size_t,const PacketOptions & options)54   bool SendRtp(const uint8_t* /*data*/,
55                size_t /*len*/,
56                const PacketOptions& options) override {
57     return false;
58   }
SendRtcp(const uint8_t * data,size_t len)59   bool SendRtcp(const uint8_t* data, size_t len) override {
60     parser_.Parse(data, len);
61     return true;
62   }
63   test::RtcpPacketParser parser_;
64 };
65 
66 namespace {
67 static const uint32_t kSenderSsrc = 0x11111111;
68 static const uint32_t kRemoteSsrc = 0x22222222;
69 static const uint32_t kStartRtpTimestamp = 0x34567;
70 static const uint32_t kRtpTimestamp = 0x45678;
71 }  // namespace
72 
73 class RtcpSenderTest : public ::testing::Test {
74  protected:
RtcpSenderTest()75   RtcpSenderTest()
76       : clock_(1335900000),
77         receive_statistics_(ReceiveStatistics::Create(&clock_)),
78         retransmission_rate_limiter_(&clock_, 1000) {
79     RtpRtcp::Configuration configuration = GetDefaultConfig();
80     rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration));
81     rtcp_sender_.reset(new RTCPSender(configuration));
82     rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
83     rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
84     rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
85                                  /*payload_type=*/0);
86   }
87 
GetDefaultConfig()88   RtpRtcp::Configuration GetDefaultConfig() {
89     RtpRtcp::Configuration configuration;
90     configuration.audio = false;
91     configuration.clock = &clock_;
92     configuration.outgoing_transport = &test_transport_;
93     configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
94     configuration.rtcp_report_interval_ms = 1000;
95     configuration.receive_statistics = receive_statistics_.get();
96     configuration.local_media_ssrc = kSenderSsrc;
97     return configuration;
98   }
99 
InsertIncomingPacket(uint32_t remote_ssrc,uint16_t seq_num)100   void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) {
101     RtpPacketReceived packet;
102     packet.SetSsrc(remote_ssrc);
103     packet.SetSequenceNumber(seq_num);
104     packet.SetTimestamp(12345);
105     packet.SetPayloadSize(100 - 12);
106     receive_statistics_->OnRtpPacket(packet);
107   }
108 
parser()109   test::RtcpPacketParser* parser() { return &test_transport_.parser_; }
110 
feedback_state()111   RTCPSender::FeedbackState feedback_state() {
112     return rtp_rtcp_impl_->GetFeedbackState();
113   }
114 
115   SimulatedClock clock_;
116   TestTransport test_transport_;
117   std::unique_ptr<ReceiveStatistics> receive_statistics_;
118   std::unique_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_;
119   std::unique_ptr<RTCPSender> rtcp_sender_;
120   RateLimiter retransmission_rate_limiter_;
121 };
122 
TEST_F(RtcpSenderTest,SetRtcpStatus)123 TEST_F(RtcpSenderTest, SetRtcpStatus) {
124   EXPECT_EQ(RtcpMode::kOff, rtcp_sender_->Status());
125   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
126   EXPECT_EQ(RtcpMode::kReducedSize, rtcp_sender_->Status());
127 }
128 
TEST_F(RtcpSenderTest,SetSendingStatus)129 TEST_F(RtcpSenderTest, SetSendingStatus) {
130   EXPECT_FALSE(rtcp_sender_->Sending());
131   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
132   EXPECT_TRUE(rtcp_sender_->Sending());
133 }
134 
TEST_F(RtcpSenderTest,NoPacketSentIfOff)135 TEST_F(RtcpSenderTest, NoPacketSentIfOff) {
136   rtcp_sender_->SetRTCPStatus(RtcpMode::kOff);
137   EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
138 }
139 
TEST_F(RtcpSenderTest,SendSr)140 TEST_F(RtcpSenderTest, SendSr) {
141   const uint32_t kPacketCount = 0x12345;
142   const uint32_t kOctetCount = 0x23456;
143   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
144   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
145   rtcp_sender_->SetSendingStatus(feedback_state, true);
146   feedback_state.packets_sent = kPacketCount;
147   feedback_state.media_bytes_sent = kOctetCount;
148   NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
149   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
150   EXPECT_EQ(1, parser()->sender_report()->num_packets());
151   EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
152   EXPECT_EQ(ntp, parser()->sender_report()->ntp());
153   EXPECT_EQ(kPacketCount, parser()->sender_report()->sender_packet_count());
154   EXPECT_EQ(kOctetCount, parser()->sender_report()->sender_octet_count());
155   EXPECT_EQ(kStartRtpTimestamp + kRtpTimestamp,
156             parser()->sender_report()->rtp_timestamp());
157   EXPECT_EQ(0U, parser()->sender_report()->report_blocks().size());
158 }
159 
TEST_F(RtcpSenderTest,SendConsecutiveSrWithExactSlope)160 TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
161   const uint32_t kPacketCount = 0x12345;
162   const uint32_t kOctetCount = 0x23456;
163   const int kTimeBetweenSRsUs = 10043;  // Not exact value in milliseconds.
164   const int kExtraPackets = 30;
165   // Make sure clock is not exactly at some milliseconds point.
166   clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
167   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
168   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
169   rtcp_sender_->SetSendingStatus(feedback_state, true);
170   feedback_state.packets_sent = kPacketCount;
171   feedback_state.media_bytes_sent = kOctetCount;
172 
173   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
174   EXPECT_EQ(1, parser()->sender_report()->num_packets());
175   NtpTime ntp1 = parser()->sender_report()->ntp();
176   uint32_t rtp1 = parser()->sender_report()->rtp_timestamp();
177 
178   // Send more SRs to ensure slope is always exact for different offsets
179   for (int packets = 1; packets <= kExtraPackets; ++packets) {
180     clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
181     EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
182     EXPECT_EQ(packets + 1, parser()->sender_report()->num_packets());
183 
184     NtpTime ntp2 = parser()->sender_report()->ntp();
185     uint32_t rtp2 = parser()->sender_report()->rtp_timestamp();
186 
187     uint32_t ntp_diff_in_rtp_units =
188         (ntp2.ToMs() - ntp1.ToMs()) * (kVideoPayloadTypeFrequency / 1000);
189     EXPECT_EQ(rtp2 - rtp1, ntp_diff_in_rtp_units);
190   }
191 }
192 
TEST_F(RtcpSenderTest,DoNotSendSrBeforeRtp)193 TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
194   RtpRtcp::Configuration config;
195   config.clock = &clock_;
196   config.receive_statistics = receive_statistics_.get();
197   config.outgoing_transport = &test_transport_;
198   config.rtcp_report_interval_ms = 1000;
199   config.local_media_ssrc = kSenderSsrc;
200   rtcp_sender_.reset(new RTCPSender(config));
201   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
202   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
203   rtcp_sender_->SetSendingStatus(feedback_state(), true);
204 
205   // Sender Report shouldn't be send as an SR nor as a Report.
206   rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr);
207   EXPECT_EQ(0, parser()->sender_report()->num_packets());
208   rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
209   EXPECT_EQ(0, parser()->sender_report()->num_packets());
210   // Other packets (e.g. Pli) are allowed, even if useless.
211   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
212   EXPECT_EQ(1, parser()->pli()->num_packets());
213 }
214 
TEST_F(RtcpSenderTest,DoNotSendCompundBeforeRtp)215 TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) {
216   RtpRtcp::Configuration config;
217   config.clock = &clock_;
218   config.receive_statistics = receive_statistics_.get();
219   config.outgoing_transport = &test_transport_;
220   config.rtcp_report_interval_ms = 1000;
221   config.local_media_ssrc = kSenderSsrc;
222   rtcp_sender_.reset(new RTCPSender(config));
223   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
224   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
225   rtcp_sender_->SetSendingStatus(feedback_state(), true);
226 
227   // In compound mode no packets are allowed (e.g. Pli) because compound mode
228   // should start with Sender Report.
229   EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
230   EXPECT_EQ(0, parser()->pli()->num_packets());
231 }
232 
TEST_F(RtcpSenderTest,SendRr)233 TEST_F(RtcpSenderTest, SendRr) {
234   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
235   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
236   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
237   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
238   EXPECT_EQ(0U, parser()->receiver_report()->report_blocks().size());
239 }
240 
TEST_F(RtcpSenderTest,SendRrWithOneReportBlock)241 TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
242   const uint16_t kSeqNum = 11111;
243   InsertIncomingPacket(kRemoteSsrc, kSeqNum);
244   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
245   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
246   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
247   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
248   ASSERT_EQ(1U, parser()->receiver_report()->report_blocks().size());
249   const rtcp::ReportBlock& rb = parser()->receiver_report()->report_blocks()[0];
250   EXPECT_EQ(kRemoteSsrc, rb.source_ssrc());
251   EXPECT_EQ(0U, rb.fraction_lost());
252   EXPECT_EQ(0, rb.cumulative_lost_signed());
253   EXPECT_EQ(kSeqNum, rb.extended_high_seq_num());
254 }
255 
TEST_F(RtcpSenderTest,SendRrWithTwoReportBlocks)256 TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
257   const uint16_t kSeqNum = 11111;
258   InsertIncomingPacket(kRemoteSsrc, kSeqNum);
259   InsertIncomingPacket(kRemoteSsrc + 1, kSeqNum + 1);
260   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
261   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
262   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
263   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
264   EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size());
265   EXPECT_EQ(kRemoteSsrc,
266             parser()->receiver_report()->report_blocks()[0].source_ssrc());
267   EXPECT_EQ(kRemoteSsrc + 1,
268             parser()->receiver_report()->report_blocks()[1].source_ssrc());
269 }
270 
TEST_F(RtcpSenderTest,SendSdes)271 TEST_F(RtcpSenderTest, SendSdes) {
272   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
273   EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
274   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
275   EXPECT_EQ(1, parser()->sdes()->num_packets());
276   EXPECT_EQ(1U, parser()->sdes()->chunks().size());
277   EXPECT_EQ(kSenderSsrc, parser()->sdes()->chunks()[0].ssrc);
278   EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname);
279 }
280 
TEST_F(RtcpSenderTest,SendSdesWithMaxChunks)281 TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) {
282   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
283   EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
284   const char cname[] = "smith@host";
285   for (size_t i = 0; i < 30; ++i) {
286     const uint32_t csrc = 0x1234 + i;
287     EXPECT_EQ(0, rtcp_sender_->AddMixedCNAME(csrc, cname));
288   }
289   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
290   EXPECT_EQ(1, parser()->sdes()->num_packets());
291   EXPECT_EQ(31U, parser()->sdes()->chunks().size());
292 }
293 
TEST_F(RtcpSenderTest,SdesIncludedInCompoundPacket)294 TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
295   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
296   EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
297   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
298   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
299   EXPECT_EQ(1, parser()->sdes()->num_packets());
300   EXPECT_EQ(1U, parser()->sdes()->chunks().size());
301 }
302 
TEST_F(RtcpSenderTest,SendBye)303 TEST_F(RtcpSenderTest, SendBye) {
304   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
305   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
306   EXPECT_EQ(1, parser()->bye()->num_packets());
307   EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
308 }
309 
TEST_F(RtcpSenderTest,StopSendingTriggersBye)310 TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
311   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
312   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
313   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
314   EXPECT_EQ(1, parser()->bye()->num_packets());
315   EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
316 }
317 
TEST_F(RtcpSenderTest,SendApp)318 TEST_F(RtcpSenderTest, SendApp) {
319   const uint8_t kSubType = 30;
320   uint32_t name = 'n' << 24;
321   name += 'a' << 16;
322   name += 'm' << 8;
323   name += 'e';
324   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
325   EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData,
326                                                         sizeof(kData)));
327   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
328   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
329   EXPECT_EQ(1, parser()->app()->num_packets());
330   EXPECT_EQ(kSubType, parser()->app()->sub_type());
331   EXPECT_EQ(name, parser()->app()->name());
332   EXPECT_EQ(sizeof(kData), parser()->app()->data_size());
333   EXPECT_EQ(0, memcmp(kData, parser()->app()->data(), sizeof(kData)));
334 }
335 
TEST_F(RtcpSenderTest,SendEmptyApp)336 TEST_F(RtcpSenderTest, SendEmptyApp) {
337   const uint8_t kSubType = 30;
338   const uint32_t kName = 0x6E616D65;
339 
340   EXPECT_EQ(
341       0, rtcp_sender_->SetApplicationSpecificData(kSubType, kName, nullptr, 0));
342 
343   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
344   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
345   EXPECT_EQ(1, parser()->app()->num_packets());
346   EXPECT_EQ(kSubType, parser()->app()->sub_type());
347   EXPECT_EQ(kName, parser()->app()->name());
348   EXPECT_EQ(0U, parser()->app()->data_size());
349 }
350 
TEST_F(RtcpSenderTest,SetInvalidApplicationSpecificData)351 TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) {
352   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't'};
353   const uint16_t kInvalidDataLength = sizeof(kData) / sizeof(kData[0]);
354   EXPECT_EQ(-1,
355             rtcp_sender_->SetApplicationSpecificData(
356                 0, 0, kData, kInvalidDataLength));  // Should by multiple of 4.
357 }
358 
TEST_F(RtcpSenderTest,SendFir)359 TEST_F(RtcpSenderTest, SendFir) {
360   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
361   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
362   EXPECT_EQ(1, parser()->fir()->num_packets());
363   EXPECT_EQ(kSenderSsrc, parser()->fir()->sender_ssrc());
364   EXPECT_EQ(1U, parser()->fir()->requests().size());
365   EXPECT_EQ(kRemoteSsrc, parser()->fir()->requests()[0].ssrc);
366   uint8_t seq = parser()->fir()->requests()[0].seq_nr;
367   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
368   EXPECT_EQ(2, parser()->fir()->num_packets());
369   EXPECT_EQ(seq + 1, parser()->fir()->requests()[0].seq_nr);
370 }
371 
TEST_F(RtcpSenderTest,SendPli)372 TEST_F(RtcpSenderTest, SendPli) {
373   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
374   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
375   EXPECT_EQ(1, parser()->pli()->num_packets());
376   EXPECT_EQ(kSenderSsrc, parser()->pli()->sender_ssrc());
377   EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
378 }
379 
TEST_F(RtcpSenderTest,SendNack)380 TEST_F(RtcpSenderTest, SendNack) {
381   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
382   const uint16_t kList[] = {0, 1, 16};
383   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack,
384                                       ABSL_ARRAYSIZE(kList), kList));
385   EXPECT_EQ(1, parser()->nack()->num_packets());
386   EXPECT_EQ(kSenderSsrc, parser()->nack()->sender_ssrc());
387   EXPECT_EQ(kRemoteSsrc, parser()->nack()->media_ssrc());
388   EXPECT_THAT(parser()->nack()->packet_ids(), ElementsAre(0, 1, 16));
389 }
390 
TEST_F(RtcpSenderTest,SendLossNotificationBufferingNotAllowed)391 TEST_F(RtcpSenderTest, SendLossNotificationBufferingNotAllowed) {
392   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
393   constexpr uint16_t kLastDecoded = 0x1234;
394   constexpr uint16_t kLastReceived = 0x4321;
395   constexpr bool kDecodabilityFlag = true;
396   constexpr bool kBufferingAllowed = false;
397   EXPECT_EQ(rtcp_sender_->SendLossNotification(feedback_state(), kLastDecoded,
398                                                kLastReceived, kDecodabilityFlag,
399                                                kBufferingAllowed),
400             0);
401   EXPECT_EQ(parser()->processed_rtcp_packets(), 1u);
402   EXPECT_EQ(parser()->loss_notification()->num_packets(), 1);
403   EXPECT_EQ(kSenderSsrc, parser()->loss_notification()->sender_ssrc());
404   EXPECT_EQ(kRemoteSsrc, parser()->loss_notification()->media_ssrc());
405 }
406 
TEST_F(RtcpSenderTest,SendLossNotificationBufferingAllowed)407 TEST_F(RtcpSenderTest, SendLossNotificationBufferingAllowed) {
408   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
409   constexpr uint16_t kLastDecoded = 0x1234;
410   constexpr uint16_t kLastReceived = 0x4321;
411   constexpr bool kDecodabilityFlag = true;
412   constexpr bool kBufferingAllowed = true;
413   EXPECT_EQ(rtcp_sender_->SendLossNotification(feedback_state(), kLastDecoded,
414                                                kLastReceived, kDecodabilityFlag,
415                                                kBufferingAllowed),
416             0);
417 
418   // No RTCP messages sent yet.
419   ASSERT_EQ(parser()->processed_rtcp_packets(), 0u);
420 
421   // Sending another messages triggers sending the LNTF messages as well.
422   const uint16_t kList[] = {0, 1, 16};
423   EXPECT_EQ(rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack,
424                                    ABSL_ARRAYSIZE(kList), kList),
425             0);
426 
427   // Exactly one packet was produced, and it contained both the buffered LNTF
428   // as well as the message that had triggered the packet.
429   EXPECT_EQ(parser()->processed_rtcp_packets(), 1u);
430   EXPECT_EQ(parser()->loss_notification()->num_packets(), 1);
431   EXPECT_EQ(parser()->loss_notification()->sender_ssrc(), kSenderSsrc);
432   EXPECT_EQ(parser()->loss_notification()->media_ssrc(), kRemoteSsrc);
433   EXPECT_EQ(parser()->nack()->num_packets(), 1);
434   EXPECT_EQ(parser()->nack()->sender_ssrc(), kSenderSsrc);
435   EXPECT_EQ(parser()->nack()->media_ssrc(), kRemoteSsrc);
436 }
437 
TEST_F(RtcpSenderTest,RembNotIncludedBeforeSet)438 TEST_F(RtcpSenderTest, RembNotIncludedBeforeSet) {
439   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
440 
441   rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
442 
443   ASSERT_EQ(1, parser()->receiver_report()->num_packets());
444   EXPECT_EQ(0, parser()->remb()->num_packets());
445 }
446 
TEST_F(RtcpSenderTest,RembNotIncludedAfterUnset)447 TEST_F(RtcpSenderTest, RembNotIncludedAfterUnset) {
448   const int64_t kBitrate = 261011;
449   const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
450   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
451   rtcp_sender_->SetRemb(kBitrate, kSsrcs);
452   rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
453   ASSERT_EQ(1, parser()->receiver_report()->num_packets());
454   EXPECT_EQ(1, parser()->remb()->num_packets());
455 
456   // Turn off REMB. rtcp_sender no longer should send it.
457   rtcp_sender_->UnsetRemb();
458   rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
459   ASSERT_EQ(2, parser()->receiver_report()->num_packets());
460   EXPECT_EQ(1, parser()->remb()->num_packets());
461 }
462 
TEST_F(RtcpSenderTest,SendRemb)463 TEST_F(RtcpSenderTest, SendRemb) {
464   const int64_t kBitrate = 261011;
465   const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
466   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
467   rtcp_sender_->SetRemb(kBitrate, kSsrcs);
468 
469   rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb);
470 
471   EXPECT_EQ(1, parser()->remb()->num_packets());
472   EXPECT_EQ(kSenderSsrc, parser()->remb()->sender_ssrc());
473   EXPECT_EQ(kBitrate, parser()->remb()->bitrate_bps());
474   EXPECT_THAT(parser()->remb()->ssrcs(),
475               ElementsAre(kRemoteSsrc, kRemoteSsrc + 1));
476 }
477 
TEST_F(RtcpSenderTest,RembIncludedInEachCompoundPacketAfterSet)478 TEST_F(RtcpSenderTest, RembIncludedInEachCompoundPacketAfterSet) {
479   const int kBitrate = 261011;
480   const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
481   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
482   rtcp_sender_->SetRemb(kBitrate, kSsrcs);
483 
484   rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
485   EXPECT_EQ(1, parser()->remb()->num_packets());
486   // REMB should be included in each compound packet.
487   rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
488   EXPECT_EQ(2, parser()->remb()->num_packets());
489 }
490 
TEST_F(RtcpSenderTest,SendXrWithDlrr)491 TEST_F(RtcpSenderTest, SendXrWithDlrr) {
492   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
493   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
494   rtcp::ReceiveTimeInfo last_xr_rr;
495   last_xr_rr.ssrc = 0x11111111;
496   last_xr_rr.last_rr = 0x22222222;
497   last_xr_rr.delay_since_last_rr = 0x33333333;
498   feedback_state.last_xr_rtis.push_back(last_xr_rr);
499   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
500   EXPECT_EQ(1, parser()->xr()->num_packets());
501   EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
502   ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(1));
503   EXPECT_EQ(last_xr_rr.ssrc, parser()->xr()->dlrr().sub_blocks()[0].ssrc);
504   EXPECT_EQ(last_xr_rr.last_rr, parser()->xr()->dlrr().sub_blocks()[0].last_rr);
505   EXPECT_EQ(last_xr_rr.delay_since_last_rr,
506             parser()->xr()->dlrr().sub_blocks()[0].delay_since_last_rr);
507 }
508 
TEST_F(RtcpSenderTest,SendXrWithMultipleDlrrSubBlocks)509 TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
510   const size_t kNumReceivers = 2;
511   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
512   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
513   for (size_t i = 0; i < kNumReceivers; ++i) {
514     rtcp::ReceiveTimeInfo last_xr_rr;
515     last_xr_rr.ssrc = i;
516     last_xr_rr.last_rr = (i + 1) * 100;
517     last_xr_rr.delay_since_last_rr = (i + 2) * 200;
518     feedback_state.last_xr_rtis.push_back(last_xr_rr);
519   }
520 
521   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
522   EXPECT_EQ(1, parser()->xr()->num_packets());
523   EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
524   ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(kNumReceivers));
525   for (size_t i = 0; i < kNumReceivers; ++i) {
526     EXPECT_EQ(feedback_state.last_xr_rtis[i].ssrc,
527               parser()->xr()->dlrr().sub_blocks()[i].ssrc);
528     EXPECT_EQ(feedback_state.last_xr_rtis[i].last_rr,
529               parser()->xr()->dlrr().sub_blocks()[i].last_rr);
530     EXPECT_EQ(feedback_state.last_xr_rtis[i].delay_since_last_rr,
531               parser()->xr()->dlrr().sub_blocks()[i].delay_since_last_rr);
532   }
533 }
534 
TEST_F(RtcpSenderTest,SendXrWithRrtr)535 TEST_F(RtcpSenderTest, SendXrWithRrtr) {
536   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
537   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
538   rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
539   NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
540   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
541   EXPECT_EQ(1, parser()->xr()->num_packets());
542   EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
543   EXPECT_FALSE(parser()->xr()->dlrr());
544   ASSERT_TRUE(parser()->xr()->rrtr());
545   EXPECT_EQ(ntp, parser()->xr()->rrtr()->ntp());
546 }
547 
TEST_F(RtcpSenderTest,TestNoXrRrtrSentIfSending)548 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
549   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
550   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
551   rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
552   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
553   EXPECT_EQ(0, parser()->xr()->num_packets());
554 }
555 
TEST_F(RtcpSenderTest,TestNoXrRrtrSentIfNotEnabled)556 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
557   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
558   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
559   rtcp_sender_->SendRtcpXrReceiverReferenceTime(false);
560   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
561   EXPECT_EQ(0, parser()->xr()->num_packets());
562 }
563 
TEST_F(RtcpSenderTest,TestRegisterRtcpPacketTypeObserver)564 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
565   RtcpPacketTypeCounterObserverImpl observer;
566   RtpRtcp::Configuration config;
567   config.clock = &clock_;
568   config.receive_statistics = receive_statistics_.get();
569   config.outgoing_transport = &test_transport_;
570   config.rtcp_packet_type_counter_observer = &observer;
571   config.rtcp_report_interval_ms = 1000;
572   rtcp_sender_.reset(new RTCPSender(config));
573 
574   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
575   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
576   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
577   EXPECT_EQ(1, parser()->pli()->num_packets());
578   EXPECT_EQ(kRemoteSsrc, observer.ssrc_);
579   EXPECT_EQ(1U, observer.counter_.pli_packets);
580   EXPECT_EQ(clock_.TimeInMilliseconds(),
581             observer.counter_.first_packet_time_ms);
582 }
583 
TEST_F(RtcpSenderTest,SendTmmbr)584 TEST_F(RtcpSenderTest, SendTmmbr) {
585   const unsigned int kBitrateBps = 312000;
586   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
587   rtcp_sender_->SetTargetBitrate(kBitrateBps);
588   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr));
589   EXPECT_EQ(1, parser()->tmmbr()->num_packets());
590   EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->sender_ssrc());
591   EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
592   EXPECT_EQ(kBitrateBps, parser()->tmmbr()->requests()[0].bitrate_bps());
593   // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
594 }
595 
TEST_F(RtcpSenderTest,TmmbrIncludedInCompoundPacketIfEnabled)596 TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
597   const unsigned int kBitrateBps = 312000;
598   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
599   EXPECT_FALSE(rtcp_sender_->TMMBR());
600   rtcp_sender_->SetTMMBRStatus(true);
601   EXPECT_TRUE(rtcp_sender_->TMMBR());
602   rtcp_sender_->SetTargetBitrate(kBitrateBps);
603   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
604   EXPECT_EQ(1, parser()->tmmbr()->num_packets());
605   EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
606   // TMMBR should be included in each compound packet.
607   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
608   EXPECT_EQ(2, parser()->tmmbr()->num_packets());
609 
610   rtcp_sender_->SetTMMBRStatus(false);
611   EXPECT_FALSE(rtcp_sender_->TMMBR());
612 }
613 
TEST_F(RtcpSenderTest,SendTmmbn)614 TEST_F(RtcpSenderTest, SendTmmbn) {
615   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
616   rtcp_sender_->SetSendingStatus(feedback_state(), true);
617   std::vector<rtcp::TmmbItem> bounding_set;
618   const uint32_t kBitrateBps = 32768000;
619   const uint32_t kPacketOh = 40;
620   const uint32_t kSourceSsrc = 12345;
621   const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateBps, kPacketOh);
622   bounding_set.push_back(tmmbn);
623   rtcp_sender_->SetTmmbn(bounding_set);
624 
625   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
626   EXPECT_EQ(1, parser()->sender_report()->num_packets());
627   EXPECT_EQ(1, parser()->tmmbn()->num_packets());
628   EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
629   EXPECT_EQ(1U, parser()->tmmbn()->items().size());
630   EXPECT_EQ(kBitrateBps, parser()->tmmbn()->items()[0].bitrate_bps());
631   EXPECT_EQ(kPacketOh, parser()->tmmbn()->items()[0].packet_overhead());
632   EXPECT_EQ(kSourceSsrc, parser()->tmmbn()->items()[0].ssrc());
633 }
634 
635 // This test is written to verify actual behaviour. It does not seem
636 // to make much sense to send an empty TMMBN, since there is no place
637 // to put an actual limit here. It's just information that no limit
638 // is set, which is kind of the starting assumption.
639 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one
640 // situation where this caused confusion.
TEST_F(RtcpSenderTest,SendsTmmbnIfSetAndEmpty)641 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
642   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
643   rtcp_sender_->SetSendingStatus(feedback_state(), true);
644   std::vector<rtcp::TmmbItem> bounding_set;
645   rtcp_sender_->SetTmmbn(bounding_set);
646   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
647   EXPECT_EQ(1, parser()->sender_report()->num_packets());
648   EXPECT_EQ(1, parser()->tmmbn()->num_packets());
649   EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
650   EXPECT_EQ(0U, parser()->tmmbn()->items().size());
651 }
652 
TEST_F(RtcpSenderTest,SendCompoundPliRemb)653 TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
654   const int kBitrate = 261011;
655   std::vector<uint32_t> ssrcs;
656   ssrcs.push_back(kRemoteSsrc);
657   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
658   rtcp_sender_->SetRemb(kBitrate, ssrcs);
659   std::set<RTCPPacketType> packet_types;
660   packet_types.insert(kRtcpRemb);
661   packet_types.insert(kRtcpPli);
662   EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
663   EXPECT_EQ(1, parser()->remb()->num_packets());
664   EXPECT_EQ(1, parser()->pli()->num_packets());
665 }
666 
667 // This test is written to verify that BYE is always the last packet
668 // type in a RTCP compoud packet.  The rtcp_sender_ is recreated with
669 // mock_transport, which is used to check for whether BYE at the end
670 // of a RTCP compound packet.
TEST_F(RtcpSenderTest,ByeMustBeLast)671 TEST_F(RtcpSenderTest, ByeMustBeLast) {
672   MockTransport mock_transport;
673   EXPECT_CALL(mock_transport, SendRtcp(_, _))
674       .WillOnce(Invoke([](const uint8_t* data, size_t len) {
675         const uint8_t* next_packet = data;
676         const uint8_t* const packet_end = data + len;
677         rtcp::CommonHeader packet;
678         while (next_packet < packet_end) {
679           EXPECT_TRUE(packet.Parse(next_packet, packet_end - next_packet));
680           next_packet = packet.NextPacket();
681           if (packet.type() ==
682               rtcp::Bye::kPacketType)  // Main test expectation.
683             EXPECT_EQ(0, packet_end - next_packet)
684                 << "Bye packet should be last in a compound RTCP packet.";
685           if (next_packet == packet_end)  // Validate test was set correctly.
686             EXPECT_EQ(packet.type(), rtcp::Bye::kPacketType)
687                 << "Last packet in this test expected to be Bye.";
688         }
689 
690         return true;
691       }));
692 
693   // Re-configure rtcp_sender_ with mock_transport_
694   RtpRtcp::Configuration config;
695   config.clock = &clock_;
696   config.receive_statistics = receive_statistics_.get();
697   config.outgoing_transport = &mock_transport;
698   config.rtcp_report_interval_ms = 1000;
699   config.local_media_ssrc = kSenderSsrc;
700   rtcp_sender_.reset(new RTCPSender(config));
701 
702   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
703   rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
704   rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
705                                /*payload_type=*/0);
706 
707   // Set up REMB info to be included with BYE.
708   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
709   rtcp_sender_->SetRemb(1234, {});
710   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
711 }
712 
TEST_F(RtcpSenderTest,SendXrWithTargetBitrate)713 TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
714   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
715   const size_t kNumSpatialLayers = 2;
716   const size_t kNumTemporalLayers = 2;
717   VideoBitrateAllocation allocation;
718   for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) {
719     uint32_t start_bitrate_bps = (sl + 1) * 100000;
720     for (size_t tl = 0; tl < kNumTemporalLayers; ++tl)
721       allocation.SetBitrate(sl, tl, start_bitrate_bps + (tl * 20000));
722   }
723   rtcp_sender_->SetVideoBitrateAllocation(allocation);
724 
725   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
726   EXPECT_EQ(1, parser()->xr()->num_packets());
727   EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
728   const absl::optional<rtcp::TargetBitrate>& target_bitrate =
729       parser()->xr()->target_bitrate();
730   ASSERT_TRUE(target_bitrate);
731   const std::vector<rtcp::TargetBitrate::BitrateItem>& bitrates =
732       target_bitrate->GetTargetBitrates();
733   EXPECT_EQ(kNumSpatialLayers * kNumTemporalLayers, bitrates.size());
734 
735   for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) {
736     uint32_t start_bitrate_bps = (sl + 1) * 100000;
737     for (size_t tl = 0; tl < kNumTemporalLayers; ++tl) {
738       size_t index = (sl * kNumSpatialLayers) + tl;
739       const rtcp::TargetBitrate::BitrateItem& item = bitrates[index];
740       EXPECT_EQ(sl, item.spatial_layer);
741       EXPECT_EQ(tl, item.temporal_layer);
742       EXPECT_EQ(start_bitrate_bps + (tl * 20000),
743                 item.target_bitrate_kbps * 1000);
744     }
745   }
746 }
747 
TEST_F(RtcpSenderTest,SendImmediateXrWithTargetBitrate)748 TEST_F(RtcpSenderTest, SendImmediateXrWithTargetBitrate) {
749   // Initialize. Send a first report right away.
750   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
751   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
752   clock_.AdvanceTimeMilliseconds(5);
753 
754   // Video bitrate allocation generated, save until next time we send a report.
755   VideoBitrateAllocation allocation;
756   allocation.SetBitrate(0, 0, 100000);
757   rtcp_sender_->SetVideoBitrateAllocation(allocation);
758   // First seen instance will be sent immediately.
759   EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
760   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
761   clock_.AdvanceTimeMilliseconds(5);
762 
763   // Update bitrate of existing layer, does not quality for immediate sending.
764   allocation.SetBitrate(0, 0, 150000);
765   rtcp_sender_->SetVideoBitrateAllocation(allocation);
766   EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
767 
768   // A new spatial layer enabled, signal this as soon as possible.
769   allocation.SetBitrate(1, 0, 200000);
770   rtcp_sender_->SetVideoBitrateAllocation(allocation);
771   EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
772   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
773   clock_.AdvanceTimeMilliseconds(5);
774 
775   // Explicitly disable top layer. The same set of layers now has a bitrate
776   // defined, but the explicit 0 indicates shutdown. Signal immediately.
777   allocation.SetBitrate(1, 0, 0);
778   EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
779   rtcp_sender_->SetVideoBitrateAllocation(allocation);
780   EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
781 }
782 
TEST_F(RtcpSenderTest,SendTargetBitrateExplicitZeroOnStreamRemoval)783 TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) {
784   // Set up and send a bitrate allocation with two layers.
785 
786   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
787   VideoBitrateAllocation allocation;
788   allocation.SetBitrate(0, 0, 100000);
789   allocation.SetBitrate(1, 0, 200000);
790   rtcp_sender_->SetVideoBitrateAllocation(allocation);
791   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
792   absl::optional<rtcp::TargetBitrate> target_bitrate =
793       parser()->xr()->target_bitrate();
794   ASSERT_TRUE(target_bitrate);
795   std::vector<rtcp::TargetBitrate::BitrateItem> bitrates =
796       target_bitrate->GetTargetBitrates();
797   ASSERT_EQ(2u, bitrates.size());
798   EXPECT_EQ(bitrates[0].target_bitrate_kbps,
799             allocation.GetBitrate(0, 0) / 1000);
800   EXPECT_EQ(bitrates[1].target_bitrate_kbps,
801             allocation.GetBitrate(1, 0) / 1000);
802 
803   // Create a new allocation, where the second stream is no longer available.
804   VideoBitrateAllocation new_allocation;
805   new_allocation.SetBitrate(0, 0, 150000);
806   rtcp_sender_->SetVideoBitrateAllocation(new_allocation);
807   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
808   target_bitrate = parser()->xr()->target_bitrate();
809   ASSERT_TRUE(target_bitrate);
810   bitrates = target_bitrate->GetTargetBitrates();
811 
812   // Two bitrates should still be set, with an explicit entry indicating the
813   // removed stream is gone.
814   ASSERT_EQ(2u, bitrates.size());
815   EXPECT_EQ(bitrates[0].target_bitrate_kbps,
816             new_allocation.GetBitrate(0, 0) / 1000);
817   EXPECT_EQ(bitrates[1].target_bitrate_kbps, 0u);
818 }
819 
TEST_F(RtcpSenderTest,DoesntSchedulesInitialReportWhenSsrcSetOnConstruction)820 TEST_F(RtcpSenderTest, DoesntSchedulesInitialReportWhenSsrcSetOnConstruction) {
821   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
822   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
823   // New report should not have been scheduled yet.
824   clock_.AdvanceTimeMilliseconds(100);
825   EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
826 }
827 
TEST_F(RtcpSenderTest,SendsCombinedRtcpPacket)828 TEST_F(RtcpSenderTest, SendsCombinedRtcpPacket) {
829   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
830 
831   std::vector<std::unique_ptr<rtcp::RtcpPacket>> packets;
832   auto transport_feedback = std::make_unique<rtcp::TransportFeedback>();
833   transport_feedback->AddReceivedPacket(321, 10000);
834   packets.push_back(std::move(transport_feedback));
835   auto remote_estimate = std::make_unique<rtcp::RemoteEstimate>();
836   packets.push_back(std::move(remote_estimate));
837   rtcp_sender_->SendCombinedRtcpPacket(std::move(packets));
838 
839   EXPECT_EQ(parser()->transport_feedback()->num_packets(), 1);
840   EXPECT_EQ(parser()->transport_feedback()->sender_ssrc(), kSenderSsrc);
841   EXPECT_EQ(parser()->app()->num_packets(), 1);
842   EXPECT_EQ(parser()->app()->sender_ssrc(), kSenderSsrc);
843 }
844 
845 }  // namespace webrtc
846