1 /*
2  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "modules/rtp_rtcp/source/rtcp_transceiver_impl.h"
12 
13 #include <memory>
14 #include <utility>
15 #include <vector>
16 
17 #include "absl/memory/memory.h"
18 #include "api/rtp_headers.h"
19 #include "api/video/video_bitrate_allocation.h"
20 #include "modules/rtp_rtcp/include/receive_statistics.h"
21 #include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
22 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
23 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
24 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
25 #include "modules/rtp_rtcp/source/time_util.h"
26 #include "rtc_base/event.h"
27 #include "rtc_base/fake_clock.h"
28 #include "rtc_base/task_queue_for_test.h"
29 #include "test/gmock.h"
30 #include "test/gtest.h"
31 #include "test/mock_transport.h"
32 #include "test/rtcp_packet_parser.h"
33 
34 namespace {
35 
36 using ::testing::_;
37 using ::testing::ElementsAre;
38 using ::testing::Return;
39 using ::testing::SizeIs;
40 using ::testing::StrictMock;
41 using ::webrtc::CompactNtp;
42 using ::webrtc::CompactNtpRttToMs;
43 using ::webrtc::MockRtcpRttStats;
44 using ::webrtc::MockTransport;
45 using ::webrtc::NtpTime;
46 using ::webrtc::RtcpTransceiverConfig;
47 using ::webrtc::RtcpTransceiverImpl;
48 using ::webrtc::SaturatedUsToCompactNtp;
49 using ::webrtc::TaskQueueForTest;
50 using ::webrtc::TimeMicrosToNtp;
51 using ::webrtc::VideoBitrateAllocation;
52 using ::webrtc::rtcp::Bye;
53 using ::webrtc::rtcp::CompoundPacket;
54 using ::webrtc::rtcp::ReportBlock;
55 using ::webrtc::rtcp::SenderReport;
56 using ::webrtc::test::RtcpPacketParser;
57 
58 class MockReceiveStatisticsProvider : public webrtc::ReceiveStatisticsProvider {
59  public:
60   MOCK_METHOD(std::vector<ReportBlock>, RtcpReportBlocks, (size_t), (override));
61 };
62 
63 class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
64  public:
65   MOCK_METHOD(void, OnSenderReport, (uint32_t, NtpTime, uint32_t), (override));
66   MOCK_METHOD(void, OnBye, (uint32_t), (override));
67   MOCK_METHOD(void,
68               OnBitrateAllocation,
69               (uint32_t, const VideoBitrateAllocation&),
70               (override));
71 };
72 
73 // Since some tests will need to wait for this period, make it small to avoid
74 // slowing tests too much. As long as there are test bots with high scheduler
75 // granularity, small period should be ok.
76 constexpr int kReportPeriodMs = 10;
77 // On some systems task queue might be slow, instead of guessing right
78 // grace period, use very large timeout, 100x larger expected wait time.
79 // Use finite timeout to fail tests rather than hang them.
80 constexpr int kAlmostForeverMs = 1000;
81 
82 // Helper to wait for an rtcp packet produced on a different thread/task queue.
83 class FakeRtcpTransport : public webrtc::Transport {
84  public:
SendRtcp(const uint8_t * data,size_t size)85   bool SendRtcp(const uint8_t* data, size_t size) override {
86     sent_rtcp_.Set();
87     return true;
88   }
SendRtp(const uint8_t *,size_t,const webrtc::PacketOptions &)89   bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
90     ADD_FAILURE() << "RtcpTransciver shouldn't send rtp packets.";
91     return true;
92   }
93 
94   // Returns true when packet was received by the transport.
WaitPacket()95   bool WaitPacket() {
96     // Normally packet should be sent fast, long before the timeout.
97     bool packet_sent = sent_rtcp_.Wait(kAlmostForeverMs);
98     // Disallow tests to wait almost forever for no packets.
99     EXPECT_TRUE(packet_sent);
100     // Return wait result even though it is expected to be true, so that
101     // individual tests can EXPECT on it for better error message.
102     return packet_sent;
103   }
104 
105  private:
106   rtc::Event sent_rtcp_;
107 };
108 
109 class RtcpParserTransport : public webrtc::Transport {
110  public:
RtcpParserTransport(RtcpPacketParser * parser)111   explicit RtcpParserTransport(RtcpPacketParser* parser) : parser_(parser) {}
112   // Returns total number of rtcp packet received.
num_packets() const113   int num_packets() const { return num_packets_; }
114 
115  private:
SendRtcp(const uint8_t * data,size_t size)116   bool SendRtcp(const uint8_t* data, size_t size) override {
117     ++num_packets_;
118     parser_->Parse(data, size);
119     return true;
120   }
121 
SendRtp(const uint8_t *,size_t,const webrtc::PacketOptions &)122   bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
123     ADD_FAILURE() << "RtcpTransciver shouldn't send rtp packets.";
124     return true;
125   }
126 
127   RtcpPacketParser* const parser_;
128   int num_packets_ = 0;
129 };
130 
DefaultTestConfig()131 RtcpTransceiverConfig DefaultTestConfig() {
132   // RtcpTransceiverConfig default constructor sets default values for prod.
133   // Test doesn't need to support all key features: Default test config returns
134   // valid config with all features turned off.
135   static MockTransport null_transport;
136   RtcpTransceiverConfig config;
137   config.outgoing_transport = &null_transport;
138   config.schedule_periodic_compound_packets = false;
139   config.initial_report_delay_ms = 10;
140   config.report_period_ms = kReportPeriodMs;
141   return config;
142 }
143 
TEST(RtcpTransceiverImplTest,NeedToStopPeriodicTaskToDestroyOnTaskQueue)144 TEST(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
145   FakeRtcpTransport transport;
146   TaskQueueForTest queue("rtcp");
147   RtcpTransceiverConfig config = DefaultTestConfig();
148   config.task_queue = queue.Get();
149   config.schedule_periodic_compound_packets = true;
150   config.outgoing_transport = &transport;
151   auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
152   // Wait for a periodic packet.
153   EXPECT_TRUE(transport.WaitPacket());
154 
155   rtc::Event done;
156   queue.PostTask([rtcp_transceiver, &done] {
157     rtcp_transceiver->StopPeriodicTask();
158     delete rtcp_transceiver;
159     done.Set();
160   });
161   ASSERT_TRUE(done.Wait(/*milliseconds=*/1000));
162 }
163 
TEST(RtcpTransceiverImplTest,CanDestroyAfterTaskQueue)164 TEST(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
165   FakeRtcpTransport transport;
166   auto* queue = new TaskQueueForTest("rtcp");
167   RtcpTransceiverConfig config = DefaultTestConfig();
168   config.task_queue = queue->Get();
169   config.schedule_periodic_compound_packets = true;
170   config.outgoing_transport = &transport;
171   auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
172   // Wait for a periodic packet.
173   EXPECT_TRUE(transport.WaitPacket());
174 
175   delete queue;
176   delete rtcp_transceiver;
177 }
178 
TEST(RtcpTransceiverImplTest,DelaysSendingFirstCompondPacket)179 TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
180   TaskQueueForTest queue("rtcp");
181   FakeRtcpTransport transport;
182   RtcpTransceiverConfig config;
183   config.outgoing_transport = &transport;
184   config.initial_report_delay_ms = 10;
185   config.task_queue = queue.Get();
186   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
187 
188   int64_t started_ms = rtc::TimeMillis();
189   queue.PostTask([&] { rtcp_transceiver.emplace(config); });
190   EXPECT_TRUE(transport.WaitPacket());
191 
192   EXPECT_GE(rtc::TimeMillis() - started_ms, config.initial_report_delay_ms);
193 
194   // Cleanup.
195   rtc::Event done;
196   queue.PostTask([&] {
197     rtcp_transceiver->StopPeriodicTask();
198     rtcp_transceiver.reset();
199     done.Set();
200   });
201   ASSERT_TRUE(done.Wait(kAlmostForeverMs));
202 }
203 
TEST(RtcpTransceiverImplTest,PeriodicallySendsPackets)204 TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
205   TaskQueueForTest queue("rtcp");
206   FakeRtcpTransport transport;
207   RtcpTransceiverConfig config;
208   config.outgoing_transport = &transport;
209   config.initial_report_delay_ms = 0;
210   config.report_period_ms = kReportPeriodMs;
211   config.task_queue = queue.Get();
212   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
213   int64_t time_just_before_1st_packet_ms = 0;
214   queue.PostTask([&] {
215     // Because initial_report_delay_ms is set to 0, time_just_before_the_packet
216     // should be very close to the time_of_the_packet.
217     time_just_before_1st_packet_ms = rtc::TimeMillis();
218     rtcp_transceiver.emplace(config);
219   });
220 
221   EXPECT_TRUE(transport.WaitPacket());
222   EXPECT_TRUE(transport.WaitPacket());
223   int64_t time_just_after_2nd_packet_ms = rtc::TimeMillis();
224 
225   EXPECT_GE(time_just_after_2nd_packet_ms - time_just_before_1st_packet_ms,
226             config.report_period_ms - 1);
227 
228   // Cleanup.
229   rtc::Event done;
230   queue.PostTask([&] {
231     rtcp_transceiver->StopPeriodicTask();
232     rtcp_transceiver.reset();
233     done.Set();
234   });
235   ASSERT_TRUE(done.Wait(kAlmostForeverMs));
236 }
237 
TEST(RtcpTransceiverImplTest,SendCompoundPacketDelaysPeriodicSendPackets)238 TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
239   TaskQueueForTest queue("rtcp");
240   FakeRtcpTransport transport;
241   RtcpTransceiverConfig config;
242   config.outgoing_transport = &transport;
243   config.initial_report_delay_ms = 0;
244   config.report_period_ms = kReportPeriodMs;
245   config.task_queue = queue.Get();
246   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
247   queue.PostTask([&] { rtcp_transceiver.emplace(config); });
248 
249   // Wait for first packet.
250   EXPECT_TRUE(transport.WaitPacket());
251   // Send non periodic one after half period.
252   rtc::Event non_periodic;
253   int64_t time_of_non_periodic_packet_ms = 0;
254   queue.PostDelayedTask(
255       [&] {
256         time_of_non_periodic_packet_ms = rtc::TimeMillis();
257         rtcp_transceiver->SendCompoundPacket();
258         non_periodic.Set();
259       },
260       config.report_period_ms / 2);
261   // Though non-periodic packet is scheduled just in between periodic, due to
262   // small period and task queue flakiness it migth end-up 1ms after next
263   // periodic packet. To be sure duration after non-periodic packet is tested
264   // wait for transport after ensuring non-periodic packet was sent.
265   EXPECT_TRUE(non_periodic.Wait(kAlmostForeverMs));
266   EXPECT_TRUE(transport.WaitPacket());
267   // Wait for next periodic packet.
268   EXPECT_TRUE(transport.WaitPacket());
269   int64_t time_of_last_periodic_packet_ms = rtc::TimeMillis();
270 
271   EXPECT_GE(time_of_last_periodic_packet_ms - time_of_non_periodic_packet_ms,
272             config.report_period_ms - 1);
273 
274   // Cleanup.
275   rtc::Event done;
276   queue.PostTask([&] {
277     rtcp_transceiver->StopPeriodicTask();
278     rtcp_transceiver.reset();
279     done.Set();
280   });
281   ASSERT_TRUE(done.Wait(kAlmostForeverMs));
282 }
283 
TEST(RtcpTransceiverImplTest,SendsNoRtcpWhenNetworkStateIsDown)284 TEST(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
285   MockTransport mock_transport;
286   RtcpTransceiverConfig config = DefaultTestConfig();
287   config.initial_ready_to_send = false;
288   config.outgoing_transport = &mock_transport;
289   RtcpTransceiverImpl rtcp_transceiver(config);
290 
291   EXPECT_CALL(mock_transport, SendRtcp(_, _)).Times(0);
292 
293   const uint8_t raw[] = {1, 2, 3, 4};
294   const std::vector<uint16_t> sequence_numbers = {45, 57};
295   const uint32_t ssrcs[] = {123};
296   rtcp_transceiver.SendCompoundPacket();
297   rtcp_transceiver.SendRawPacket(raw);
298   rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
299   rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
300   rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
301 }
302 
TEST(RtcpTransceiverImplTest,SendsRtcpWhenNetworkStateIsUp)303 TEST(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
304   MockTransport mock_transport;
305   RtcpTransceiverConfig config = DefaultTestConfig();
306   config.initial_ready_to_send = false;
307   config.outgoing_transport = &mock_transport;
308   RtcpTransceiverImpl rtcp_transceiver(config);
309 
310   rtcp_transceiver.SetReadyToSend(true);
311 
312   EXPECT_CALL(mock_transport, SendRtcp(_, _)).Times(5);
313 
314   const uint8_t raw[] = {1, 2, 3, 4};
315   const std::vector<uint16_t> sequence_numbers = {45, 57};
316   const uint32_t ssrcs[] = {123};
317   rtcp_transceiver.SendCompoundPacket();
318   rtcp_transceiver.SendRawPacket(raw);
319   rtcp_transceiver.SendNack(ssrcs[0], sequence_numbers);
320   rtcp_transceiver.SendPictureLossIndication(ssrcs[0]);
321   rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
322 }
323 
TEST(RtcpTransceiverImplTest,SendsPeriodicRtcpWhenNetworkStateIsUp)324 TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
325   TaskQueueForTest queue("rtcp");
326   FakeRtcpTransport transport;
327   RtcpTransceiverConfig config = DefaultTestConfig();
328   config.schedule_periodic_compound_packets = true;
329   config.initial_ready_to_send = false;
330   config.outgoing_transport = &transport;
331   config.task_queue = queue.Get();
332   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
333   rtcp_transceiver.emplace(config);
334 
335   queue.PostTask([&] { rtcp_transceiver->SetReadyToSend(true); });
336 
337   EXPECT_TRUE(transport.WaitPacket());
338 
339   // Cleanup.
340   rtc::Event done;
341   queue.PostTask([&] {
342     rtcp_transceiver->StopPeriodicTask();
343     rtcp_transceiver.reset();
344     done.Set();
345   });
346   ASSERT_TRUE(done.Wait(kAlmostForeverMs));
347 }
348 
TEST(RtcpTransceiverImplTest,SendsMinimalCompoundPacket)349 TEST(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
350   const uint32_t kSenderSsrc = 12345;
351   RtcpTransceiverConfig config;
352   config.feedback_ssrc = kSenderSsrc;
353   config.cname = "cname";
354   RtcpPacketParser rtcp_parser;
355   RtcpParserTransport transport(&rtcp_parser);
356   config.outgoing_transport = &transport;
357   config.schedule_periodic_compound_packets = false;
358   RtcpTransceiverImpl rtcp_transceiver(config);
359 
360   rtcp_transceiver.SendCompoundPacket();
361 
362   // Minimal compound RTCP packet contains sender or receiver report and sdes
363   // with cname.
364   ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
365   EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
366   ASSERT_GT(rtcp_parser.sdes()->num_packets(), 0);
367   ASSERT_EQ(rtcp_parser.sdes()->chunks().size(), 1u);
368   EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].ssrc, kSenderSsrc);
369   EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].cname, config.cname);
370 }
371 
TEST(RtcpTransceiverImplTest,SendsNoRembInitially)372 TEST(RtcpTransceiverImplTest, SendsNoRembInitially) {
373   const uint32_t kSenderSsrc = 12345;
374   RtcpTransceiverConfig config;
375   config.feedback_ssrc = kSenderSsrc;
376   RtcpPacketParser rtcp_parser;
377   RtcpParserTransport transport(&rtcp_parser);
378   config.outgoing_transport = &transport;
379   config.schedule_periodic_compound_packets = false;
380   RtcpTransceiverImpl rtcp_transceiver(config);
381 
382   rtcp_transceiver.SendCompoundPacket();
383 
384   EXPECT_EQ(transport.num_packets(), 1);
385   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 0);
386 }
387 
TEST(RtcpTransceiverImplTest,SetRembIncludesRembInNextCompoundPacket)388 TEST(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
389   const uint32_t kSenderSsrc = 12345;
390   RtcpTransceiverConfig config;
391   config.feedback_ssrc = kSenderSsrc;
392   RtcpPacketParser rtcp_parser;
393   RtcpParserTransport transport(&rtcp_parser);
394   config.outgoing_transport = &transport;
395   config.schedule_periodic_compound_packets = false;
396   RtcpTransceiverImpl rtcp_transceiver(config);
397 
398   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
399   rtcp_transceiver.SendCompoundPacket();
400 
401   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
402   EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
403   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
404   EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
405 }
406 
TEST(RtcpTransceiverImplTest,SetRembUpdatesValuesToSend)407 TEST(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
408   const uint32_t kSenderSsrc = 12345;
409   RtcpTransceiverConfig config;
410   config.feedback_ssrc = kSenderSsrc;
411   RtcpPacketParser rtcp_parser;
412   RtcpParserTransport transport(&rtcp_parser);
413   config.outgoing_transport = &transport;
414   config.schedule_periodic_compound_packets = false;
415   RtcpTransceiverImpl rtcp_transceiver(config);
416 
417   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
418   rtcp_transceiver.SendCompoundPacket();
419 
420   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
421   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
422   EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
423 
424   rtcp_transceiver.SetRemb(/*bitrate_bps=*/70000, /*ssrcs=*/{67321});
425   rtcp_transceiver.SendCompoundPacket();
426 
427   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
428   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 70000);
429   EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(67321));
430 }
431 
TEST(RtcpTransceiverImplTest,SetRembSendsImmediatelyIfSendRembOnChange)432 TEST(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
433   const uint32_t kSenderSsrc = 12345;
434   RtcpTransceiverConfig config;
435   config.send_remb_on_change = true;
436   config.feedback_ssrc = kSenderSsrc;
437   RtcpPacketParser rtcp_parser;
438   RtcpParserTransport transport(&rtcp_parser);
439   config.outgoing_transport = &transport;
440   config.schedule_periodic_compound_packets = false;
441   RtcpTransceiverImpl rtcp_transceiver(config);
442 
443   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
444   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
445   EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
446   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
447 
448   // If there is no change, the packet is not sent immediately.
449   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
450   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
451 
452   rtcp_transceiver.SetRemb(/*bitrate_bps=*/20000, /*ssrcs=*/{});
453   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
454   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 20000);
455 }
456 
TEST(RtcpTransceiverImplTest,SetRembSendsImmediatelyIfSendRembOnChangeReducedSize)457 TEST(RtcpTransceiverImplTest,
458      SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
459   const uint32_t kSenderSsrc = 12345;
460   RtcpTransceiverConfig config;
461   config.send_remb_on_change = true;
462   config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
463   config.feedback_ssrc = kSenderSsrc;
464   RtcpPacketParser rtcp_parser;
465   RtcpParserTransport transport(&rtcp_parser);
466   config.outgoing_transport = &transport;
467   config.schedule_periodic_compound_packets = false;
468   RtcpTransceiverImpl rtcp_transceiver(config);
469 
470   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{});
471   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
472   EXPECT_EQ(rtcp_parser.remb()->sender_ssrc(), kSenderSsrc);
473   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
474 }
475 
TEST(RtcpTransceiverImplTest,SetRembIncludesRembInAllCompoundPackets)476 TEST(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
477   const uint32_t kSenderSsrc = 12345;
478   RtcpTransceiverConfig config;
479   config.feedback_ssrc = kSenderSsrc;
480   RtcpPacketParser rtcp_parser;
481   RtcpParserTransport transport(&rtcp_parser);
482   config.outgoing_transport = &transport;
483   config.schedule_periodic_compound_packets = false;
484   RtcpTransceiverImpl rtcp_transceiver(config);
485 
486   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
487   rtcp_transceiver.SendCompoundPacket();
488   rtcp_transceiver.SendCompoundPacket();
489 
490   EXPECT_EQ(transport.num_packets(), 2);
491   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
492 }
493 
TEST(RtcpTransceiverImplTest,SendsNoRembAfterUnset)494 TEST(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
495   const uint32_t kSenderSsrc = 12345;
496   RtcpTransceiverConfig config;
497   config.feedback_ssrc = kSenderSsrc;
498   RtcpPacketParser rtcp_parser;
499   RtcpParserTransport transport(&rtcp_parser);
500   config.outgoing_transport = &transport;
501   config.schedule_periodic_compound_packets = false;
502   RtcpTransceiverImpl rtcp_transceiver(config);
503 
504   rtcp_transceiver.SetRemb(/*bitrate_bps=*/10000, /*ssrcs=*/{54321, 64321});
505   rtcp_transceiver.SendCompoundPacket();
506   EXPECT_EQ(transport.num_packets(), 1);
507   ASSERT_EQ(rtcp_parser.remb()->num_packets(), 1);
508 
509   rtcp_transceiver.UnsetRemb();
510   rtcp_transceiver.SendCompoundPacket();
511 
512   EXPECT_EQ(transport.num_packets(), 2);
513   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
514 }
515 
TEST(RtcpTransceiverImplTest,ReceiverReportUsesReceiveStatistics)516 TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
517   const uint32_t kSenderSsrc = 12345;
518   const uint32_t kMediaSsrc = 54321;
519   MockReceiveStatisticsProvider receive_statistics;
520   std::vector<ReportBlock> report_blocks(1);
521   report_blocks[0].SetMediaSsrc(kMediaSsrc);
522   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
523       .WillRepeatedly(Return(report_blocks));
524 
525   RtcpTransceiverConfig config;
526   config.feedback_ssrc = kSenderSsrc;
527   RtcpPacketParser rtcp_parser;
528   RtcpParserTransport transport(&rtcp_parser);
529   config.outgoing_transport = &transport;
530   config.receive_statistics = &receive_statistics;
531   config.schedule_periodic_compound_packets = false;
532   RtcpTransceiverImpl rtcp_transceiver(config);
533 
534   rtcp_transceiver.SendCompoundPacket();
535 
536   ASSERT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
537   EXPECT_EQ(rtcp_parser.receiver_report()->sender_ssrc(), kSenderSsrc);
538   ASSERT_THAT(rtcp_parser.receiver_report()->report_blocks(),
539               SizeIs(report_blocks.size()));
540   EXPECT_EQ(rtcp_parser.receiver_report()->report_blocks()[0].source_ssrc(),
541             kMediaSsrc);
542 }
543 
TEST(RtcpTransceiverImplTest,MultipleObserversOnSameSsrc)544 TEST(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
545   const uint32_t kRemoteSsrc = 12345;
546   StrictMock<MockMediaReceiverRtcpObserver> observer1;
547   StrictMock<MockMediaReceiverRtcpObserver> observer2;
548   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
549   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
550   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
551 
552   const NtpTime kRemoteNtp(0x9876543211);
553   const uint32_t kRemoteRtp = 0x444555;
554   SenderReport sr;
555   sr.SetSenderSsrc(kRemoteSsrc);
556   sr.SetNtp(kRemoteNtp);
557   sr.SetRtpTimestamp(kRemoteRtp);
558   auto raw_packet = sr.Build();
559 
560   EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
561   EXPECT_CALL(observer2, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
562   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
563 }
564 
TEST(RtcpTransceiverImplTest,DoesntCallsObserverAfterRemoved)565 TEST(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
566   const uint32_t kRemoteSsrc = 12345;
567   StrictMock<MockMediaReceiverRtcpObserver> observer1;
568   StrictMock<MockMediaReceiverRtcpObserver> observer2;
569   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
570   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
571   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
572 
573   SenderReport sr;
574   sr.SetSenderSsrc(kRemoteSsrc);
575   auto raw_packet = sr.Build();
576 
577   rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
578 
579   EXPECT_CALL(observer1, OnSenderReport(_, _, _)).Times(0);
580   EXPECT_CALL(observer2, OnSenderReport(_, _, _));
581   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
582 }
583 
TEST(RtcpTransceiverImplTest,CallsObserverOnSenderReportBySenderSsrc)584 TEST(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
585   const uint32_t kRemoteSsrc1 = 12345;
586   const uint32_t kRemoteSsrc2 = 22345;
587   StrictMock<MockMediaReceiverRtcpObserver> observer1;
588   StrictMock<MockMediaReceiverRtcpObserver> observer2;
589   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
590   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
591   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
592 
593   const NtpTime kRemoteNtp(0x9876543211);
594   const uint32_t kRemoteRtp = 0x444555;
595   SenderReport sr;
596   sr.SetSenderSsrc(kRemoteSsrc1);
597   sr.SetNtp(kRemoteNtp);
598   sr.SetRtpTimestamp(kRemoteRtp);
599   auto raw_packet = sr.Build();
600 
601   EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc1, kRemoteNtp, kRemoteRtp));
602   EXPECT_CALL(observer2, OnSenderReport(_, _, _)).Times(0);
603   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
604 }
605 
TEST(RtcpTransceiverImplTest,CallsObserverOnByeBySenderSsrc)606 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
607   const uint32_t kRemoteSsrc1 = 12345;
608   const uint32_t kRemoteSsrc2 = 22345;
609   StrictMock<MockMediaReceiverRtcpObserver> observer1;
610   StrictMock<MockMediaReceiverRtcpObserver> observer2;
611   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
612   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
613   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
614 
615   Bye bye;
616   bye.SetSenderSsrc(kRemoteSsrc1);
617   auto raw_packet = bye.Build();
618 
619   EXPECT_CALL(observer1, OnBye(kRemoteSsrc1));
620   EXPECT_CALL(observer2, OnBye(_)).Times(0);
621   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
622 }
623 
TEST(RtcpTransceiverImplTest,CallsObserverOnTargetBitrateBySenderSsrc)624 TEST(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
625   const uint32_t kRemoteSsrc1 = 12345;
626   const uint32_t kRemoteSsrc2 = 22345;
627   StrictMock<MockMediaReceiverRtcpObserver> observer1;
628   StrictMock<MockMediaReceiverRtcpObserver> observer2;
629   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
630   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
631   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
632 
633   webrtc::rtcp::TargetBitrate target_bitrate;
634   target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
635   target_bitrate.AddTargetBitrate(0, 1, /*target_bitrate_kbps=*/20);
636   target_bitrate.AddTargetBitrate(1, 0, /*target_bitrate_kbps=*/40);
637   target_bitrate.AddTargetBitrate(1, 1, /*target_bitrate_kbps=*/80);
638   webrtc::rtcp::ExtendedReports xr;
639   xr.SetSenderSsrc(kRemoteSsrc1);
640   xr.SetTargetBitrate(target_bitrate);
641   auto raw_packet = xr.Build();
642 
643   VideoBitrateAllocation bitrate_allocation;
644   bitrate_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
645   bitrate_allocation.SetBitrate(0, 1, /*bitrate_bps=*/20000);
646   bitrate_allocation.SetBitrate(1, 0, /*bitrate_bps=*/40000);
647   bitrate_allocation.SetBitrate(1, 1, /*bitrate_bps=*/80000);
648   EXPECT_CALL(observer1, OnBitrateAllocation(kRemoteSsrc1, bitrate_allocation));
649   EXPECT_CALL(observer2, OnBitrateAllocation(_, _)).Times(0);
650   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
651 }
652 
TEST(RtcpTransceiverImplTest,SkipsIncorrectTargetBitrateEntries)653 TEST(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
654   const uint32_t kRemoteSsrc = 12345;
655   MockMediaReceiverRtcpObserver observer;
656   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
657   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
658 
659   webrtc::rtcp::TargetBitrate target_bitrate;
660   target_bitrate.AddTargetBitrate(0, 0, /*target_bitrate_kbps=*/10);
661   target_bitrate.AddTargetBitrate(0, webrtc::kMaxTemporalStreams, 20);
662   target_bitrate.AddTargetBitrate(webrtc::kMaxSpatialLayers, 0, 40);
663 
664   webrtc::rtcp::ExtendedReports xr;
665   xr.SetTargetBitrate(target_bitrate);
666   xr.SetSenderSsrc(kRemoteSsrc);
667   auto raw_packet = xr.Build();
668 
669   VideoBitrateAllocation expected_allocation;
670   expected_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
671   EXPECT_CALL(observer, OnBitrateAllocation(kRemoteSsrc, expected_allocation));
672   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
673 }
674 
TEST(RtcpTransceiverImplTest,CallsObserverOnByeBehindSenderReport)675 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
676   const uint32_t kRemoteSsrc = 12345;
677   MockMediaReceiverRtcpObserver observer;
678   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
679   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
680 
681   CompoundPacket compound;
682   auto sr = std::make_unique<SenderReport>();
683   sr->SetSenderSsrc(kRemoteSsrc);
684   compound.Append(std::move(sr));
685   auto bye = std::make_unique<Bye>();
686   bye->SetSenderSsrc(kRemoteSsrc);
687   compound.Append(std::move(bye));
688   auto raw_packet = compound.Build();
689 
690   EXPECT_CALL(observer, OnBye(kRemoteSsrc));
691   EXPECT_CALL(observer, OnSenderReport(kRemoteSsrc, _, _));
692   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
693 }
694 
TEST(RtcpTransceiverImplTest,CallsObserverOnByeBehindUnknownRtcpPacket)695 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
696   const uint32_t kRemoteSsrc = 12345;
697   MockMediaReceiverRtcpObserver observer;
698   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
699   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
700 
701   CompoundPacket compound;
702   // Use Application-Defined rtcp packet as unknown.
703   auto app = std::make_unique<webrtc::rtcp::App>();
704   compound.Append(std::move(app));
705   auto bye = std::make_unique<Bye>();
706   bye->SetSenderSsrc(kRemoteSsrc);
707   compound.Append(std::move(bye));
708   auto raw_packet = compound.Build();
709 
710   EXPECT_CALL(observer, OnBye(kRemoteSsrc));
711   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
712 }
713 
TEST(RtcpTransceiverImplTest,WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc)714 TEST(RtcpTransceiverImplTest,
715      WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc) {
716   const uint32_t kRemoteSsrc1 = 4321;
717   const uint32_t kRemoteSsrc2 = 5321;
718   std::vector<ReportBlock> statistics_report_blocks(2);
719   statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
720   statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
721   MockReceiveStatisticsProvider receive_statistics;
722   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
723       .WillOnce(Return(statistics_report_blocks));
724 
725   RtcpTransceiverConfig config;
726   config.schedule_periodic_compound_packets = false;
727   RtcpPacketParser rtcp_parser;
728   RtcpParserTransport transport(&rtcp_parser);
729   config.outgoing_transport = &transport;
730   config.receive_statistics = &receive_statistics;
731   RtcpTransceiverImpl rtcp_transceiver(config);
732 
733   const NtpTime kRemoteNtp(0x9876543211);
734   // Receive SenderReport for RemoteSsrc1, but no report for RemoteSsrc2.
735   SenderReport sr;
736   sr.SetSenderSsrc(kRemoteSsrc1);
737   sr.SetNtp(kRemoteNtp);
738   auto raw_packet = sr.Build();
739   rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
740 
741   // Trigger sending ReceiverReport.
742   rtcp_transceiver.SendCompoundPacket();
743 
744   EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
745   const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
746   ASSERT_EQ(report_blocks.size(), 2u);
747   // RtcpTransceiverImpl doesn't guarantee order of the report blocks
748   // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
749   // but for simplicity of the test asume it is the same.
750   ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
751   EXPECT_EQ(report_blocks[0].last_sr(), CompactNtp(kRemoteNtp));
752 
753   ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
754   // No matching Sender Report for kRemoteSsrc2, LastSR fields has to be 0.
755   EXPECT_EQ(report_blocks[1].last_sr(), 0u);
756 }
757 
TEST(RtcpTransceiverImplTest,WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport)758 TEST(RtcpTransceiverImplTest,
759      WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
760   const uint32_t kRemoteSsrc1 = 4321;
761   const uint32_t kRemoteSsrc2 = 5321;
762   rtc::ScopedFakeClock clock;
763   std::vector<ReportBlock> statistics_report_blocks(2);
764   statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
765   statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
766   MockReceiveStatisticsProvider receive_statistics;
767   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
768       .WillOnce(Return(statistics_report_blocks));
769 
770   RtcpTransceiverConfig config;
771   config.schedule_periodic_compound_packets = false;
772   RtcpPacketParser rtcp_parser;
773   RtcpParserTransport transport(&rtcp_parser);
774   config.outgoing_transport = &transport;
775   config.receive_statistics = &receive_statistics;
776   RtcpTransceiverImpl rtcp_transceiver(config);
777 
778   auto receive_sender_report = [&rtcp_transceiver](uint32_t remote_ssrc) {
779     SenderReport sr;
780     sr.SetSenderSsrc(remote_ssrc);
781     auto raw_packet = sr.Build();
782     rtcp_transceiver.ReceivePacket(raw_packet, rtc::TimeMicros());
783   };
784 
785   receive_sender_report(kRemoteSsrc1);
786   clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
787 
788   receive_sender_report(kRemoteSsrc2);
789   clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
790 
791   // Trigger ReceiverReport back.
792   rtcp_transceiver.SendCompoundPacket();
793 
794   EXPECT_GT(rtcp_parser.receiver_report()->num_packets(), 0);
795   const auto& report_blocks = rtcp_parser.receiver_report()->report_blocks();
796   ASSERT_EQ(report_blocks.size(), 2u);
797   // RtcpTransceiverImpl doesn't guarantee order of the report blocks
798   // match result of ReceiveStatisticsProvider::RtcpReportBlocks callback,
799   // but for simplicity of the test asume it is the same.
800   ASSERT_EQ(report_blocks[0].source_ssrc(), kRemoteSsrc1);
801   EXPECT_EQ(CompactNtpRttToMs(report_blocks[0].delay_since_last_sr()), 200);
802 
803   ASSERT_EQ(report_blocks[1].source_ssrc(), kRemoteSsrc2);
804   EXPECT_EQ(CompactNtpRttToMs(report_blocks[1].delay_since_last_sr()), 100);
805 }
806 
TEST(RtcpTransceiverImplTest,SendsNack)807 TEST(RtcpTransceiverImplTest, SendsNack) {
808   const uint32_t kSenderSsrc = 1234;
809   const uint32_t kRemoteSsrc = 4321;
810   std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
811   RtcpTransceiverConfig config;
812   config.feedback_ssrc = kSenderSsrc;
813   config.schedule_periodic_compound_packets = false;
814   RtcpPacketParser rtcp_parser;
815   RtcpParserTransport transport(&rtcp_parser);
816   config.outgoing_transport = &transport;
817   RtcpTransceiverImpl rtcp_transceiver(config);
818 
819   rtcp_transceiver.SendNack(kRemoteSsrc, kMissingSequenceNumbers);
820 
821   EXPECT_EQ(rtcp_parser.nack()->num_packets(), 1);
822   EXPECT_EQ(rtcp_parser.nack()->sender_ssrc(), kSenderSsrc);
823   EXPECT_EQ(rtcp_parser.nack()->media_ssrc(), kRemoteSsrc);
824   EXPECT_EQ(rtcp_parser.nack()->packet_ids(), kMissingSequenceNumbers);
825 }
826 
TEST(RtcpTransceiverImplTest,RequestKeyFrameWithPictureLossIndication)827 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
828   const uint32_t kSenderSsrc = 1234;
829   const uint32_t kRemoteSsrc = 4321;
830   RtcpTransceiverConfig config;
831   config.feedback_ssrc = kSenderSsrc;
832   config.schedule_periodic_compound_packets = false;
833   RtcpPacketParser rtcp_parser;
834   RtcpParserTransport transport(&rtcp_parser);
835   config.outgoing_transport = &transport;
836   RtcpTransceiverImpl rtcp_transceiver(config);
837 
838   rtcp_transceiver.SendPictureLossIndication(kRemoteSsrc);
839 
840   EXPECT_EQ(transport.num_packets(), 1);
841   EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
842   EXPECT_EQ(rtcp_parser.pli()->sender_ssrc(), kSenderSsrc);
843   EXPECT_EQ(rtcp_parser.pli()->media_ssrc(), kRemoteSsrc);
844 }
845 
TEST(RtcpTransceiverImplTest,RequestKeyFrameWithFullIntraRequest)846 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
847   const uint32_t kSenderSsrc = 1234;
848   const uint32_t kRemoteSsrcs[] = {4321, 5321};
849   RtcpTransceiverConfig config;
850   config.feedback_ssrc = kSenderSsrc;
851   config.schedule_periodic_compound_packets = false;
852   RtcpPacketParser rtcp_parser;
853   RtcpParserTransport transport(&rtcp_parser);
854   config.outgoing_transport = &transport;
855   RtcpTransceiverImpl rtcp_transceiver(config);
856 
857   rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
858 
859   EXPECT_EQ(rtcp_parser.fir()->num_packets(), 1);
860   EXPECT_EQ(rtcp_parser.fir()->sender_ssrc(), kSenderSsrc);
861   EXPECT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kRemoteSsrcs[0]);
862   EXPECT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kRemoteSsrcs[1]);
863 }
864 
TEST(RtcpTransceiverImplTest,RequestKeyFrameWithFirIncreaseSeqNoPerSsrc)865 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
866   RtcpTransceiverConfig config;
867   config.schedule_periodic_compound_packets = false;
868   RtcpPacketParser rtcp_parser;
869   RtcpParserTransport transport(&rtcp_parser);
870   config.outgoing_transport = &transport;
871   RtcpTransceiverImpl rtcp_transceiver(config);
872 
873   const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
874   const uint32_t kOneRemoteSsrc[] = {4321};
875 
876   rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
877   ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
878   uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
879   ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
880   uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
881 
882   rtcp_transceiver.SendFullIntraRequest(kOneRemoteSsrc, true);
883   ASSERT_EQ(rtcp_parser.fir()->requests().size(), 1u);
884   ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
885   EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 1);
886 
887   rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
888   ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
889   ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
890   EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0 + 2);
891   ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
892   EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1 + 1);
893 }
894 
TEST(RtcpTransceiverImplTest,SendFirDoesNotIncreaseSeqNoIfOldRequest)895 TEST(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
896   RtcpTransceiverConfig config;
897   config.schedule_periodic_compound_packets = false;
898   RtcpPacketParser rtcp_parser;
899   RtcpParserTransport transport(&rtcp_parser);
900   config.outgoing_transport = &transport;
901   RtcpTransceiverImpl rtcp_transceiver(config);
902 
903   const uint32_t kBothRemoteSsrcs[] = {4321, 5321};
904 
905   rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, true);
906   ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
907   ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
908   uint8_t fir_sequence_number0 = rtcp_parser.fir()->requests()[0].seq_nr;
909   ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
910   uint8_t fir_sequence_number1 = rtcp_parser.fir()->requests()[1].seq_nr;
911 
912   rtcp_transceiver.SendFullIntraRequest(kBothRemoteSsrcs, false);
913   ASSERT_EQ(rtcp_parser.fir()->requests().size(), 2u);
914   ASSERT_EQ(rtcp_parser.fir()->requests()[0].ssrc, kBothRemoteSsrcs[0]);
915   EXPECT_EQ(rtcp_parser.fir()->requests()[0].seq_nr, fir_sequence_number0);
916   ASSERT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kBothRemoteSsrcs[1]);
917   EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1);
918 }
919 
TEST(RtcpTransceiverImplTest,KeyFrameRequestCreatesCompoundPacket)920 TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
921   const uint32_t kRemoteSsrcs[] = {4321};
922   RtcpTransceiverConfig config;
923   // Turn periodic off to ensure sent rtcp packet is explicitly requested.
924   config.schedule_periodic_compound_packets = false;
925   RtcpPacketParser rtcp_parser;
926   RtcpParserTransport transport(&rtcp_parser);
927   config.outgoing_transport = &transport;
928 
929   config.rtcp_mode = webrtc::RtcpMode::kCompound;
930 
931   RtcpTransceiverImpl rtcp_transceiver(config);
932   rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
933 
934   // Test sent packet is compound by expecting presense of receiver report.
935   EXPECT_EQ(transport.num_packets(), 1);
936   EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
937 }
938 
TEST(RtcpTransceiverImplTest,KeyFrameRequestCreatesReducedSizePacket)939 TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
940   const uint32_t kRemoteSsrcs[] = {4321};
941   RtcpTransceiverConfig config;
942   // Turn periodic off to ensure sent rtcp packet is explicitly requested.
943   config.schedule_periodic_compound_packets = false;
944   RtcpPacketParser rtcp_parser;
945   RtcpParserTransport transport(&rtcp_parser);
946   config.outgoing_transport = &transport;
947 
948   config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
949 
950   RtcpTransceiverImpl rtcp_transceiver(config);
951   rtcp_transceiver.SendFullIntraRequest(kRemoteSsrcs, true);
952 
953   // Test sent packet is reduced size by expecting absense of receiver report.
954   EXPECT_EQ(transport.num_packets(), 1);
955   EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
956 }
957 
TEST(RtcpTransceiverImplTest,SendsXrRrtrWhenEnabled)958 TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
959   const uint32_t kSenderSsrc = 4321;
960   rtc::ScopedFakeClock clock;
961   RtcpTransceiverConfig config;
962   config.feedback_ssrc = kSenderSsrc;
963   config.schedule_periodic_compound_packets = false;
964   RtcpPacketParser rtcp_parser;
965   RtcpParserTransport transport(&rtcp_parser);
966   config.outgoing_transport = &transport;
967   config.non_sender_rtt_measurement = true;
968   RtcpTransceiverImpl rtcp_transceiver(config);
969 
970   rtcp_transceiver.SendCompoundPacket();
971   NtpTime ntp_time_now = TimeMicrosToNtp(rtc::TimeMicros());
972 
973   EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
974   EXPECT_EQ(rtcp_parser.xr()->sender_ssrc(), kSenderSsrc);
975   ASSERT_TRUE(rtcp_parser.xr()->rrtr());
976   EXPECT_EQ(rtcp_parser.xr()->rrtr()->ntp(), ntp_time_now);
977 }
978 
TEST(RtcpTransceiverImplTest,SendsNoXrRrtrWhenDisabled)979 TEST(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
980   RtcpTransceiverConfig config;
981   config.schedule_periodic_compound_packets = false;
982   RtcpPacketParser rtcp_parser;
983   RtcpParserTransport transport(&rtcp_parser);
984   config.outgoing_transport = &transport;
985   config.non_sender_rtt_measurement = false;
986   RtcpTransceiverImpl rtcp_transceiver(config);
987 
988   rtcp_transceiver.SendCompoundPacket();
989 
990   EXPECT_EQ(transport.num_packets(), 1);
991   // Extended reports rtcp packet might be included for another reason,
992   // but it shouldn't contain rrtr block.
993   EXPECT_FALSE(rtcp_parser.xr()->rrtr());
994 }
995 
TEST(RtcpTransceiverImplTest,CalculatesRoundTripTimeOnDlrr)996 TEST(RtcpTransceiverImplTest, CalculatesRoundTripTimeOnDlrr) {
997   const uint32_t kSenderSsrc = 4321;
998   MockRtcpRttStats rtt_observer;
999   MockTransport null_transport;
1000   RtcpTransceiverConfig config;
1001   config.feedback_ssrc = kSenderSsrc;
1002   config.schedule_periodic_compound_packets = false;
1003   config.outgoing_transport = &null_transport;
1004   config.non_sender_rtt_measurement = true;
1005   config.rtt_observer = &rtt_observer;
1006   RtcpTransceiverImpl rtcp_transceiver(config);
1007 
1008   int64_t time_us = 12345678;
1009   webrtc::rtcp::ReceiveTimeInfo rti;
1010   rti.ssrc = kSenderSsrc;
1011   rti.last_rr = CompactNtp(TimeMicrosToNtp(time_us));
1012   rti.delay_since_last_rr = SaturatedUsToCompactNtp(10 * 1000);
1013   webrtc::rtcp::ExtendedReports xr;
1014   xr.AddDlrrItem(rti);
1015   auto raw_packet = xr.Build();
1016 
1017   EXPECT_CALL(rtt_observer, OnRttUpdate(100 /* rtt_ms */));
1018   rtcp_transceiver.ReceivePacket(raw_packet, time_us + 110 * 1000);
1019 }
1020 
TEST(RtcpTransceiverImplTest,IgnoresUnknownSsrcInDlrr)1021 TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
1022   const uint32_t kSenderSsrc = 4321;
1023   const uint32_t kUnknownSsrc = 4322;
1024   MockRtcpRttStats rtt_observer;
1025   MockTransport null_transport;
1026   RtcpTransceiverConfig config;
1027   config.feedback_ssrc = kSenderSsrc;
1028   config.schedule_periodic_compound_packets = false;
1029   config.outgoing_transport = &null_transport;
1030   config.non_sender_rtt_measurement = true;
1031   config.rtt_observer = &rtt_observer;
1032   RtcpTransceiverImpl rtcp_transceiver(config);
1033 
1034   int64_t time_us = 12345678;
1035   webrtc::rtcp::ReceiveTimeInfo rti;
1036   rti.ssrc = kUnknownSsrc;
1037   rti.last_rr = CompactNtp(TimeMicrosToNtp(time_us));
1038   webrtc::rtcp::ExtendedReports xr;
1039   xr.AddDlrrItem(rti);
1040   auto raw_packet = xr.Build();
1041 
1042   EXPECT_CALL(rtt_observer, OnRttUpdate(_)).Times(0);
1043   rtcp_transceiver.ReceivePacket(raw_packet, time_us + 100000);
1044 }
1045 
1046 }  // namespace
1047