Allow max 1 block per type in RTCP Extended Reports

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 34 matching lines @@
 using ::testing::AllOf;
 using ::testing::ElementsAreArray;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::NiceMock;
 using ::testing::Property;
 using ::testing::SizeIs;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 using ::testing::UnorderedElementsAre;
+using rtcp::ReceiveTimeInfo;
 
 class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver {
  public:
   MOCK_METHOD2(RtcpPacketTypesCounterUpdated,
                void(uint32_t, const RtcpPacketTypeCounter&));
 };
 
 class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
  public:
   MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t));
@@ skipping 625 matching lines @@
 // VOiP reports are ignored.
 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
   const uint8_t kLossRate = 123;
   rtcp::VoipMetric voip_metric;
   voip_metric.SetMediaSsrc(kReceiverMainSsrc);
   RTCPVoIPMetric metric;
   metric.lossRate = kLossRate;
   voip_metric.SetVoipMetric(metric);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddVoipMetric(voip_metric);
+  xr.SetVoipMetric(voip_metric);
 
   InjectRtcpPacket(xr);
 }
 
 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
   rtcp::VoipMetric voip_metric;
   voip_metric.SetMediaSsrc(kNotToUsSsrc);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddVoipMetric(voip_metric);
+  xr.SetVoipMetric(voip_metric);
 
   InjectRtcpPacket(xr);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
   const NtpTime kNtp(0x10203, 0x40506);
   rtcp::Rrtr rrtr;
   rrtr.SetNtp(kNtp);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddRrtr(rrtr);
+  xr.SetRrtr(rrtr);
 
-  rtcp::ReceiveTimeInfo rrtime;
+  ReceiveTimeInfo rrtime;
   EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
 
   InjectRtcpPacket(xr);
 
   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
   EXPECT_EQ(rrtime.ssrc, kSenderSsrc);
   EXPECT_EQ(rrtime.last_rr, CompactNtp(kNtp));
   EXPECT_EQ(0U, rrtime.delay_since_last_rr);
 
   system_clock_.AdvanceTimeMilliseconds(1500);
   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
   EXPECT_NEAR(1500, CompactNtpRttToMs(rrtime.delay_since_last_rr), 1);
 }
 
 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
   // Allow calculate rtt using dlrr/rrtr, simulating media receiver side.
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kNotToUsSsrc, 0x12345, 0x67890);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddDlrr(dlrr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kNotToUsSsrc, 0x12345, 0x67890));
 
   InjectRtcpPacket(xr);
 
   int64_t rtt_ms = 0;
   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
   const uint32_t kLastRR = 0x12345;
   const uint32_t kDelay = 0x23456;
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
   int64_t rtt_ms = 0;
   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
 
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddDlrr(dlrr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
 
   InjectRtcpPacket(xr);
 
   uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_));
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
   uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
   EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
   const uint32_t kLastRR = 0x12345;
   const uint32_t kDelay = 0x56789;
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay);
-  dlrr.AddDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890);
-  dlrr.AddDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890);
-  xr.AddDlrr(dlrr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay));
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 1, 0x12345, 0x67890));
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 2, 0x12345, 0x67890));
 
   InjectRtcpPacket(xr);
 
   uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_));
   int64_t rtt_ms = 0;
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
   uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
   EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   rtcp::Rrtr rrtr;
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890);
   rtcp::VoipMetric metric;
   metric.SetMediaSsrc(kReceiverMainSsrc);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddRrtr(rrtr);
-  xr.AddDlrr(dlrr);
-  xr.AddVoipMetric(metric);
+  xr.SetRrtr(rrtr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
+  xr.SetVoipMetric(metric);
 
   InjectRtcpPacket(xr);
 
-  rtcp::ReceiveTimeInfo rrtime;
+  ReceiveTimeInfo rrtime;
   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
   int64_t rtt_ms = 0;
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   rtcp::Rrtr rrtr;
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890);
   rtcp::VoipMetric metric;
   metric.SetMediaSsrc(kReceiverMainSsrc);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddRrtr(rrtr);
-  xr.AddDlrr(dlrr);
-  xr.AddVoipMetric(metric);
+  xr.SetRrtr(rrtr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890));
+  xr.SetVoipMetric(metric);
 
   rtc::Buffer packet = xr.Build();
   // Modify the DLRR block to have an unsupported block type, from 5 to 6.
   ASSERT_EQ(5, packet.data()[20]);
   packet.data()[20] = 6;
   InjectRtcpPacket(packet);
 
   // Validate Rrtr was received and processed.
-  rtcp::ReceiveTimeInfo rrtime;
+  ReceiveTimeInfo rrtime;
   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
   // Validate Dlrr report wasn't processed.
   int64_t rtt_ms = 0;
   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
 }
 
 TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   int64_t rtt_ms;
   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
 }
 
 TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
   Random rand(0x0123456789abcdef);
   const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000);
   const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
   NtpTime now(system_clock_);
   uint32_t sent_ntp = CompactNtp(now);
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddDlrr(dlrr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
 
   InjectRtcpPacket(xr);
 
   int64_t rtt_ms = 0;
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
   EXPECT_NEAR(kRttMs, rtt_ms, 1);
 }
 
 TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
   Random rand(0x0123456789abcdef);
   const int64_t kRttMs = rand.Rand(-3600 * 1000, -1);
   const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
   NtpTime now(system_clock_);
   uint32_t sent_ntp = CompactNtp(now);
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
-  rtcp::Dlrr dlrr;
-  dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddDlrr(dlrr);
+  xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp));
 
   InjectRtcpPacket(xr);
 
   int64_t rtt_ms = 0;
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
   EXPECT_EQ(1, rtt_ms);
 }
 
 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) {
-  rtcp::ReceiveTimeInfo info;
+  ReceiveTimeInfo info;
   EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
 }
 
 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
   const NtpTime kNtp(0x10203, 0x40506);
   const uint32_t kNtpMid = CompactNtp(kNtp);
 
   rtcp::Rrtr rrtr;
   rrtr.SetNtp(kNtp);
   rtcp::ExtendedReports xr;
   xr.SetSenderSsrc(kSenderSsrc);
-  xr.AddRrtr(rrtr);
+  xr.SetRrtr(rrtr);
 
   InjectRtcpPacket(xr);
 
-  rtcp::ReceiveTimeInfo info;
+  ReceiveTimeInfo info;
   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
   EXPECT_EQ(kSenderSsrc, info.ssrc);
   EXPECT_EQ(kNtpMid, info.last_rr);
   EXPECT_EQ(0U, info.delay_since_last_rr);
 
   system_clock_.AdvanceTimeMilliseconds(1000);
   EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info));
   EXPECT_EQ(65536U, info.delay_since_last_rr);
 }
 
@@ skipping 334 matching lines @@
 TEST_F(RtcpReceiverTest, ForceSenderReport) {
   rtcp::RapidResyncRequest rr;
   rr.SetSenderSsrc(kSenderSsrc);
   rr.SetMediaSsrc(kReceiverMainSsrc);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport());
   InjectRtcpPacket(rr);
 }
 
 }  // namespace webrtc