[rtp_rtcp] rtc::scoped_ptr<rtcp::RawPacket> replaced with rtc::Buffer

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/random.h"
 
 using testing::ElementsAre;
 using testing::ElementsAreArray;
 using testing::IsEmpty;
 using testing::make_tuple;
 using webrtc::rtcp::Dlrr;
 using webrtc::rtcp::ExtendedReports;
-using webrtc::rtcp::RawPacket;
 using webrtc::rtcp::ReceiveTimeInfo;
 using webrtc::rtcp::Rrtr;
 using webrtc::rtcp::VoipMetric;
 using webrtc::RTCPUtility::RtcpCommonHeader;
 using webrtc::RTCPUtility::RtcpParseCommonHeader;
 
 namespace webrtc {
 // Define comparision operators that shouldn't be needed in production,
 // but make testing matches more clear.
 bool operator==(const RTCPVoIPMetric& metric1, const RTCPVoIPMetric& metric2) {
@@ skipping 47 matching lines @@
 
   bool Parse(const uint8_t* buffer,
                     size_t length,
                     ExtendedReports* packet) {
     RtcpCommonHeader header;
     EXPECT_TRUE(RtcpParseCommonHeader(buffer, length, &header));
     EXPECT_EQ(length, header.BlockSize());
     return packet->Parse(header, buffer + RtcpCommonHeader::kHeaderSizeBytes);
   }
 
-  bool Parse(const RawPacket& buffer, ExtendedReports* packet) {
-    return Parse(buffer.Buffer(), buffer.Length(), packet);
+  bool Parse(const rtc::Buffer& buffer, ExtendedReports* packet) {
+    return Parse(buffer.data(), buffer.size(), packet);
   }
 }  // namespace
 
 class RtcpPacketExtendedReportsTest : public ::testing::Test {
  public:
   RtcpPacketExtendedReportsTest() : random_(0x123456789) {}
 
  protected:
   template <typename T>
   T Rand() {
@@ skipping 57 matching lines @@
   VoipMetric voip_metric;
   voip_metric.To(Rand<uint32_t>());
   voip_metric.WithVoipMetric(Rand<RTCPVoIPMetric>());
   return voip_metric;
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateWithoutReportBlocks) {
   ExtendedReports xr;
   xr.From(kSenderSsrc);
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
-  EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
+  EXPECT_THAT(make_tuple(packet.data(), packet.size()),
               ElementsAreArray(kEmptyPacket));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, ParseWithoutReportBlocks) {
   ExtendedReports parsed;
   EXPECT_TRUE(Parse(kEmptyPacket, sizeof(kEmptyPacket), &parsed));
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.rrtrs(), IsEmpty());
   EXPECT_THAT(parsed.dlrrs(), IsEmpty());
   EXPECT_THAT(parsed.voip_metrics(), IsEmpty());
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithOneRrtrBlock) {
   Rrtr rrtr = Rand<Rrtr>();
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithRrtr(rrtr));
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.rrtrs(), ElementsAre(rrtr));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) {
   Rrtr rrtr1 = Rand<Rrtr>();
   Rrtr rrtr2 = Rand<Rrtr>();
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithRrtr(rrtr1));
   EXPECT_TRUE(xr.WithRrtr(rrtr2));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.rrtrs(), ElementsAre(rrtr1, rrtr2));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) {
   Dlrr dlrr;
   EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithDlrr(dlrr));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.dlrrs(), ElementsAre(dlrr));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) {
   Dlrr dlrr;
   EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
   EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithDlrr(dlrr));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.dlrrs(), ElementsAre(dlrr));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoDlrrBlocks) {
   Dlrr dlrr1;
   EXPECT_TRUE(dlrr1.WithDlrrItem(Rand<ReceiveTimeInfo>()));
   Dlrr dlrr2;
   EXPECT_TRUE(dlrr2.WithDlrrItem(Rand<ReceiveTimeInfo>()));
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithDlrr(dlrr1));
   EXPECT_TRUE(xr.WithDlrr(dlrr2));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.dlrrs(), ElementsAre(dlrr1, dlrr2));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) {
   VoipMetric voip_metric = Rand<VoipMetric>();
 
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithVoipMetric(voip_metric));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.voip_metrics(), ElementsAre(voip_metric));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithMultipleReportBlocks) {
   Rrtr rrtr = Rand<Rrtr>();
   Dlrr dlrr;
   EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
   VoipMetric metric = Rand<VoipMetric>();
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithRrtr(rrtr));
   EXPECT_TRUE(xr.WithDlrr(dlrr));
   EXPECT_TRUE(xr.WithVoipMetric(metric));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
   EXPECT_THAT(parsed.rrtrs(), ElementsAre(rrtr));
   EXPECT_THAT(parsed.dlrrs(), ElementsAre(dlrr));
   EXPECT_THAT(parsed.voip_metrics(), ElementsAre(metric));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, DlrrWithoutItemNotIncludedInPacket) {
   Rrtr rrtr = Rand<Rrtr>();
   Dlrr dlrr;
   VoipMetric metric = Rand<VoipMetric>();
   ExtendedReports xr;
   xr.From(kSenderSsrc);
   EXPECT_TRUE(xr.WithRrtr(rrtr));
   EXPECT_TRUE(xr.WithDlrr(dlrr));
   EXPECT_TRUE(xr.WithVoipMetric(metric));
 
-  rtc::scoped_ptr<RawPacket> packet = xr.Build();
+  rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
-  EXPECT_TRUE(Parse(*packet, &mparsed));
+  EXPECT_TRUE(Parse(packet, &mparsed));
   const ExtendedReports& parsed = mparsed;
 
   EXPECT_THAT(parsed.rrtrs(), ElementsAre(rrtr));
   EXPECT_THAT(parsed.dlrrs(), IsEmpty());
   EXPECT_THAT(parsed.voip_metrics(), ElementsAre(metric));
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, WithTooManyBlocks) {
   const size_t kMaxBlocks = 50;
   ExtendedReports xr;
 
   Rrtr rrtr = Rand<Rrtr>();
   for (size_t i = 0; i < kMaxBlocks; ++i)
     EXPECT_TRUE(xr.WithRrtr(rrtr));
   EXPECT_FALSE(xr.WithRrtr(rrtr));
 
   Dlrr dlrr;
   for (size_t i = 0; i < kMaxBlocks; ++i)
     EXPECT_TRUE(xr.WithDlrr(dlrr));
   EXPECT_FALSE(xr.WithDlrr(dlrr));
 
   VoipMetric voip_metric = Rand<VoipMetric>();
   for (size_t i = 0; i < kMaxBlocks; ++i)
     EXPECT_TRUE(xr.WithVoipMetric(voip_metric));
   EXPECT_FALSE(xr.WithVoipMetric(voip_metric));
 }
 }  // namespace webrtc