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 <memory>
12 
13 #include "api/array_view.h"
14 #include "common_types.h"  // NOLINT(build/include)
15 #include "common_video/include/video_bitrate_allocator.h"
16 #include "modules/rtp_rtcp/source/byte_io.h"
17 #include "modules/rtp_rtcp/source/rtcp_packet.h"
18 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
19 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
20 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
21 #include "modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
22 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
23 #include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
24 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
25 #include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
26 #include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
27 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
28 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
29 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
30 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
31 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
32 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
33 #include "modules/rtp_rtcp/source/rtcp_receiver.h"
34 #include "modules/rtp_rtcp/source/time_util.h"
35 #include "rtc_base/arraysize.h"
36 #include "rtc_base/random.h"
37 #include "system_wrappers/include/ntp_time.h"
38 #include "test/gmock.h"
39 #include "test/gtest.h"
40 
41 namespace webrtc {
42 namespace {
43 
44 using ::testing::_;
45 using ::testing::AllOf;
46 using ::testing::ElementsAreArray;
47 using ::testing::Field;
48 using ::testing::IsEmpty;
49 using ::testing::NiceMock;
50 using ::testing::Property;
51 using ::testing::SizeIs;
52 using ::testing::StrEq;
53 using ::testing::StrictMock;
54 using ::testing::UnorderedElementsAre;
55 using rtcp::ReceiveTimeInfo;
56 
57 class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver {
58  public:
59   MOCK_METHOD2(RtcpPacketTypesCounterUpdated,
60                void(uint32_t, const RtcpPacketTypeCounter&));
61 };
62 
63 class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
64  public:
65   MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t));
66 };
67 
68 class MockRtcpCallbackImpl : public RtcpStatisticsCallback {
69  public:
70   MOCK_METHOD2(StatisticsUpdated, void(const RtcpStatistics&, uint32_t));
71   MOCK_METHOD2(CNameChanged, void(const char*, uint32_t));
72 };
73 
74 class MockTransportFeedbackObserver : public TransportFeedbackObserver {
75  public:
76   MOCK_METHOD3(AddPacket, void(uint32_t, uint16_t, size_t));
77   MOCK_METHOD4(AddPacket,
78                void(uint32_t, uint16_t, size_t, const PacedPacketInfo&));
79   MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
80   MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>());
81 };
82 
83 class MockRtcpBandwidthObserver : public RtcpBandwidthObserver {
84  public:
85   MOCK_METHOD1(OnReceivedEstimatedBitrate, void(uint32_t));
86   MOCK_METHOD3(OnReceivedRtcpReceiverReport,
87                void(const ReportBlockList&, int64_t, int64_t));
88 };
89 
90 class MockModuleRtpRtcp : public RTCPReceiver::ModuleRtpRtcp {
91  public:
92   MOCK_METHOD4(GetSendReportMetadata, bool(uint32_t, uint64_t*, uint32_t*, uint64_t*));
93   MOCK_METHOD1(SetTmmbn, void(std::vector<rtcp::TmmbItem>));
94   MOCK_METHOD0(OnRequestSendReport, void());
95   MOCK_METHOD1(OnReceivedNack, void(const std::vector<uint16_t>&));
96   MOCK_METHOD1(OnReceivedRtcpReportBlocks, void(const ReportBlockList&));
97 };
98 
99 class MockVideoBitrateAllocationObserver
100     : public VideoBitrateAllocationObserver {
101  public:
102   MOCK_METHOD1(OnBitrateAllocationUpdated,
103                void(const BitrateAllocation& allocation));
104 };
105 
106 // SSRC of remote peer, that sends rtcp packet to the rtcp receiver under test.
107 constexpr uint32_t kSenderSsrc = 0x10203;
108 // SSRCs of local peer, that rtcp packet addressed to.
109 constexpr uint32_t kReceiverMainSsrc = 0x123456;
110 // RtcpReceiver can accept several ssrc, e.g. regular and rtx streams.
111 constexpr uint32_t kReceiverExtraSsrc = 0x1234567;
112 // SSRCs to ignore (i.e. not configured in RtcpReceiver).
113 constexpr uint32_t kNotToUsSsrc = 0x654321;
114 constexpr uint32_t kUnknownSenderSsrc = 0x54321;
115 
116 }  // namespace
117 
118 class RtcpReceiverTest : public ::testing::Test {
119  protected:
RtcpReceiverTest()120   RtcpReceiverTest()
121       : system_clock_(1335900000),
122         rtcp_receiver_(&system_clock_,
123                        false,
124                        &packet_type_counter_observer_,
125                        &bandwidth_observer_,
126                        &intra_frame_observer_,
127                        &transport_feedback_observer_,
128                        &bitrate_allocation_observer_,
129                        &rtp_rtcp_impl_) {}
SetUp()130   void SetUp() {
131     std::set<uint32_t> ssrcs = {kReceiverMainSsrc, kReceiverExtraSsrc};
132     rtcp_receiver_.SetSsrcs(kReceiverMainSsrc, ssrcs);
133 
134     rtcp_receiver_.SetRemoteSSRC(kSenderSsrc);
135   }
136 
InjectRtcpPacket(rtc::ArrayView<const uint8_t> raw)137   void InjectRtcpPacket(rtc::ArrayView<const uint8_t> raw) {
138     rtcp_receiver_.IncomingPacket(raw.data(), raw.size());
139   }
140 
InjectRtcpPacket(const rtcp::RtcpPacket & packet)141   void InjectRtcpPacket(const rtcp::RtcpPacket& packet) {
142     rtc::Buffer raw = packet.Build();
143     rtcp_receiver_.IncomingPacket(raw.data(), raw.size());
144   }
145 
146   SimulatedClock system_clock_;
147   // Callbacks to packet_type_counter_observer are frequent but most of the time
148   // are not interesting.
149   NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer_;
150   StrictMock<MockRtcpBandwidthObserver> bandwidth_observer_;
151   StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer_;
152   StrictMock<MockTransportFeedbackObserver> transport_feedback_observer_;
153   StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer_;
154   StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl_;
155 
156   RTCPReceiver rtcp_receiver_;
157 };
158 
TEST_F(RtcpReceiverTest,BrokenPacketIsIgnored)159 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
160   const uint8_t bad_packet[] = {0, 0, 0, 0};
161   EXPECT_CALL(packet_type_counter_observer_,
162               RtcpPacketTypesCounterUpdated(_, _))
163       .Times(0);
164   InjectRtcpPacket(bad_packet);
165 }
166 
TEST_F(RtcpReceiverTest,InvalidFeedbackPacketIsIgnored)167 TEST_F(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) {
168   // Too short feedback packet.
169   const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0};
170 
171   // TODO(danilchap): Add expectation RtcpPacketTypesCounterUpdated
172   // is not called once parser would be adjusted to avoid that callback on
173   // semi-valid packets.
174   InjectRtcpPacket(bad_packet);
175 }
176 
TEST_F(RtcpReceiverTest,InjectSrPacket)177 TEST_F(RtcpReceiverTest, InjectSrPacket) {
178   EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr));
179 
180   int64_t now = system_clock_.TimeInMilliseconds();
181   rtcp::SenderReport sr;
182   sr.SetSenderSsrc(kSenderSsrc);
183 
184   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
185   EXPECT_CALL(bandwidth_observer_,
186               OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
187   InjectRtcpPacket(sr);
188 
189   EXPECT_TRUE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr));
190 }
191 
TEST_F(RtcpReceiverTest,InjectSrPacketFromUnknownSender)192 TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) {
193   int64_t now = system_clock_.TimeInMilliseconds();
194   rtcp::SenderReport sr;
195   sr.SetSenderSsrc(kUnknownSenderSsrc);
196 
197   // The parser will handle report blocks in Sender Report from other than his
198   // expected peer.
199   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
200   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, now));
201   InjectRtcpPacket(sr);
202 
203   // But will not flag that he's gotten sender information.
204   EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr));
205 }
206 
TEST_F(RtcpReceiverTest,InjectSrPacketCalculatesRTT)207 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
208   Random r(0x0123456789abcdef);
209   const int64_t kRttMs = r.Rand(1, 9 * 3600 * 1000);
210   const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff);
211   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
212 
213   int64_t rtt_ms = 0;
214   EXPECT_EQ(
215       -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
216 
217   uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
218   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
219 
220   rtcp::SenderReport sr;
221   sr.SetSenderSsrc(kSenderSsrc);
222   rtcp::ReportBlock block;
223   block.SetMediaSsrc(kReceiverMainSsrc);
224   block.SetLastSr(sent_ntp);
225   block.SetDelayLastSr(kDelayNtp);
226   sr.AddReportBlock(block);
227 
228   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
229   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
230   InjectRtcpPacket(sr);
231 
232   EXPECT_EQ(
233       0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
234   EXPECT_NEAR(kRttMs, rtt_ms, 1);
235 }
236 
TEST_F(RtcpReceiverTest,InjectSrPacketCalculatesNegativeRTTAsOne)237 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) {
238   Random r(0x0123456789abcdef);
239   const int64_t kRttMs = r.Rand(-3600 * 1000, -1);
240   const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff);
241   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
242 
243   int64_t rtt_ms = 0;
244   EXPECT_EQ(
245       -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
246 
247   uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
248   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
249 
250   rtcp::SenderReport sr;
251   sr.SetSenderSsrc(kSenderSsrc);
252   rtcp::ReportBlock block;
253   block.SetMediaSsrc(kReceiverMainSsrc);
254   block.SetLastSr(sent_ntp);
255   block.SetDelayLastSr(kDelayNtp);
256   sr.AddReportBlock(block);
257 
258   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
259   EXPECT_CALL(bandwidth_observer_,
260               OnReceivedRtcpReceiverReport(SizeIs(1), _, _));
261   InjectRtcpPacket(sr);
262 
263   EXPECT_EQ(
264       0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
265   EXPECT_EQ(1, rtt_ms);
266 }
267 
TEST_F(RtcpReceiverTest,InjectRrPacket)268 TEST_F(RtcpReceiverTest, InjectRrPacket) {
269   int64_t now = system_clock_.TimeInMilliseconds();
270   rtcp::ReceiverReport rr;
271   rr.SetSenderSsrc(kSenderSsrc);
272 
273   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
274   EXPECT_CALL(bandwidth_observer_,
275               OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
276   InjectRtcpPacket(rr);
277 
278   std::vector<RTCPReportBlock> report_blocks;
279   rtcp_receiver_.StatisticsReceived(&report_blocks);
280   EXPECT_TRUE(report_blocks.empty());
281 }
282 
TEST_F(RtcpReceiverTest,InjectRrPacketWithReportBlockNotToUsIgnored)283 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
284   int64_t now = system_clock_.TimeInMilliseconds();
285   rtcp::ReportBlock rb;
286   rb.SetMediaSsrc(kNotToUsSsrc);
287   rtcp::ReceiverReport rr;
288   rr.SetSenderSsrc(kSenderSsrc);
289   rr.AddReportBlock(rb);
290 
291   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
292   EXPECT_CALL(bandwidth_observer_,
293               OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
294   InjectRtcpPacket(rr);
295 
296   EXPECT_EQ(0, rtcp_receiver_.LastReceivedReportBlockMs());
297   std::vector<RTCPReportBlock> received_blocks;
298   rtcp_receiver_.StatisticsReceived(&received_blocks);
299   EXPECT_TRUE(received_blocks.empty());
300 }
301 
TEST_F(RtcpReceiverTest,InjectRrPacketWithOneReportBlock)302 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
303   int64_t now = system_clock_.TimeInMilliseconds();
304 
305   rtcp::ReportBlock rb;
306   rb.SetMediaSsrc(kReceiverMainSsrc);
307   rtcp::ReceiverReport rr;
308   rr.SetSenderSsrc(kSenderSsrc);
309   rr.AddReportBlock(rb);
310 
311   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
312   EXPECT_CALL(bandwidth_observer_,
313               OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
314   InjectRtcpPacket(rr);
315 
316   EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
317   std::vector<RTCPReportBlock> received_blocks;
318   rtcp_receiver_.StatisticsReceived(&received_blocks);
319   EXPECT_EQ(1u, received_blocks.size());
320 }
321 
TEST_F(RtcpReceiverTest,InjectSrPacketWithOneReportBlock)322 TEST_F(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) {
323   int64_t now = system_clock_.TimeInMilliseconds();
324 
325   rtcp::ReportBlock rb;
326   rb.SetMediaSsrc(kReceiverMainSsrc);
327   rtcp::SenderReport sr;
328   sr.SetSenderSsrc(kSenderSsrc);
329   sr.AddReportBlock(rb);
330 
331   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
332   EXPECT_CALL(bandwidth_observer_,
333               OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
334   InjectRtcpPacket(sr);
335 
336   EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
337   std::vector<RTCPReportBlock> received_blocks;
338   rtcp_receiver_.StatisticsReceived(&received_blocks);
339   EXPECT_EQ(1u, received_blocks.size());
340 }
341 
TEST_F(RtcpReceiverTest,InjectRrPacketWithTwoReportBlocks)342 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
343   const uint16_t kSequenceNumbers[] = {10, 12423};
344   const uint32_t kCumLost[] = {13, 555};
345   const uint8_t kFracLost[] = {20, 11};
346   int64_t now = system_clock_.TimeInMilliseconds();
347 
348   rtcp::ReportBlock rb1;
349   rb1.SetMediaSsrc(kReceiverMainSsrc);
350   rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
351   rb1.SetFractionLost(10);
352 
353   rtcp::ReportBlock rb2;
354   rb2.SetMediaSsrc(kReceiverExtraSsrc);
355   rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
356   rb2.SetFractionLost(0);
357 
358   rtcp::ReceiverReport rr1;
359   rr1.SetSenderSsrc(kSenderSsrc);
360   rr1.AddReportBlock(rb1);
361   rr1.AddReportBlock(rb2);
362 
363   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2)));
364   EXPECT_CALL(bandwidth_observer_,
365               OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
366   InjectRtcpPacket(rr1);
367 
368   EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
369   std::vector<RTCPReportBlock> received_blocks;
370   rtcp_receiver_.StatisticsReceived(&received_blocks);
371   EXPECT_THAT(received_blocks,
372               UnorderedElementsAre(Field(&RTCPReportBlock::fraction_lost, 0),
373                                    Field(&RTCPReportBlock::fraction_lost, 10)));
374 
375   // Insert next receiver report with same ssrc but new values.
376   rtcp::ReportBlock rb3;
377   rb3.SetMediaSsrc(kReceiverMainSsrc);
378   rb3.SetExtHighestSeqNum(kSequenceNumbers[0]);
379   rb3.SetFractionLost(kFracLost[0]);
380   rb3.SetCumulativeLost(kCumLost[0]);
381 
382   rtcp::ReportBlock rb4;
383   rb4.SetMediaSsrc(kReceiverExtraSsrc);
384   rb4.SetExtHighestSeqNum(kSequenceNumbers[1]);
385   rb4.SetFractionLost(kFracLost[1]);
386   rb4.SetCumulativeLost(kCumLost[1]);
387 
388   rtcp::ReceiverReport rr2;
389   rr2.SetSenderSsrc(kSenderSsrc);
390   rr2.AddReportBlock(rb3);
391   rr2.AddReportBlock(rb4);
392 
393   // Advance time to make 1st sent time and 2nd sent time different.
394   system_clock_.AdvanceTimeMilliseconds(500);
395   now = system_clock_.TimeInMilliseconds();
396 
397   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2)));
398   EXPECT_CALL(bandwidth_observer_,
399               OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
400   InjectRtcpPacket(rr2);
401 
402   received_blocks.clear();
403   rtcp_receiver_.StatisticsReceived(&received_blocks);
404   EXPECT_EQ(2u, received_blocks.size());
405   EXPECT_THAT(
406       received_blocks,
407       UnorderedElementsAre(
408           AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
409                 Field(&RTCPReportBlock::fraction_lost, kFracLost[0]),
410                 Field(&RTCPReportBlock::packets_lost, kCumLost[0]),
411                 Field(&RTCPReportBlock::extended_highest_sequence_number,
412                       kSequenceNumbers[0])),
413           AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverExtraSsrc),
414                 Field(&RTCPReportBlock::fraction_lost, kFracLost[1]),
415                 Field(&RTCPReportBlock::packets_lost, kCumLost[1]),
416                 Field(&RTCPReportBlock::extended_highest_sequence_number,
417                       kSequenceNumbers[1]))));
418 }
419 
TEST_F(RtcpReceiverTest,InjectRrPacketsFromTwoRemoteSsrcs)420 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
421   const uint32_t kSenderSsrc2 = 0x20304;
422   const uint16_t kSequenceNumbers[] = {10, 12423};
423   const uint32_t kCumLost[] = {13, 555};
424   const uint8_t kFracLost[] = {20, 11};
425 
426   rtcp::ReportBlock rb1;
427   rb1.SetMediaSsrc(kReceiverMainSsrc);
428   rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
429   rb1.SetFractionLost(kFracLost[0]);
430   rb1.SetCumulativeLost(kCumLost[0]);
431   rtcp::ReceiverReport rr1;
432   rr1.SetSenderSsrc(kSenderSsrc);
433   rr1.AddReportBlock(rb1);
434 
435   int64_t now = system_clock_.TimeInMilliseconds();
436 
437   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
438   EXPECT_CALL(bandwidth_observer_,
439               OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
440   InjectRtcpPacket(rr1);
441 
442   EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
443 
444   std::vector<RTCPReportBlock> received_blocks;
445   rtcp_receiver_.StatisticsReceived(&received_blocks);
446   EXPECT_EQ(1u, received_blocks.size());
447   EXPECT_EQ(kSenderSsrc, received_blocks[0].sender_ssrc);
448   EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].source_ssrc);
449   EXPECT_EQ(kFracLost[0], received_blocks[0].fraction_lost);
450   EXPECT_EQ(kCumLost[0], received_blocks[0].packets_lost);
451   EXPECT_EQ(kSequenceNumbers[0],
452             received_blocks[0].extended_highest_sequence_number);
453 
454   rtcp::ReportBlock rb2;
455   rb2.SetMediaSsrc(kReceiverMainSsrc);
456   rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
457   rb2.SetFractionLost(kFracLost[1]);
458   rb2.SetCumulativeLost(kCumLost[1]);
459   rtcp::ReceiverReport rr2;
460   rr2.SetSenderSsrc(kSenderSsrc2);
461   rr2.AddReportBlock(rb2);
462 
463   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
464   EXPECT_CALL(bandwidth_observer_,
465               OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
466   InjectRtcpPacket(rr2);
467 
468   received_blocks.clear();
469   rtcp_receiver_.StatisticsReceived(&received_blocks);
470   ASSERT_EQ(2u, received_blocks.size());
471   EXPECT_THAT(
472       received_blocks,
473       UnorderedElementsAre(
474           AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
475                 Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc),
476                 Field(&RTCPReportBlock::fraction_lost, kFracLost[0]),
477                 Field(&RTCPReportBlock::packets_lost, kCumLost[0]),
478                 Field(&RTCPReportBlock::extended_highest_sequence_number,
479                       kSequenceNumbers[0])),
480           AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc),
481                 Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc2),
482                 Field(&RTCPReportBlock::fraction_lost, kFracLost[1]),
483                 Field(&RTCPReportBlock::packets_lost, kCumLost[1]),
484                 Field(&RTCPReportBlock::extended_highest_sequence_number,
485                       kSequenceNumbers[1]))));
486 }
487 
TEST_F(RtcpReceiverTest,GetRtt)488 TEST_F(RtcpReceiverTest, GetRtt) {
489   const uint32_t kSentCompactNtp = 0x1234;
490   const uint32_t kDelayCompactNtp = 0x222;
491   // No report block received.
492   EXPECT_EQ(
493       -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
494 
495   rtcp::ReportBlock rb;
496   rb.SetMediaSsrc(kReceiverMainSsrc);
497   rb.SetLastSr(kSentCompactNtp);
498   rb.SetDelayLastSr(kDelayCompactNtp);
499 
500   rtcp::ReceiverReport rr;
501   rr.SetSenderSsrc(kSenderSsrc);
502   rr.AddReportBlock(rb);
503   int64_t now = system_clock_.TimeInMilliseconds();
504 
505   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
506   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
507   InjectRtcpPacket(rr);
508 
509   EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs());
510   EXPECT_EQ(
511       0, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
512 }
513 
514 // Ij packets are ignored.
TEST_F(RtcpReceiverTest,InjectIjWithNoItem)515 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
516   rtcp::ExtendedJitterReport ij;
517   InjectRtcpPacket(ij);
518 }
519 
520 // App packets are ignored.
TEST_F(RtcpReceiverTest,InjectApp)521 TEST_F(RtcpReceiverTest, InjectApp) {
522   rtcp::App app;
523   app.SetSubType(30);
524   app.SetName(0x17a177e);
525   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
526   app.SetData(kData, sizeof(kData));
527 
528   InjectRtcpPacket(app);
529 }
530 
TEST_F(RtcpReceiverTest,InjectSdesWithOneChunk)531 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
532   const char kCname[] = "alice@host";
533   MockRtcpCallbackImpl callback;
534   rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback);
535   rtcp::Sdes sdes;
536   sdes.AddCName(kSenderSsrc, kCname);
537 
538   EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc));
539   InjectRtcpPacket(sdes);
540 
541   char cName[RTCP_CNAME_SIZE];
542   EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName));
543   EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE));
544 }
545 
TEST_F(RtcpReceiverTest,InjectByePacket_RemovesCname)546 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
547   const char kCname[] = "alice@host";
548   rtcp::Sdes sdes;
549   sdes.AddCName(kSenderSsrc, kCname);
550 
551   InjectRtcpPacket(sdes);
552 
553   char cName[RTCP_CNAME_SIZE];
554   EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName));
555 
556   // Verify that BYE removes the CNAME.
557   rtcp::Bye bye;
558   bye.SetSenderSsrc(kSenderSsrc);
559 
560   InjectRtcpPacket(bye);
561 
562   EXPECT_EQ(-1, rtcp_receiver_.CNAME(kSenderSsrc, cName));
563 }
564 
TEST_F(RtcpReceiverTest,InjectByePacket_RemovesReportBlocks)565 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
566   rtcp::ReportBlock rb1;
567   rb1.SetMediaSsrc(kReceiverMainSsrc);
568   rtcp::ReportBlock rb2;
569   rb2.SetMediaSsrc(kReceiverExtraSsrc);
570   rtcp::ReceiverReport rr;
571   rr.SetSenderSsrc(kSenderSsrc);
572   rr.AddReportBlock(rb1);
573   rr.AddReportBlock(rb2);
574 
575   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
576   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
577   InjectRtcpPacket(rr);
578 
579   std::vector<RTCPReportBlock> received_blocks;
580   rtcp_receiver_.StatisticsReceived(&received_blocks);
581   EXPECT_EQ(2u, received_blocks.size());
582 
583   // Verify that BYE removes the report blocks.
584   rtcp::Bye bye;
585   bye.SetSenderSsrc(kSenderSsrc);
586 
587   InjectRtcpPacket(bye);
588 
589   received_blocks.clear();
590   rtcp_receiver_.StatisticsReceived(&received_blocks);
591   EXPECT_TRUE(received_blocks.empty());
592 
593   // Inject packet again.
594   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
595   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
596   InjectRtcpPacket(rr);
597 
598   received_blocks.clear();
599   rtcp_receiver_.StatisticsReceived(&received_blocks);
600   EXPECT_EQ(2u, received_blocks.size());
601 }
602 
TEST_F(RtcpReceiverTest,InjectPliPacket)603 TEST_F(RtcpReceiverTest, InjectPliPacket) {
604   rtcp::Pli pli;
605   pli.SetMediaSsrc(kReceiverMainSsrc);
606 
607   EXPECT_CALL(
608       packet_type_counter_observer_,
609       RtcpPacketTypesCounterUpdated(
610           kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1)));
611   EXPECT_CALL(intra_frame_observer_,
612               OnReceivedIntraFrameRequest(kReceiverMainSsrc));
613   InjectRtcpPacket(pli);
614 }
615 
TEST_F(RtcpReceiverTest,PliPacketNotToUsIgnored)616 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
617   rtcp::Pli pli;
618   pli.SetMediaSsrc(kNotToUsSsrc);
619 
620   EXPECT_CALL(
621       packet_type_counter_observer_,
622       RtcpPacketTypesCounterUpdated(
623           kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0)));
624   EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0);
625   InjectRtcpPacket(pli);
626 }
627 
TEST_F(RtcpReceiverTest,InjectFirPacket)628 TEST_F(RtcpReceiverTest, InjectFirPacket) {
629   rtcp::Fir fir;
630   fir.AddRequestTo(kReceiverMainSsrc, 13);
631 
632   EXPECT_CALL(
633       packet_type_counter_observer_,
634       RtcpPacketTypesCounterUpdated(
635           kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1)));
636   EXPECT_CALL(intra_frame_observer_,
637               OnReceivedIntraFrameRequest(kReceiverMainSsrc));
638   InjectRtcpPacket(fir);
639 }
640 
TEST_F(RtcpReceiverTest,FirPacketNotToUsIgnored)641 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
642   rtcp::Fir fir;
643   fir.AddRequestTo(kNotToUsSsrc, 13);
644 
645   EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0);
646   InjectRtcpPacket(fir);
647 }
648 
TEST_F(RtcpReceiverTest,ExtendedReportsPacketWithZeroReportBlocksIgnored)649 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
650   rtcp::ExtendedReports xr;
651   xr.SetSenderSsrc(kSenderSsrc);
652 
653   InjectRtcpPacket(xr);
654 }
655 
656 // VOiP reports are ignored.
TEST_F(RtcpReceiverTest,InjectExtendedReportsVoipPacket)657 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
658   const uint8_t kLossRate = 123;
659   rtcp::VoipMetric voip_metric;
660   voip_metric.SetMediaSsrc(kReceiverMainSsrc);
661   RTCPVoIPMetric metric;
662   metric.lossRate = kLossRate;
663   voip_metric.SetVoipMetric(metric);
664   rtcp::ExtendedReports xr;
665   xr.SetSenderSsrc(kSenderSsrc);
666   xr.SetVoipMetric(voip_metric);
667 
668   InjectRtcpPacket(xr);
669 }
670 
TEST_F(RtcpReceiverTest,ExtendedReportsVoipPacketNotToUsIgnored)671 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
672   rtcp::VoipMetric voip_metric;
673   voip_metric.SetMediaSsrc(kNotToUsSsrc);
674   rtcp::ExtendedReports xr;
675   xr.SetSenderSsrc(kSenderSsrc);
676   xr.SetVoipMetric(voip_metric);
677 
678   InjectRtcpPacket(xr);
679 }
680 
TEST_F(RtcpReceiverTest,InjectExtendedReportsReceiverReferenceTimePacket)681 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
682   const NtpTime kNtp(0x10203, 0x40506);
683   rtcp::Rrtr rrtr;
684   rrtr.SetNtp(kNtp);
685   rtcp::ExtendedReports xr;
686   xr.SetSenderSsrc(kSenderSsrc);
687   xr.SetRrtr(rrtr);
688 
689   ReceiveTimeInfo rrtime;
690   EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
691 
692   InjectRtcpPacket(xr);
693 
694   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
695   EXPECT_EQ(rrtime.ssrc, kSenderSsrc);
696   EXPECT_EQ(rrtime.last_rr, CompactNtp(kNtp));
697   EXPECT_EQ(0U, rrtime.delay_since_last_rr);
698 
699   system_clock_.AdvanceTimeMilliseconds(1500);
700   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
701   EXPECT_NEAR(1500, CompactNtpRttToMs(rrtime.delay_since_last_rr), 1);
702 }
703 
TEST_F(RtcpReceiverTest,ExtendedReportsDlrrPacketNotToUsIgnored)704 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
705   // Allow calculate rtt using dlrr/rrtr, simulating media receiver side.
706   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
707 
708   rtcp::ExtendedReports xr;
709   xr.SetSenderSsrc(kSenderSsrc);
710   xr.AddDlrrItem(ReceiveTimeInfo(kNotToUsSsrc, 0x12345, 0x67890));
711 
712   InjectRtcpPacket(xr);
713 
714   int64_t rtt_ms = 0;
715   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
716 }
717 
TEST_F(RtcpReceiverTest,InjectExtendedReportsDlrrPacketWithSubBlock)718 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
719   const uint32_t kLastRR = 0x12345;
720   const uint32_t kDelay = 0x23456;
721   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
722   int64_t rtt_ms = 0;
723   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
724 
725   rtcp::ExtendedReports xr;
726   xr.SetSenderSsrc(kSenderSsrc);
727   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
728 
729   InjectRtcpPacket(xr);
730 
731   uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime());
732   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
733   uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
734   EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
735 }
736 
TEST_F(RtcpReceiverTest,InjectExtendedReportsDlrrPacketWithMultipleSubBlocks)737 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
738   const uint32_t kLastRR = 0x12345;
739   const uint32_t kDelay = 0x56789;
740   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
741 
742   rtcp::ExtendedReports xr;
743   xr.SetSenderSsrc(kSenderSsrc);
744   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
745   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 1, 0x12345, 0x67890));
746   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 2, 0x12345, 0x67890));
747 
748   InjectRtcpPacket(xr);
749 
750   uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime());
751   int64_t rtt_ms = 0;
752   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
753   uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
754   EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
755 }
756 
TEST_F(RtcpReceiverTest,InjectExtendedReportsPacketWithMultipleReportBlocks)757 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
758   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
759 
760   rtcp::Rrtr rrtr;
761   rtcp::VoipMetric metric;
762   metric.SetMediaSsrc(kReceiverMainSsrc);
763   rtcp::ExtendedReports xr;
764   xr.SetSenderSsrc(kSenderSsrc);
765   xr.SetRrtr(rrtr);
766   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
767   xr.SetVoipMetric(metric);
768 
769   InjectRtcpPacket(xr);
770 
771   ReceiveTimeInfo rrtime;
772   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
773   int64_t rtt_ms = 0;
774   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
775 }
776 
TEST_F(RtcpReceiverTest,InjectExtendedReportsPacketWithUnknownReportBlock)777 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
778   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
779 
780   rtcp::Rrtr rrtr;
781   rtcp::VoipMetric metric;
782   metric.SetMediaSsrc(kReceiverMainSsrc);
783   rtcp::ExtendedReports xr;
784   xr.SetSenderSsrc(kSenderSsrc);
785   xr.SetRrtr(rrtr);
786   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
787   xr.SetVoipMetric(metric);
788 
789   rtc::Buffer packet = xr.Build();
790   // Modify the DLRR block to have an unsupported block type, from 5 to 6.
791   ASSERT_EQ(5, packet.data()[20]);
792   packet.data()[20] = 6;
793   InjectRtcpPacket(packet);
794 
795   // Validate Rrtr was received and processed.
796   ReceiveTimeInfo rrtime;
797   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
798   // Validate Dlrr report wasn't processed.
799   int64_t rtt_ms = 0;
800   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
801 }
802 
TEST_F(RtcpReceiverTest,TestExtendedReportsRrRttInitiallyFalse)803 TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
804   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
805 
806   int64_t rtt_ms;
807   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
808 }
809 
TEST_F(RtcpReceiverTest,RttCalculatedAfterExtendedReportsDlrr)810 TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
811   Random rand(0x0123456789abcdef);
812   const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000);
813   const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
814   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
815   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
816   NtpTime now = system_clock_.CurrentNtpTime();
817   uint32_t sent_ntp = CompactNtp(now);
818   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
819 
820   rtcp::ExtendedReports xr;
821   xr.SetSenderSsrc(kSenderSsrc);
822   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
823 
824   InjectRtcpPacket(xr);
825 
826   int64_t rtt_ms = 0;
827   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
828   EXPECT_NEAR(kRttMs, rtt_ms, 1);
829 }
830 
TEST_F(RtcpReceiverTest,XrDlrrCalculatesNegativeRttAsOne)831 TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
832   Random rand(0x0123456789abcdef);
833   const int64_t kRttMs = rand.Rand(-3600 * 1000, -1);
834   const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
835   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
836   NtpTime now = system_clock_.CurrentNtpTime();
837   uint32_t sent_ntp = CompactNtp(now);
838   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
839   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
840 
841   rtcp::ExtendedReports xr;
842   xr.SetSenderSsrc(kSenderSsrc);
843   xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
844 
845   InjectRtcpPacket(xr);
846 
847   int64_t rtt_ms = 0;
848   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
849   EXPECT_EQ(1, rtt_ms);
850 }
851 
TEST_F(RtcpReceiverTest,LastReceivedXrReferenceTimeInfoInitiallyFalse)852 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) {
853   ReceiveTimeInfo info;
854   EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
855 }
856 
TEST_F(RtcpReceiverTest,GetLastReceivedExtendedReportsReferenceTimeInfo)857 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
858   const NtpTime kNtp(0x10203, 0x40506);
859   const uint32_t kNtpMid = CompactNtp(kNtp);
860 
861   rtcp::Rrtr rrtr;
862   rrtr.SetNtp(kNtp);
863   rtcp::ExtendedReports xr;
864   xr.SetSenderSsrc(kSenderSsrc);
865   xr.SetRrtr(rrtr);
866 
867   InjectRtcpPacket(xr);
868 
869   ReceiveTimeInfo info;
870   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
871   EXPECT_EQ(kSenderSsrc, info.ssrc);
872   EXPECT_EQ(kNtpMid, info.last_rr);
873   EXPECT_EQ(0U, info.delay_since_last_rr);
874 
875   system_clock_.AdvanceTimeMilliseconds(1000);
876   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
877   EXPECT_EQ(65536U, info.delay_since_last_rr);
878 }
879 
TEST_F(RtcpReceiverTest,ReceiveReportTimeout)880 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
881   const int64_t kRtcpIntervalMs = 1000;
882   const uint16_t kSequenceNumber = 1234;
883   system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
884 
885   // No RR received, shouldn't trigger a timeout.
886   EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
887   EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
888 
889   // Add a RR and advance the clock just enough to not trigger a timeout.
890   rtcp::ReportBlock rb1;
891   rb1.SetMediaSsrc(kReceiverMainSsrc);
892   rb1.SetExtHighestSeqNum(kSequenceNumber);
893   rtcp::ReceiverReport rr1;
894   rr1.SetSenderSsrc(kSenderSsrc);
895   rr1.AddReportBlock(rb1);
896 
897   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
898   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
899   InjectRtcpPacket(rr1);
900 
901   system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1);
902   EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
903   EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
904 
905   // Add a RR with the same extended max as the previous RR to trigger a
906   // sequence number timeout, but not a RR timeout.
907   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
908   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
909   InjectRtcpPacket(rr1);
910 
911   system_clock_.AdvanceTimeMilliseconds(2);
912   EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
913   EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
914 
915   // Advance clock enough to trigger an RR timeout too.
916   system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
917   EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
918 
919   // We should only get one timeout even though we still haven't received a new
920   // RR.
921   EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
922   EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
923 
924   // Add a new RR with increase sequence number to reset timers.
925   rtcp::ReportBlock rb2;
926   rb2.SetMediaSsrc(kReceiverMainSsrc);
927   rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
928   rtcp::ReceiverReport rr2;
929   rr2.SetSenderSsrc(kSenderSsrc);
930   rr2.AddReportBlock(rb2);
931 
932   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
933   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
934   InjectRtcpPacket(rr2);
935 
936   EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
937   EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
938 
939   // Verify we can get a timeout again once we've received new RR.
940   system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
941   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
942   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
943   InjectRtcpPacket(rr2);
944 
945   system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
946   EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
947   EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
948 
949   system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
950   EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs));
951 }
952 
TEST_F(RtcpReceiverTest,TmmbrReceivedWithNoIncomingPacket)953 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
954   EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size());
955 }
956 
TEST_F(RtcpReceiverTest,TmmbrPacketAccepted)957 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
958   const uint32_t kBitrateBps = 30000;
959   rtcp::Tmmbr tmmbr;
960   tmmbr.SetSenderSsrc(kSenderSsrc);
961   tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0));
962   rtcp::SenderReport sr;
963   sr.SetSenderSsrc(kSenderSsrc);
964   rtcp::CompoundPacket compound;
965   compound.Append(&sr);
966   compound.Append(&tmmbr);
967 
968   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
969   EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(SizeIs(1)));
970   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
971   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
972   InjectRtcpPacket(compound);
973 
974   std::vector<rtcp::TmmbItem> tmmbr_received = rtcp_receiver_.TmmbrReceived();
975   ASSERT_EQ(1u, tmmbr_received.size());
976   EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps());
977   EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc());
978 }
979 
TEST_F(RtcpReceiverTest,TmmbrPacketNotForUsIgnored)980 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
981   const uint32_t kBitrateBps = 30000;
982   rtcp::Tmmbr tmmbr;
983   tmmbr.SetSenderSsrc(kSenderSsrc);
984   tmmbr.AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0));
985 
986   rtcp::SenderReport sr;
987   sr.SetSenderSsrc(kSenderSsrc);
988   rtcp::CompoundPacket compound;
989   compound.Append(&sr);
990   compound.Append(&tmmbr);
991 
992   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
993   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
994   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0);
995   InjectRtcpPacket(compound);
996 
997   EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size());
998 }
999 
TEST_F(RtcpReceiverTest,TmmbrPacketZeroRateIgnored)1000 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
1001   rtcp::Tmmbr tmmbr;
1002   tmmbr.SetSenderSsrc(kSenderSsrc);
1003   tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0));
1004   rtcp::SenderReport sr;
1005   sr.SetSenderSsrc(kSenderSsrc);
1006   rtcp::CompoundPacket compound;
1007   compound.Append(&sr);
1008   compound.Append(&tmmbr);
1009 
1010   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1011   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1012   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0);
1013   InjectRtcpPacket(compound);
1014 
1015   EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size());
1016 }
1017 
TEST_F(RtcpReceiverTest,TmmbrThreeConstraintsTimeOut)1018 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
1019   // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
1020   // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
1021   for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
1022     rtcp::Tmmbr tmmbr;
1023     tmmbr.SetSenderSsrc(ssrc);
1024     tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0));
1025     rtcp::SenderReport sr;
1026     sr.SetSenderSsrc(ssrc);
1027     rtcp::CompoundPacket compound;
1028     compound.Append(&sr);
1029     compound.Append(&tmmbr);
1030 
1031     EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1032     EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(_));
1033     EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1034     EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_));
1035     InjectRtcpPacket(compound);
1036 
1037     // 5 seconds between each packet.
1038     system_clock_.AdvanceTimeMilliseconds(5000);
1039   }
1040   // It is now starttime + 15.
1041   std::vector<rtcp::TmmbItem> candidate_set = rtcp_receiver_.TmmbrReceived();
1042   ASSERT_EQ(3u, candidate_set.size());
1043   EXPECT_EQ(30000U, candidate_set[0].bitrate_bps());
1044 
1045   // We expect the timeout to be 25 seconds. Advance the clock by 12
1046   // seconds, timing out the first packet.
1047   system_clock_.AdvanceTimeMilliseconds(12000);
1048   candidate_set = rtcp_receiver_.TmmbrReceived();
1049   ASSERT_EQ(2u, candidate_set.size());
1050   EXPECT_EQ(kSenderSsrc + 1, candidate_set[0].ssrc());
1051 }
1052 
TEST_F(RtcpReceiverTest,Callbacks)1053 TEST_F(RtcpReceiverTest, Callbacks) {
1054   MockRtcpCallbackImpl callback;
1055   rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback);
1056 
1057   const uint8_t kFractionLoss = 3;
1058   const uint32_t kCumulativeLoss = 7;
1059   const uint32_t kJitter = 9;
1060   const uint16_t kSequenceNumber = 1234;
1061 
1062   // First packet, all numbers should just propagate.
1063   rtcp::ReportBlock rb1;
1064   rb1.SetMediaSsrc(kReceiverMainSsrc);
1065   rb1.SetExtHighestSeqNum(kSequenceNumber);
1066   rb1.SetFractionLost(kFractionLoss);
1067   rb1.SetCumulativeLost(kCumulativeLoss);
1068   rb1.SetJitter(kJitter);
1069 
1070   rtcp::ReceiverReport rr1;
1071   rr1.SetSenderSsrc(kSenderSsrc);
1072   rr1.AddReportBlock(rb1);
1073   EXPECT_CALL(callback,
1074               StatisticsUpdated(
1075                   AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss),
1076                         Field(&RtcpStatistics::packets_lost, kCumulativeLoss),
1077                         Field(&RtcpStatistics::extended_highest_sequence_number,
1078                               kSequenceNumber),
1079                         Field(&RtcpStatistics::jitter, kJitter)),
1080                   kReceiverMainSsrc));
1081   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1082   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1083   InjectRtcpPacket(rr1);
1084 
1085   rtcp_receiver_.RegisterRtcpStatisticsCallback(nullptr);
1086 
1087   // Add arbitrary numbers, callback should not be called.
1088   rtcp::ReportBlock rb2;
1089   rb2.SetMediaSsrc(kReceiverMainSsrc);
1090   rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
1091   rb2.SetFractionLost(42);
1092   rb2.SetCumulativeLost(137);
1093   rb2.SetJitter(4711);
1094 
1095   rtcp::ReceiverReport rr2;
1096   rr2.SetSenderSsrc(kSenderSsrc);
1097   rr2.AddReportBlock(rb2);
1098 
1099   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
1100   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1101   EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0);
1102   InjectRtcpPacket(rr2);
1103 }
1104 
TEST_F(RtcpReceiverTest,ReceivesTransportFeedback)1105 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
1106   rtcp::TransportFeedback packet;
1107   packet.SetMediaSsrc(kReceiverMainSsrc);
1108   packet.SetSenderSsrc(kSenderSsrc);
1109   packet.SetBase(1, 1000);
1110   packet.AddReceivedPacket(1, 1000);
1111 
1112   EXPECT_CALL(
1113       transport_feedback_observer_,
1114       OnTransportFeedback(AllOf(
1115           Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc),
1116           Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc))));
1117   InjectRtcpPacket(packet);
1118 }
1119 
TEST_F(RtcpReceiverTest,ReceivesRemb)1120 TEST_F(RtcpReceiverTest, ReceivesRemb) {
1121   const uint32_t kBitrateBps = 500000;
1122   rtcp::Remb remb;
1123   remb.SetSenderSsrc(kSenderSsrc);
1124   remb.SetBitrateBps(kBitrateBps);
1125 
1126   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
1127   InjectRtcpPacket(remb);
1128 }
1129 
TEST_F(RtcpReceiverTest,HandlesInvalidTransportFeedback)1130 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
1131   // Send a compound packet with a TransportFeedback followed by something else.
1132   rtcp::TransportFeedback packet;
1133   packet.SetMediaSsrc(kReceiverMainSsrc);
1134   packet.SetSenderSsrc(kSenderSsrc);
1135   packet.SetBase(1, 1000);
1136   packet.AddReceivedPacket(1, 1000);
1137 
1138   static uint32_t kBitrateBps = 50000;
1139   rtcp::Remb remb;
1140   remb.SetSenderSsrc(kSenderSsrc);
1141   remb.SetBitrateBps(kBitrateBps);
1142   rtcp::CompoundPacket compound;
1143   compound.Append(&packet);
1144   compound.Append(&remb);
1145   rtc::Buffer built_packet = compound.Build();
1146 
1147   // Modify the TransportFeedback packet so that it is invalid.
1148   const size_t kStatusCountOffset = 14;
1149   ByteWriter<uint16_t>::WriteBigEndian(
1150       &built_packet.data()[kStatusCountOffset], 42);
1151 
1152   // Stress no transport feedback is expected.
1153   EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0);
1154   // But remb should be processed and cause a callback
1155   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
1156   InjectRtcpPacket(built_packet);
1157 }
1158 
TEST_F(RtcpReceiverTest,Nack)1159 TEST_F(RtcpReceiverTest, Nack) {
1160   const uint16_t kNackList1[] = {1, 2, 3, 5};
1161   const uint16_t kNackList23[] = {5, 7, 30, 40, 41, 58, 59, 61, 63};
1162   const size_t kNackListLength2 = 4;
1163   const size_t kNackListLength3 = arraysize(kNackList23) - kNackListLength2;
1164   std::set<uint16_t> nack_set;
1165   nack_set.insert(std::begin(kNackList1), std::end(kNackList1));
1166   nack_set.insert(std::begin(kNackList23), std::end(kNackList23));
1167 
1168   rtcp::Nack nack1;
1169   nack1.SetSenderSsrc(kSenderSsrc);
1170   nack1.SetMediaSsrc(kReceiverMainSsrc);
1171   nack1.SetPacketIds(kNackList1, arraysize(kNackList1));
1172 
1173   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1)));
1174   EXPECT_CALL(packet_type_counter_observer_,
1175               RtcpPacketTypesCounterUpdated(
1176                   kReceiverMainSsrc,
1177                   AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
1178                               arraysize(kNackList1)),
1179                         Field(&RtcpPacketTypeCounter::unique_nack_requests,
1180                               arraysize(kNackList1)))));
1181   InjectRtcpPacket(nack1);
1182 
1183   rtcp::Nack nack2;
1184   nack2.SetSenderSsrc(kSenderSsrc);
1185   nack2.SetMediaSsrc(kReceiverMainSsrc);
1186   nack2.SetPacketIds(kNackList23, kNackListLength2);
1187 
1188   rtcp::Nack nack3;
1189   nack3.SetSenderSsrc(kSenderSsrc);
1190   nack3.SetMediaSsrc(kReceiverMainSsrc);
1191   nack3.SetPacketIds(kNackList23 + kNackListLength2, kNackListLength3);
1192 
1193   rtcp::CompoundPacket two_nacks;
1194   two_nacks.Append(&nack2);
1195   two_nacks.Append(&nack3);
1196 
1197   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList23)));
1198   EXPECT_CALL(packet_type_counter_observer_,
1199               RtcpPacketTypesCounterUpdated(
1200                   kReceiverMainSsrc,
1201                   AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
1202                               arraysize(kNackList1) + arraysize(kNackList23)),
1203                         Field(&RtcpPacketTypeCounter::unique_nack_requests,
1204                               nack_set.size()))));
1205   InjectRtcpPacket(two_nacks);
1206 }
1207 
TEST_F(RtcpReceiverTest,NackNotForUsIgnored)1208 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) {
1209   const uint16_t kNackList1[] = {1, 2, 3, 5};
1210   const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
1211 
1212   rtcp::Nack nack;
1213   nack.SetSenderSsrc(kSenderSsrc);
1214   nack.SetMediaSsrc(kNotToUsSsrc);
1215   nack.SetPacketIds(kNackList1, kNackListLength1);
1216 
1217   EXPECT_CALL(packet_type_counter_observer_,
1218               RtcpPacketTypesCounterUpdated(
1219                   _, Field(&RtcpPacketTypeCounter::nack_requests, 0)));
1220   InjectRtcpPacket(nack);
1221 }
1222 
TEST_F(RtcpReceiverTest,ForceSenderReport)1223 TEST_F(RtcpReceiverTest, ForceSenderReport) {
1224   rtcp::RapidResyncRequest rr;
1225   rr.SetSenderSsrc(kSenderSsrc);
1226   rr.SetMediaSsrc(kReceiverMainSsrc);
1227 
1228   EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport());
1229   InjectRtcpPacket(rr);
1230 }
1231 
TEST_F(RtcpReceiverTest,ReceivesTargetBitrate)1232 TEST_F(RtcpReceiverTest, ReceivesTargetBitrate) {
1233   BitrateAllocation expected_allocation;
1234   expected_allocation.SetBitrate(0, 0, 10000);
1235   expected_allocation.SetBitrate(0, 1, 20000);
1236   expected_allocation.SetBitrate(1, 0, 40000);
1237   expected_allocation.SetBitrate(1, 1, 80000);
1238 
1239   rtcp::TargetBitrate bitrate;
1240   bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
1241   bitrate.AddTargetBitrate(0, 1, expected_allocation.GetBitrate(0, 1) / 1000);
1242   bitrate.AddTargetBitrate(1, 0, expected_allocation.GetBitrate(1, 0) / 1000);
1243   bitrate.AddTargetBitrate(1, 1, expected_allocation.GetBitrate(1, 1) / 1000);
1244 
1245   rtcp::ExtendedReports xr;
1246   xr.SetTargetBitrate(bitrate);
1247 
1248   // Wrong sender ssrc, target bitrate should be discarded.
1249   xr.SetSenderSsrc(kSenderSsrc + 1);
1250   EXPECT_CALL(bitrate_allocation_observer_,
1251               OnBitrateAllocationUpdated(expected_allocation))
1252       .Times(0);
1253   InjectRtcpPacket(xr);
1254 
1255   // Set correct ssrc, callback should be called once.
1256   xr.SetSenderSsrc(kSenderSsrc);
1257   EXPECT_CALL(bitrate_allocation_observer_,
1258               OnBitrateAllocationUpdated(expected_allocation));
1259   InjectRtcpPacket(xr);
1260 }
1261 
TEST_F(RtcpReceiverTest,HandlesIncorrectTargetBitrate)1262 TEST_F(RtcpReceiverTest, HandlesIncorrectTargetBitrate) {
1263   BitrateAllocation expected_allocation;
1264   expected_allocation.SetBitrate(0, 0, 10000);
1265 
1266   rtcp::TargetBitrate bitrate;
1267   bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000);
1268   bitrate.AddTargetBitrate(0, kMaxTemporalStreams, 20000);
1269   bitrate.AddTargetBitrate(kMaxSpatialLayers, 0, 40000);
1270 
1271   rtcp::ExtendedReports xr;
1272   xr.SetTargetBitrate(bitrate);
1273   xr.SetSenderSsrc(kSenderSsrc);
1274 
1275   EXPECT_CALL(bitrate_allocation_observer_,
1276               OnBitrateAllocationUpdated(expected_allocation));
1277   InjectRtcpPacket(xr);
1278 }
1279 
1280 }  // namespace webrtc
1281