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

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 142 matching lines @@
 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
   const uint8_t bad_packet[] = {0, 0, 0, 0};
   EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet)));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectSrPacket) {
   const uint32_t kSenderSsrc = 0x10203;
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = sr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   // The parser will note the remote SSRC on a SR from other than his
   // expected peer, but will not flag that he's gotten a packet.
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
-  EXPECT_EQ(0U,
-            kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags);
+  EXPECT_EQ(0U, kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) {
   const uint32_t kSenderSsrc = 0x10203;
   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = sr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpSr, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectRrPacket) {
   const uint32_t kSenderSsrc = 0x10203;
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size());
 }
 
 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
   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);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   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);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   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());
 }
 
 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
@@ skipping 15 matching lines @@
 
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrcs[1]);
   rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
 
   rtcp::ReceiverReport rr1;
   rr1.From(kSenderSsrc);
   rr1.WithReportBlock(rb1);
   rr1.WithReportBlock(rb2);
 
-  rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
+  rtc::Buffer p1 = rr1.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   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);
 
-  rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
+  rtc::Buffer p2 = rr2.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   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());
   for (size_t i = 0; i < received_blocks.size(); ++i) {
     EXPECT_EQ(kSenderSsrc, received_blocks[i].remoteSSRC);
     EXPECT_EQ(kSourceSsrcs[i], received_blocks[i].sourceSSRC);
@@ skipping 17 matching lines @@
 
   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);
 
-  rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
+  rtc::Buffer p1 = rr1.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   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);
-  rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
+  rtc::Buffer p2 = rr2.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   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);
   for (size_t i = 0; i < received_blocks.size(); ++i) {
     EXPECT_EQ(kSourceSsrcs[0], received_blocks[i].sourceSSRC);
@@ skipping 12 matching lines @@
 
   // No report block received.
   EXPECT_EQ(
       -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
 
   rtcp::ReportBlock rb;
   rb.To(kSourceSsrc);
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
   rr.WithReportBlock(rb);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   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, nullptr, nullptr, nullptr, nullptr));
 
   // Report block not received.
   EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr,
                                     nullptr));
 }
 
 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
   rtcp::ExtendedJitterReport ij;
-  rtc::scoped_ptr<rtcp::RawPacket> packet(ij.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = ij.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) {
   rtcp::ExtendedJitterReport ij;
   ij.WithJitter(0x11213141);
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(ij.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = ij.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpTransmissionTimeOffset, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(0x11213141U, rtcp_packet_info_.interArrivalJitter);
 }
 
 TEST_F(RtcpReceiverTest, InjectAppWithNoData) {
   rtcp::App app;
   app.WithSubType(30);
   uint32_t name = 'n' << 24;
   name += 'a' << 16;
   name += 'm' << 8;
   name += 'e';
   app.WithName(name);
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(app.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = app.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(30, rtcp_packet_info_.applicationSubType);
   EXPECT_EQ(name, rtcp_packet_info_.applicationName);
   EXPECT_EQ(0, rtcp_packet_info_.applicationLength);
 }
 
 TEST_F(RtcpReceiverTest, InjectAppWithData) {
   rtcp::App app;
   app.WithSubType(30);
   uint32_t name = 'n' << 24;
   name += 'a' << 16;
   name += 'm' << 8;
   name += 'e';
   app.WithName(name);
   const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
   const size_t kDataLength = sizeof(kData) / sizeof(kData[0]);
   app.WithData((const uint8_t*)kData, kDataLength);
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(app.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = app.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(30, rtcp_packet_info_.applicationSubType);
   EXPECT_EQ(name, rtcp_packet_info_.applicationName);
   EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength);
 }
 
 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
   const uint32_t kSenderSsrc = 0x123456;
   rtcp::Sdes sdes;
   sdes.WithCName(kSenderSsrc, "alice@host");
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sdes.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = sdes.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   char cName[RTCP_CNAME_SIZE];
   EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName));
   EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE));
 }
 
 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
   const uint32_t kSenderSsrc = 0x123456;
   rtcp::Sdes sdes;
   sdes.WithCName(kSenderSsrc, "alice@host");
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sdes.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = sdes.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   char cName[RTCP_CNAME_SIZE];
   EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName));
 
   // Verify that BYE removes the CNAME.
   rtcp::Bye bye;
   bye.From(kSenderSsrc);
-  rtc::scoped_ptr<rtcp::RawPacket> p2(bye.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
+  rtc::Buffer p2 = bye.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName));
 }
 
 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
   const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
 
   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);
 
-  rtc::scoped_ptr<rtcp::RawPacket> p1(rr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
+  rtc::Buffer p1 = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   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;
   bye.From(kSenderSsrc);
-  rtc::scoped_ptr<rtcp::RawPacket> p2(bye.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
+  rtc::Buffer p2 = bye.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   received_blocks.clear();
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_TRUE(received_blocks.empty());
 
   // Inject packet.
-  EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
   received_blocks.clear();
   rtcp_receiver_->StatisticsReceived(&received_blocks);
   EXPECT_EQ(2u, received_blocks.size());
 }
 
 TEST_F(RtcpReceiverTest, InjectPliPacket) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Pli pli;
   pli.To(kSourceSsrc);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(pli.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = pli.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpPli, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Pli pli;
   pli.To(kSourceSsrc + 1);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(pli.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = pli.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectFirPacket) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Fir fir;
   fir.WithRequestTo(kSourceSsrc, 13);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(fir.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = fir.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpFir, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Fir fir;
   fir.WithRequestTo(kSourceSsrc + 1, 13);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(fir.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = fir.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectSliPacket) {
   rtcp::Sli sli;
   sli.WithPictureId(40);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sli.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = sli.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpSli, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(40, rtcp_packet_info_.sliPictureId);
 }
 
 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   const uint8_t kLossRate = 123;
   rtcp::VoipMetric voip_metric;
   voip_metric.To(kSourceSsrc);
   RTCPVoIPMetric metric;
   metric.lossRate = kLossRate;
   voip_metric.WithVoipMetric(metric);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithVoipMetric(voip_metric);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr);
   EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate);
   EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::VoipMetric voip_metric;
   voip_metric.To(kSourceSsrc + 1);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithVoipMetric(voip_metric);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
   rtcp::Rrtr rrtr;
   rrtr.WithNtp(NtpTime(0x10203, 0x40506));
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithRrtr(rrtr);
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpXrReceiverReferenceTime,
             rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Dlrr dlrr;
   dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithDlrr(dlrr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Dlrr dlrr;
   dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithDlrr(dlrr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   // The parser should note the DLRR report block item, but not flag the packet
   // since the RTT is not estimated.
   EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Dlrr dlrr;
   dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
   dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890);
   dlrr.WithDlrrItem(kSourceSsrc,     0x12345, 0x67890);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithDlrr(dlrr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   // The parser should note the DLRR report block item, but not flag the packet
   // since the RTT is not estimated.
   EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Rrtr rrtr;
   rtcp::Dlrr dlrr;
   dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
   rtcp::VoipMetric metric;
   metric.To(kSourceSsrc);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithRrtr(rrtr);
   xr.WithDlrr(dlrr);
   xr.WithVoipMetric(metric);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime +
                                       kRtcpXrVoipMetric),
             rtcp_packet_info_.rtcpPacketTypeFlags);
   // The parser should note the DLRR report block item, but not flag the packet
   // since the RTT is not estimated.
   EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
   std::vector<uint32_t> remote_ssrcs;
   remote_ssrcs.push_back(kSourceSsrc);
 
   rtcp::Rrtr rrtr;
   rtcp::Dlrr dlrr;
   dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
   rtcp::VoipMetric metric;
   metric.To(kSourceSsrc);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithRrtr(rrtr);
   xr.WithDlrr(dlrr);
   xr.WithVoipMetric(metric);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
+  rtc::Buffer packet = xr.Build();
   // Modify the DLRR block to have an unsupported block type, from 5 to 6.
-  uint8_t* buffer = const_cast<uint8_t*>(packet->Buffer());
+  uint8_t* buffer = packet.data();
   EXPECT_EQ(5, buffer[20]);
   buffer[20] = 6;
 
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime +
                                       kRtcpXrVoipMetric),
             rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) {
   int64_t rtt_ms;
   EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
 }
 
 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) {
   RtcpReceiveTimeInfo info;
   EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info));
 }
 
 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
   const uint32_t kSenderSsrc = 0x123456;
   const NtpTime kNtp(0x10203, 0x40506);
   const uint32_t kNtpMid =
       RTCPUtility::MidNtp(kNtp.seconds(), kNtp.fractions());
 
   rtcp::Rrtr rrtr;
   rrtr.WithNtp(kNtp);
   rtcp::ExtendedReports xr;
   xr.From(kSenderSsrc);
   xr.WithRrtr(rrtr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(kRtcpXrReceiverReferenceTime,
       rtcp_packet_info_.rtcpPacketTypeFlags);
 
   RtcpReceiveTimeInfo info;
   EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info));
   EXPECT_EQ(kSenderSsrc, info.sourceSSRC);
   EXPECT_EQ(kNtpMid, info.lastRR);
   EXPECT_EQ(0U, info.delaySinceLastRR);
 
   system_clock_.AdvanceTimeMilliseconds(1000);
@@ skipping 17 matching lines @@
   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);
-  rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
+  rtc::Buffer p1 = rr1.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   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()));
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   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);
-  rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
+  rtc::Buffer p2 = rr2.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   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()));
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
   system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
   EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
   // This call is expected to fail because no data has arrived.
   EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);  // Matches "media source" above.
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0));
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   sr.Append(&tmmbr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  rtc::Buffer packet = sr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
 
   EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
   TMMBRSet candidate_set;
   candidate_set.VerifyAndAllocateSet(1);
   EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set));
   EXPECT_LT(0U, candidate_set.Tmmbr(0));
   EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   // This SSRC is not what we are sending.
   tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc + 1, 30000, 0));
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   sr.Append(&tmmbr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
+  rtc::Buffer packet = sr.Build();
 
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);  // Matches "media source" above.
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 0, 0));
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   sr.Append(&tmmbr);
-  rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
+  rtc::Buffer packet = sr.Build();
 
-  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+  EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
   EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);  // Matches "media source" above.
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
 
   // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
   // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
   for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
     rtcp::Tmmbr tmmbr;
     tmmbr.From(ssrc);
     tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0));
 
     rtcp::SenderReport sr;
     sr.From(ssrc);
     sr.Append(&tmmbr);
-    rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
-    EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+    rtc::Buffer packet = sr.Build();
+    EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
     // 5 seconds between each packet.
     system_clock_.AdvanceTimeMilliseconds(5000);
   }
   // It is now starttime + 15.
   EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
   TMMBRSet candidate_set;
   candidate_set.VerifyAndAllocateSet(3);
   EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
   EXPECT_LT(0U, candidate_set.Tmmbr(0));
   // We expect the timeout to be 25 seconds. Advance the clock by 12
@@ skipping 49 matching lines @@
   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);
-  rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
+  rtc::Buffer p1 = rr1.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size()));
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 
   rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr);
 
   // 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);
-  rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
-  EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
+  rtc::Buffer p2 = rr2.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 }
 
 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrc = 0x123456;
 
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::TransportFeedback packet;
   packet.WithMediaSourceSsrc(kSourceSsrc);
   packet.WithPacketSenderSsrc(kSenderSsrc);
   packet.WithBase(1, 1000);
   packet.WithReceivedPacket(1, 1000);
 
-  rtc::scoped_ptr<rtcp::RawPacket> built_packet = packet.Build();
-  ASSERT_TRUE(built_packet.get() != nullptr);
+  rtc::Buffer built_packet = packet.Build();
 
-  EXPECT_EQ(0,
-            InjectRtcpPacket(built_packet->Buffer(), built_packet->Length()));
+  EXPECT_EQ(0, InjectRtcpPacket(built_packet.data(), built_packet.size()));
 
   EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback);
   EXPECT_TRUE(rtcp_packet_info_.transport_feedback_.get() != nullptr);
 }
 
 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrc = 0x123456;
 
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   // Send a compound packet with a TransportFeedback followed by something else.
   rtcp::TransportFeedback packet;
   packet.WithMediaSourceSsrc(kSourceSsrc);
   packet.WithPacketSenderSsrc(kSenderSsrc);
   packet.WithBase(1, 1000);
   packet.WithReceivedPacket(1, 1000);
 
   static uint32_t kBitrateBps = 50000;
   rtcp::Remb remb;
   remb.From(kSourceSsrc);
   remb.WithBitrateBps(kBitrateBps);
   packet.Append(&remb);
 
-  rtc::scoped_ptr<rtcp::RawPacket> built_packet = packet.Build();
-  ASSERT_TRUE(built_packet.get() != nullptr);
+  rtc::Buffer built_packet = packet.Build();
 
   // Modify the TransportFeedback packet so that it is invalid.
   const size_t kStatusCountOffset = 14;
   ByteWriter<uint16_t>::WriteBigEndian(
-      &built_packet->MutableBuffer()[kStatusCountOffset], 42);
+      &built_packet.data()[kStatusCountOffset], 42);
 
-  EXPECT_EQ(0,
-            InjectRtcpPacket(built_packet->Buffer(), built_packet->Length()));
+  EXPECT_EQ(0, InjectRtcpPacket(built_packet.data(), built_packet.size()));
 
   // Transport feedback should be ignored, but next packet should work.
   EXPECT_EQ(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback);
   EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpRemb);
   EXPECT_EQ(kBitrateBps, rtcp_packet_info_.receiverEstimatedMaxBitrate);
 }
 
 }  // Anonymous namespace
 
 }  // namespace webrtc