Use RtcpPacket classes for SenderReport/ReceiveReport in RTCPSender

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 179 matching lines @@
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::ReportBlock rb;
   rb.To(kSourceSsrc + 1);
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
-  rr.WithReportBlock(&rb);
+  rr.WithReportBlock(rb);
   rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size());
 
   std::vector<RTCPReportBlock> received_blocks;
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_TRUE(received_blocks.empty());
 }
 
 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::ReportBlock rb;
   rb.To(kSourceSsrc);
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
-  rr.WithReportBlock(&rb);
+  rr.WithReportBlock(rb);
   rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
 
   std::vector<RTCPReportBlock> received_blocks;
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_EQ(1u, received_blocks.size());
 }
@@ skipping 14 matching lines @@
   rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
   rb1.WithFractionLost(10);
   rb1.WithCumulativeLost(5);
 
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrcs[1]);
   rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
 
   rtcp::ReceiverReport rr1;
   rr1.From(kSenderSsrc);
-  rr1.WithReportBlock(&rb1);
-  rr1.WithReportBlock(&rb2);
+  rr1.WithReportBlock(rb1);
+  rr1.WithReportBlock(rb2);
 
   rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
   EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost);
   EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost);
 
   rtcp::ReportBlock rb3;
   rb3.To(kSourceSsrcs[0]);
   rb3.WithExtHighestSeqNum(kSequenceNumbers[0]);
   rb3.WithFractionLost(kFracLost[0]);
   rb3.WithCumulativeLost(kCumLost[0]);
 
   rtcp::ReportBlock rb4;
   rb4.To(kSourceSsrcs[1]);
   rb4.WithExtHighestSeqNum(kSequenceNumbers[1]);
   rb4.WithFractionLost(kFracLost[1]);
   rb4.WithCumulativeLost(kCumLost[1]);
 
   rtcp::ReceiverReport rr2;
   rr2.From(kSenderSsrc);
-  rr2.WithReportBlock(&rb3);
-  rr2.WithReportBlock(&rb4);
+  rr2.WithReportBlock(rb3);
+  rr2.WithReportBlock(rb4);
 
   rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
   EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost);
   EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.back().fractionLost);
 
   std::vector<RTCPReportBlock> received_blocks;
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_EQ(2u, received_blocks.size());
@@ skipping 18 matching lines @@
   std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
   rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
 
   rtcp::ReportBlock rb1;
   rb1.To(kSourceSsrcs[0]);
   rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
   rb1.WithFractionLost(kFracLost[0]);
   rb1.WithCumulativeLost(kCumLost[0]);
   rtcp::ReceiverReport rr1;
   rr1.From(kSenderSsrc1);
-  rr1.WithReportBlock(&rb1);
+  rr1.WithReportBlock(rb1);
 
   rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
   EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost);
 
   std::vector<RTCPReportBlock> received_blocks;
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_EQ(1u, received_blocks.size());
   EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC);
   EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC);
   EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost);
   EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost);
   EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum);
 
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrcs[0]);
   rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
   rb2.WithFractionLost(kFracLost[1]);
   rb2.WithCumulativeLost(kCumLost[1]);
   rtcp::ReceiverReport rr2;
   rr2.From(kSenderSsrc2);
-  rr2.WithReportBlock(&rb2);
+  rr2.WithReportBlock(rb2);
   rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
   EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.front().fractionLost);
 
   received_blocks.clear();
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   ASSERT_EQ(2u, received_blocks.size());
   EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC);
   EXPECT_EQ(kSenderSsrc2, received_blocks[1].remoteSSRC);
@@ skipping 12 matching lines @@
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   // No report block received.
   EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
 
   rtcp::ReportBlock rb;
   rb.To(kSourceSsrc);
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
-  rr.WithReportBlock(&rb);
+  rr.WithReportBlock(rb);
   rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size());
   EXPECT_EQ(0, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
 
   // Report block not received.
   EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, NULL, NULL, NULL, NULL));
 }
@@ skipping 89 matching lines @@
 
   std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
   rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
 
   rtcp::ReportBlock rb1;
   rb1.To(kSourceSsrcs[0]);
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrcs[1]);
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
-  rr.WithReportBlock(&rb1);
-  rr.WithReportBlock(&rb2);
+  rr.WithReportBlock(rb1);
+  rr.WithReportBlock(rb2);
 
   rtc::scoped_ptr<rtcp::RawPacket> p1(rr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
   std::vector<RTCPReportBlock> received_blocks;
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_EQ(2u, received_blocks.size());
 
   // Verify that BYE removes the report blocks.
   rtcp::Bye bye;
@@ skipping 296 matching lines @@
   // No RR received, shouldn't trigger a timeout.
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
 
   // Add a RR and advance the clock just enough to not trigger a timeout.
   rtcp::ReportBlock rb1;
   rb1.To(kSourceSsrc);
   rb1.WithExtHighestSeqNum(kSequenceNumber);
   rtcp::ReceiverReport rr1;
   rr1.From(kSenderSsrc);
-  rr1.WithReportBlock(&rb1);
+  rr1.WithReportBlock(rb1);
   rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1);
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
 
   // Add a RR with the same extended max as the previous RR to trigger a
   // sequence number timeout, but not a RR timeout.
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   system_clock_.AdvanceTimeMilliseconds(2);
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
 
   // Advance clock enough to trigger an RR timeout too.
   system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
   EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
 
   // We should only get one timeout even though we still haven't received a new
   // RR.
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
 
   // Add a new RR with increase sequence number to reset timers.
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrc);
   rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
   rtcp::ReceiverReport rr2;
   rr2.From(kSenderSsrc);
-  rr2.WithReportBlock(&rb2);
+  rr2.WithReportBlock(rb2);
   rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
 
   // Verify we can get a timeout again once we've received new RR.
   system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
@@ skipping 156 matching lines @@
   // First packet, all numbers should just propagate.
   rtcp::ReportBlock rb1;
   rb1.To(kSourceSsrc);
   rb1.WithExtHighestSeqNum(kSequenceNumber);
   rb1.WithFractionLost(kFractionLoss);
   rb1.WithCumulativeLost(kCumulativeLoss);
   rb1.WithJitter(kJitter);
 
   rtcp::ReceiverReport rr1;
   rr1.From(kSenderSsrc);
-  rr1.WithReportBlock(&rb1);
+  rr1.WithReportBlock(rb1);
   rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 
   rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL);
 
   // Add arbitrary numbers, callback should not be called (retain old values).
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrc);
   rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
   rb2.WithFractionLost(42);
   rb2.WithCumulativeLost(137);
   rb2.WithJitter(4711);
 
   rtcp::ReceiverReport rr2;
   rr2.From(kSenderSsrc);
-  rr2.WithReportBlock(&rb2);
+  rr2.WithReportBlock(rb2);
   rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 }
 
 }  // Anonymous namespace
 
 }  // namespace webrtc