admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
rtcp::RawPacket is rtc::Buffer, it had no extra functionality.
rtc::Buffer is a movable class - no point to wrap it into rtc::scoped_ptr
change is large, but straightforward:
  rtc::scoped_ptr<rtcp::RawPacket> replaced with rtc::Buffer
  ->Buffer() replaced with .data()
  ->Length() replaced with .size()

BUG=webrtc:5260

Review URL: https://codereview.webrtc.org/1696203002

Cr-Commit-Position: refs/heads/master@{#11649}
This commit is contained in:
danilchap 2016-02-17 03:11:42 -08:00 committed by Commit bot
parent 67680c1bf9
commit 69e59e619a
24 changed files with 298 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
webrtc/call/rtc_event_log_unittest.cc
View File

@ -350,7 +350,7 @@ size_t GenerateRtpPacket(uint32_t extensions_bitvector,
return header_size;
}
rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket(Random* prng) {
rtc::Buffer GenerateRtcpPacket(Random* prng) {
rtcp::ReportBlock report_block;
report_block.To(prng->Rand<uint32_t>()); // Remote SSRC.
report_block.WithFractionLost(prng->Rand(50));
@ -427,7 +427,7 @@ void LogSessionAndReadBack(size_t rtp_count,
ASSERT_LE(playout_count, rtp_count);
ASSERT_LE(bwe_loss_count, rtp_count);
std::vector<rtc::Buffer> rtp_packets;
std::vector<rtc::scoped_ptr<rtcp::RawPacket> > rtcp_packets;
std::vector<rtc::Buffer> rtcp_packets;
std::vector<size_t> rtp_header_sizes;
std::vector<uint32_t> playout_ssrcs;
std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates;
@ -488,8 +488,8 @@ void LogSessionAndReadBack(size_t rtp_count,
log_dumper->LogRtcpPacket(
(rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
rtcp_packets[rtcp_index - 1]->Buffer(),
rtcp_packets[rtcp_index - 1]->Length());
rtcp_packets[rtcp_index - 1].data(),
rtcp_packets[rtcp_index - 1].size());
rtcp_index++;
}
if (i * playout_count >= playout_index * rtp_count) {
@ -536,8 +536,8 @@ void LogSessionAndReadBack(size_t rtp_count,
VerifyRtcpEvent(parsed_stream.stream(event_index),
rtcp_index % 2 == 0, // Every second packet is incoming.
rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
rtcp_packets[rtcp_index - 1]->Buffer(),
rtcp_packets[rtcp_index - 1]->Length());
rtcp_packets[rtcp_index - 1].data(),
rtcp_packets[rtcp_index - 1].size());
event_index++;
rtcp_index++;
}
@ -604,8 +604,8 @@ void DropOldEvents(uint32_t extensions_bitvector,
unsigned int random_seed) {
rtc::Buffer old_rtp_packet;
rtc::Buffer recent_rtp_packet;
rtc::scoped_ptr<rtcp::RawPacket> old_rtcp_packet;
rtc::scoped_ptr<rtcp::RawPacket> recent_rtcp_packet;
rtc::Buffer old_rtcp_packet;
rtc::Buffer recent_rtcp_packet;
VideoReceiveStream::Config receiver_config(nullptr);
VideoSendStream::Config sender_config(nullptr);
@ -647,8 +647,8 @@ void DropOldEvents(uint32_t extensions_bitvector,
log_dumper->LogRtpHeader(kOutgoingPacket, MediaType::AUDIO,
old_rtp_packet.data(), old_rtp_packet.size());
log_dumper->LogRtcpPacket(kIncomingPacket, MediaType::AUDIO,
old_rtcp_packet->Buffer(),
old_rtcp_packet->Length());
old_rtcp_packet.data(),
old_rtcp_packet.size());
// Sleep 55 ms to let old events be removed from the queue.
rtc::Thread::SleepMs(55);
log_dumper->StartLogging(temp_filename, 10000000);
@ -656,8 +656,8 @@ void DropOldEvents(uint32_t extensions_bitvector,
recent_rtp_packet.data(),
recent_rtp_packet.size());
log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO,
recent_rtcp_packet->Buffer(),
recent_rtcp_packet->Length());
recent_rtcp_packet.data(),
recent_rtcp_packet.size());
}
// Read the generated file from disk.
@ -675,7 +675,7 @@ void DropOldEvents(uint32_t extensions_bitvector,
recent_rtp_packet.data(), recent_header_size,
recent_rtp_packet.size());
VerifyRtcpEvent(parsed_stream.stream(4), false, MediaType::VIDEO,
recent_rtcp_packet->Buffer(), recent_rtcp_packet->Length());
recent_rtcp_packet.data(), recent_rtcp_packet.size());
// Clean up temporary file - can be pretty slow.
remove(temp_filename.c_str());

16
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc
View File

@ -211,9 +211,9 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
EXPECT_TRUE(feedback->WithReceivedPacket(
packets[i].sequence_number, packets[i].arrival_time_ms * 1000));
rtc::scoped_ptr<rtcp::RawPacket> raw_packet = feedback->Build();
feedback = rtcp::TransportFeedback::ParseFrom(raw_packet->Buffer(),
raw_packet->Length());
rtc::Buffer raw_packet = feedback->Build();
feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
raw_packet.size());
std::vector<PacketInfo> expected_packets;
expected_packets.push_back(packets[i]);
@ -280,9 +280,9 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number,
info.arrival_time_ms * 1000));
rtc::scoped_ptr<rtcp::RawPacket> raw_packet = feedback->Build();
feedback = rtcp::TransportFeedback::ParseFrom(raw_packet->Buffer(),
raw_packet->Length());
rtc::Buffer raw_packet = feedback->Build();
feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
raw_packet.size());
std::vector<PacketInfo> received_feedback;
@ -302,8 +302,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number,
info.arrival_time_ms * 1000));
raw_packet = feedback->Build();
feedback = rtcp::TransportFeedback::ParseFrom(raw_packet->Buffer(),
raw_packet->Length());
feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
raw_packet.size());
EXPECT_TRUE(feedback.get() != nullptr);
EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))

49
webrtc/modules/rtp_rtcp/source/rtcp_packet.cc
View File

@ -31,28 +31,27 @@ void RtcpPacket::Append(RtcpPacket* packet) {
appended_packets_.push_back(packet);
}
rtc::scoped_ptr<RawPacket> RtcpPacket::Build() const {
rtc::Buffer RtcpPacket::Build() const {
size_t length = 0;
rtc::scoped_ptr<RawPacket> packet(new RawPacket(IP_PACKET_SIZE));
rtc::Buffer packet(IP_PACKET_SIZE);
class PacketVerifier : public PacketReadyCallback {
public:
explicit PacketVerifier(RawPacket* packet)
explicit PacketVerifier(rtc::Buffer* packet)
: called_(false), packet_(packet) {}
virtual ~PacketVerifier() {}
void OnPacketReady(uint8_t* data, size_t length) override {
RTC_CHECK(!called_) << "Fragmentation not supported.";
called_ = true;
packet_->SetLength(length);
packet_->SetSize(length);
}
private:
bool called_;
RawPacket* const packet_;
} verifier(packet.get());
CreateAndAddAppended(packet->MutableBuffer(), &length, packet->BufferLength(),
&verifier);
OnBufferFull(packet->MutableBuffer(), &length, &verifier);
rtc::Buffer* const packet_;
} verifier(&packet);
CreateAndAddAppended(packet.data(), &length, packet.capacity(), &verifier);
OnBufferFull(packet.data(), &length, &verifier);
return packet;
}
@ -122,37 +121,5 @@ void RtcpPacket::CreateHeader(
AssignUWord16(buffer, pos, length);
}
RawPacket::RawPacket(size_t buffer_length)
: buffer_length_(buffer_length), length_(0) {
buffer_.reset(new uint8_t[buffer_length]);
}
RawPacket::RawPacket(const uint8_t* packet, size_t packet_length)
: buffer_length_(packet_length), length_(packet_length) {
buffer_.reset(new uint8_t[packet_length]);
memcpy(buffer_.get(), packet, packet_length);
}
const uint8_t* RawPacket::Buffer() const {
return buffer_.get();
}
uint8_t* RawPacket::MutableBuffer() {
return buffer_.get();
}
size_t RawPacket::BufferLength() const {
return buffer_length_;
}
size_t RawPacket::Length() const {
return length_;
}
void RawPacket::SetLength(size_t length) {
assert(length <= buffer_length_);
length_ = length;
}
} // namespace rtcp
} // namespace webrtc

45
webrtc/modules/rtp_rtcp/source/rtcp_packet.h
View File

@ -14,7 +14,7 @@
#include <vector>
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/buffer.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/typedefs.h"
@ -23,18 +23,16 @@ namespace rtcp {
static const int kCommonFbFmtLength = 12;
class RawPacket;
// Class for building RTCP packets.
//
// Example:
// ReportBlock report_block;
// report_block.To(234)
// report_block.FractionLost(10);
// report_block.To(234);
// report_block.WithFractionLost(10);
//
// ReceiverReport rr;
// rr.From(123);
// rr.WithReportBlock(&report_block)
// rr.WithReportBlock(report_block);
//
// Fir fir;
// fir.From(123);
@ -44,11 +42,11 @@ class RawPacket;
// uint8_t packet[kPacketSize]; // with sequence number 56.
// fir.Build(packet, &length, kPacketSize);
//
// RawPacket packet = fir.Build(); // Returns a RawPacket holding
// rtc::Buffer packet = fir.Build(); // Returns a RawPacket holding
// // the built rtcp packet.
//
// rr.Append(&fir) // Builds a compound RTCP packet with
// RawPacket packet = rr.Build(); // a receiver report, report block
// rr.Append(&fir); // Builds a compound RTCP packet with
// rtc::Buffer packet = rr.Build(); // a receiver report, report block
// // and fir message.
class RtcpPacket {
@ -71,7 +69,7 @@ class RtcpPacket {
// Convenience method mostly used for test. Max length of IP_PACKET_SIZE is
// used, will cause assertion error if fragmentation occurs.
rtc::scoped_ptr<RawPacket> Build() const;
rtc::Buffer Build() const;
// Returns true if all calls to Create succeeded. A buffer of size
// IP_PACKET_SIZE will be allocated and reused between calls to callback.
@ -115,33 +113,6 @@ class RtcpPacket {
size_t max_length,
PacketReadyCallback* callback) const;
};
// Class holding a RTCP packet.
//
// Takes a built rtcp packet.
// RawPacket raw_packet(buffer, length);
//
// To access the raw packet:
// raw_packet.Buffer(); - pointer to the raw packet
// raw_packet.BufferLength(); - the length of the raw packet
class RawPacket {
public:
explicit RawPacket(size_t buffer_length);
RawPacket(const uint8_t* packet, size_t packet_length);
const uint8_t* Buffer() const;
uint8_t* MutableBuffer();
size_t BufferLength() const;
size_t Length() const;
void SetLength(size_t length);
private:
const size_t buffer_length_;
size_t length_;
rtc::scoped_ptr<uint8_t[]> buffer_;
};
} // namespace rtcp
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_H_

10
webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
using webrtc::rtcp::App;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -32,16 +31,15 @@ class RtcpPacketAppTest : public ::testing::Test {
void BuildPacket() { packet = app.Build(); }
void ParsePacket() {
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header));
// Check there is exactly one RTCP packet in the buffer.
EXPECT_EQ(header.BlockSize(), packet->Length());
EXPECT_EQ(header.BlockSize(), packet.size());
EXPECT_TRUE(parsed_.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
App app;
rtc::scoped_ptr<RawPacket> packet;
rtc::Buffer packet;
const App& parsed() { return parsed_; }
private:

22
webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc
View File

@ -17,7 +17,6 @@
using ::testing::ElementsAre;
using webrtc::rtcp::Bye;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -33,16 +32,15 @@ class RtcpPacketByeTest : public ::testing::Test {
void BuildPacket() { packet = bye.Build(); }
void ParsePacket() {
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header));
// Check that there is exactly one RTCP packet in the buffer.
EXPECT_EQ(header.BlockSize(), packet->Length());
EXPECT_EQ(header.BlockSize(), packet.size());
EXPECT_TRUE(parsed_bye.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
Bye bye;
rtc::scoped_ptr<RawPacket> packet;
rtc::Buffer packet;
Bye parsed_bye;
};
@ -64,7 +62,7 @@ TEST_F(RtcpPacketByeTest, WithCsrcs) {
EXPECT_TRUE(bye.reason().empty());
BuildPacket();
EXPECT_EQ(16u, packet->Length()); // Header: 4, 3xSRCs: 12, Reason: 0.
EXPECT_EQ(16u, packet.size()); // Header: 4, 3xSRCs: 12, Reason: 0.
ParsePacket();
@ -82,7 +80,7 @@ TEST_F(RtcpPacketByeTest, WithCsrcsAndReason) {
bye.WithReason(kReason);
BuildPacket();
EXPECT_EQ(28u, packet->Length()); // Header: 4, 3xSRCs: 12, Reason: 12.
EXPECT_EQ(28u, packet.size()); // Header: 4, 3xSRCs: 12, Reason: 12.
ParsePacket();
@ -148,11 +146,11 @@ TEST_F(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) {
BuildPacket();
RtcpCommonHeader header;
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header);
RtcpParseCommonHeader(packet.data(), packet.size(), &header);
header.count_or_format = 2; // Lie there are 2 ssrcs, not one.
EXPECT_FALSE(parsed_bye.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
TEST_F(RtcpPacketByeTest, ParseFailOnInvalidReasonLength) {
@ -162,11 +160,11 @@ TEST_F(RtcpPacketByeTest, ParseFailOnInvalidReasonLength) {
BuildPacket();
RtcpCommonHeader header;
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header);
RtcpParseCommonHeader(packet.data(), packet.size(), &header);
header.payload_size_bytes -= 4; // Payload is usually 32bit aligned.
EXPECT_FALSE(parsed_bye.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
} // namespace

13
webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc
View File

@ -21,7 +21,6 @@
using webrtc::rtcp::Bye;
using webrtc::rtcp::CompoundPacket;
using webrtc::rtcp::Fir;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::ReceiverReport;
using webrtc::rtcp::ReportBlock;
using webrtc::rtcp::SenderReport;
@ -42,9 +41,9 @@ TEST(RtcpCompoundPacketTest, AppendPacket) {
EXPECT_TRUE(rr.WithReportBlock(rb));
rr.Append(&fir);
rtc::scoped_ptr<RawPacket> packet(rr.Build());
rtc::Buffer packet = rr.Build();
RtcpPacketParser parser;
parser.Parse(packet->Buffer(), packet->Length());
parser.Parse(packet.data(), packet.size());
EXPECT_EQ(1, parser.receiver_report()->num_packets());
EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
EXPECT_EQ(1, parser.report_block()->num_packets());
@ -57,9 +56,9 @@ TEST(RtcpCompoundPacketTest, AppendPacketOnEmpty) {
rr.From(kSenderSsrc);
empty.Append(&rr);
rtc::scoped_ptr<RawPacket> packet(empty.Build());
rtc::Buffer packet = empty.Build();
RtcpPacketParser parser;
parser.Parse(packet->Buffer(), packet->Length());
parser.Parse(packet.data(), packet.size());
EXPECT_EQ(1, parser.receiver_report()->num_packets());
EXPECT_EQ(0, parser.report_block()->num_packets());
}
@ -78,9 +77,9 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) {
sr.Append(&bye);
sr.Append(&rr);
rtc::scoped_ptr<RawPacket> packet(sr.Build());
rtc::Buffer packet = sr.Build();
RtcpPacketParser parser;
parser.Parse(packet->Buffer(), packet->Length());
parser.Parse(packet.data(), packet.size());
EXPECT_EQ(1, parser.sender_report()->num_packets());
EXPECT_EQ(1, parser.receiver_report()->num_packets());
EXPECT_EQ(1, parser.report_block()->num_packets());

14
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc
View File

@ -15,7 +15,6 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::ExtendedJitterReport;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -28,15 +27,14 @@ class RtcpPacketExtendedJitterReportTest : public ::testing::Test {
void BuildPacket() { packet = ij.Build(); }
void ParsePacket() {
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
EXPECT_EQ(header.BlockSize(), packet->Length());
EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header));
EXPECT_EQ(header.BlockSize(), packet.size());
EXPECT_TRUE(parsed_.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
ExtendedJitterReport ij;
rtc::scoped_ptr<RawPacket> packet;
rtc::Buffer packet;
const ExtendedJitterReport& parsed() { return parsed_; }
private:
@ -85,13 +83,13 @@ TEST_F(RtcpPacketExtendedJitterReportTest, ParseFailWithTooManyItems) {
ij.WithJitter(0x11121418);
BuildPacket();
RtcpCommonHeader header;
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header);
RtcpParseCommonHeader(packet.data(), packet.size(), &header);
header.count_or_format++; // Damage package.
ExtendedJitterReport parsed;
EXPECT_FALSE(parsed.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
} // namespace

41
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc
View File

@ -20,7 +20,6 @@ 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;
@ -88,8 +87,8 @@ namespace {
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
@ -167,9 +166,9 @@ 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));
}
@ -187,10 +186,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithOneRrtrBlock) {
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());
@ -205,10 +204,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) {
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());
@ -222,10 +221,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) {
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());
@ -240,10 +239,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) {
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());
@ -260,10 +259,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoDlrrBlocks) {
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());
@ -277,10 +276,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) {
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());
@ -298,10 +297,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithMultipleReportBlocks) {
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());
@ -320,10 +319,10 @@ TEST_F(RtcpPacketExtendedReportsTest, DlrrWithoutItemNotIncludedInPacket) {
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));

22
webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc
View File

@ -20,7 +20,6 @@ using testing::Eq;
using testing::Field;
using testing::make_tuple;
using webrtc::rtcp::Fir;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -60,9 +59,9 @@ TEST(RtcpPacketFirTest, Create) {
fir.From(kSenderSsrc);
fir.WithRequestTo(kRemoteSsrc, kSeqNr);
rtc::scoped_ptr<RawPacket> packet = fir.Build();
rtc::Buffer packet = fir.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}
@ -72,9 +71,9 @@ TEST(RtcpPacketFirTest, TwoFciEntries) {
fir.WithRequestTo(kRemoteSsrc, kSeqNr);
fir.WithRequestTo(kRemoteSsrc + 1, kSeqNr + 1);
rtc::scoped_ptr<RawPacket> packet = fir.Build();
rtc::Buffer packet = fir.Build();
Fir parsed;
EXPECT_TRUE(ParseFir(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseFir(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_THAT(parsed.requests(),
@ -89,16 +88,16 @@ TEST(RtcpPacketFirTest, ParseFailsOnZeroFciEntries) {
fir.From(kSenderSsrc);
fir.WithRequestTo(kRemoteSsrc, kSeqNr);
rtc::scoped_ptr<RawPacket> packet = fir.Build();
rtc::Buffer packet = fir.Build();
RtcpCommonHeader header;
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header);
RtcpParseCommonHeader(packet.data(), packet.size(), &header);
ASSERT_EQ(16u, header.payload_size_bytes); // Common: 8, 1xfci: 8.
header.payload_size_bytes = 8; // Common: 8, 0xfcis.
Fir parsed;
EXPECT_FALSE(parsed.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
TEST(RtcpPacketFirTest, ParseFailsOnFractionalFciEntries) {
@ -107,14 +106,13 @@ TEST(RtcpPacketFirTest, ParseFailsOnFractionalFciEntries) {
fir.WithRequestTo(kRemoteSsrc, kSeqNr);
fir.WithRequestTo(kRemoteSsrc + 1, kSeqNr + 1);
rtc::scoped_ptr<RawPacket> packet = fir.Build();
rtc::Buffer packet = fir.Build();
RtcpCommonHeader header;
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header);
RtcpParseCommonHeader(packet.data(), packet.size(), &header);
ASSERT_EQ(24u, header.payload_size_bytes); // Common: 8, 2xfcis: 16.
const uint8_t* payload =
packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes;
const uint8_t* payload = packet.data() + RtcpCommonHeader::kHeaderSizeBytes;
Fir good;
EXPECT_TRUE(good.Parse(header, payload));
for (size_t i = 1; i < 8; ++i) {

20
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc
View File

@ -19,7 +19,6 @@ using ::testing::Invoke;
using ::testing::UnorderedElementsAreArray;
using webrtc::rtcp::Nack;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -50,10 +49,10 @@ TEST(RtcpPacketNackTest, Create) {
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
rtc::scoped_ptr<RawPacket> packet = nack.Build();
rtc::Buffer packet = nack.Build();
EXPECT_EQ(kPacketLength, packet->Length());
EXPECT_EQ(0, memcmp(kPacket, packet->Buffer(), kPacketLength));
EXPECT_EQ(kPacketLength, packet.size());
EXPECT_EQ(0, memcmp(kPacket, packet.data(), kPacketLength));
}
TEST(RtcpPacketNackTest, Parse) {
@ -77,10 +76,10 @@ TEST(RtcpPacketNackTest, CreateWrap) {
nack.To(kRemoteSsrc);
nack.WithList(kWrapList, kWrapListLength);
rtc::scoped_ptr<RawPacket> packet = nack.Build();
rtc::Buffer packet = nack.Build();
EXPECT_EQ(kWrapPacketLength, packet->Length());
EXPECT_EQ(0, memcmp(kWrapPacket, packet->Buffer(), kWrapPacketLength));
EXPECT_EQ(kWrapPacketLength, packet.size());
EXPECT_EQ(0, memcmp(kWrapPacket, packet.data(), kWrapPacketLength));
}
TEST(RtcpPacketNackTest, ParseWrap) {
@ -107,14 +106,13 @@ TEST(RtcpPacketNackTest, BadOrder) {
nack.To(kRemoteSsrc);
nack.WithList(kUnorderedList, kUnorderedListLength);
rtc::scoped_ptr<RawPacket> packet = nack.Build();
rtc::Buffer packet = nack.Build();
Nack parsed;
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header));
EXPECT_TRUE(parsed.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc());

7
webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc
View File

@ -14,7 +14,6 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
using webrtc::rtcp::Pli;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -46,10 +45,10 @@ TEST(RtcpPacketPliTest, Create) {
pli.From(kSenderSsrc);
pli.To(kRemoteSsrc);
rtc::scoped_ptr<RawPacket> packet(pli.Build());
rtc::Buffer packet = pli.Build();
ASSERT_EQ(kPacketLength, packet->Length());
EXPECT_EQ(0, memcmp(kPacket, packet->Buffer(), kPacketLength));
ASSERT_EQ(kPacketLength, packet.size());
EXPECT_EQ(0, memcmp(kPacket, packet.data(), kPacketLength));
}
TEST(RtcpPacketPliTest, ParseFailsOnTooSmallPacket) {

5
webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc
View File

@ -16,7 +16,6 @@
using testing::ElementsAreArray;
using testing::make_tuple;
using webrtc::rtcp::RapidResyncRequest;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -48,9 +47,9 @@ TEST(RtcpPacketRapidResyncRequestTest, Create) {
rrr.From(kSenderSsrc);
rrr.To(kRemoteSsrc);
rtc::scoped_ptr<RawPacket> packet = rrr.Build();
rtc::Buffer packet = rrr.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}

14
webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc
View File

@ -12,7 +12,6 @@
#include "testing/gtest/include/gtest/gtest.h"
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::ReceiverReport;
using webrtc::rtcp::ReportBlock;
using webrtc::RTCPUtility::RtcpCommonHeader;
@ -42,15 +41,14 @@ class RtcpPacketReceiverReportTest : public ::testing::Test {
void BuildPacket() { packet = rr.Build(); }
void ParsePacket() {
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
EXPECT_EQ(header.BlockSize(), packet->Length());
EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header));
EXPECT_EQ(header.BlockSize(), packet.size());
EXPECT_TRUE(parsed_.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
ReceiverReport rr;
rtc::scoped_ptr<RawPacket> packet;
rtc::Buffer packet;
const ReceiverReport& parsed() { return parsed_; }
private:
@ -96,8 +94,8 @@ TEST_F(RtcpPacketReceiverReportTest, Create) {
BuildPacket();
ASSERT_EQ(kPacketLength, packet->Length());
EXPECT_EQ(0, memcmp(kPacket, packet->Buffer(), kPacketLength));
ASSERT_EQ(kPacketLength, packet.size());
EXPECT_EQ(0, memcmp(kPacket, packet.data(), kPacketLength));
}
TEST_F(RtcpPacketReceiverReportTest, WithoutReportBlocks) {

9
webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc
View File

@ -16,7 +16,6 @@
using testing::ElementsAreArray;
using testing::IsEmpty;
using testing::make_tuple;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::Remb;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -48,9 +47,9 @@ TEST(RtcpPacketRembTest, Create) {
remb.AppliesTo(kRemoteSsrcs[2]);
remb.WithBitrateBps(kBitrateBps);
rtc::scoped_ptr<RawPacket> packet(remb.Build());
rtc::Buffer packet = remb.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}
@ -68,10 +67,10 @@ TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) {
Remb remb;
remb.From(kSenderSsrc);
remb.WithBitrateBps(kBitrateBps);
rtc::scoped_ptr<RawPacket> packet(remb.Build());
rtc::Buffer packet = remb.Build();
Remb parsed;
EXPECT_TRUE(ParseRemb(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseRemb(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(kBitrateBps, parsed.bitrate_bps());
EXPECT_THAT(parsed.ssrcs(), IsEmpty());

65
webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc
View File

@ -16,7 +16,6 @@
using testing::ElementsAreArray;
using testing::make_tuple;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::Rpsi;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -66,9 +65,9 @@ TEST(RtcpPacketRpsiTest, Create) {
rpsi.WithPayloadType(kPayloadType);
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
rtc::Buffer packet = rpsi.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}
@ -77,10 +76,10 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) {
rpsi.From(kSenderSsrc);
rpsi.To(kRemoteSsrc);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
packet->MutableBuffer()[3]--; // Reduce size field by one word (4 bytes).
rtc::Buffer packet = rpsi.Build();
packet.data()[3]--; // Reduce size field by one word (4 bytes).
EXPECT_FALSE(ParseRpsi(packet->Buffer(), packet->Length() - 4));
EXPECT_FALSE(ParseRpsi(packet.data(), packet.size() - 4));
}
TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) {
@ -88,14 +87,14 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) {
rpsi.From(kSenderSsrc);
rpsi.To(kRemoteSsrc);
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
uint8_t* padding_bits = packet->MutableBuffer() + 12;
rtc::Buffer packet = rpsi.Build();
uint8_t* padding_bits = packet.data() + 12;
uint8_t saved_padding_bits = *padding_bits;
ASSERT_TRUE(ParseRpsi(packet->Buffer(), packet->Length()));
ASSERT_TRUE(ParseRpsi(packet.data(), packet.size()));
for (uint8_t i = 1; i < 8; ++i) {
*padding_bits = saved_padding_bits + i;
EXPECT_FALSE(ParseRpsi(packet->Buffer(), packet->Length()));
EXPECT_FALSE(ParseRpsi(packet.data(), packet.size()));
}
}
@ -104,19 +103,19 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnTooBigPadding) {
rpsi.From(kSenderSsrc);
rpsi.To(kRemoteSsrc);
rpsi.WithPictureId(1); // Small picture id that occupy just 1 byte.
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
uint8_t* padding_bits = packet->MutableBuffer() + 12;
ASSERT_TRUE(ParseRpsi(packet->Buffer(), packet->Length()));
rtc::Buffer packet = rpsi.Build();
uint8_t* padding_bits = packet.data() + 12;
ASSERT_TRUE(ParseRpsi(packet.data(), packet.size()));
*padding_bits += 8;
EXPECT_FALSE(ParseRpsi(packet->Buffer(), packet->Length()));
EXPECT_FALSE(ParseRpsi(packet.data(), packet.size()));
}
// For raw rpsi packet extract how many bytes are used to store picture_id.
size_t UsedBytes(const RawPacket& packet) { // Works for small packets only.
RTC_CHECK_EQ(packet.Buffer()[2], 0); // Assume packet is small.
size_t total_rpsi_payload_bytes = 4 * (packet.Buffer()[3] - 2) - 2;
uint8_t padding_bits = packet.Buffer()[12];
size_t UsedBytes(const rtc::Buffer& packet) { // Works for small packets only.
RTC_CHECK_EQ(packet.data()[2], 0); // Assume packet is small.
size_t total_rpsi_payload_bytes = 4 * (packet.data()[3] - 2) - 2;
uint8_t padding_bits = packet.data()[12];
RTC_CHECK_EQ(padding_bits % 8, 0);
return total_rpsi_payload_bytes - (padding_bits / 8);
}
@ -128,11 +127,11 @@ TEST(RtcpPacketRpsiTest, WithOneByteNativeString) {
const uint16_t kNumberOfValidBytes = 1;
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(*packet));
rtc::Buffer packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
Rpsi parsed;
EXPECT_TRUE(ParseRpsi(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseRpsi(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kPictureId, parsed.picture_id());
}
@ -143,11 +142,11 @@ TEST(RtcpPacketRpsiTest, WithTwoByteNativeString) {
const uint16_t kNumberOfValidBytes = 2;
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(*packet));
rtc::Buffer packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
Rpsi parsed;
EXPECT_TRUE(ParseRpsi(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseRpsi(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kPictureId, parsed.picture_id());
}
@ -158,11 +157,11 @@ TEST(RtcpPacketRpsiTest, WithThreeByteNativeString) {
const uint16_t kNumberOfValidBytes = 3;
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(*packet));
rtc::Buffer packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
Rpsi parsed;
EXPECT_TRUE(ParseRpsi(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseRpsi(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kPictureId, parsed.picture_id());
}
@ -173,11 +172,11 @@ TEST(RtcpPacketRpsiTest, WithFourByteNativeString) {
const uint16_t kNumberOfValidBytes = 4;
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(*packet));
rtc::Buffer packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
Rpsi parsed;
EXPECT_TRUE(ParseRpsi(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseRpsi(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kPictureId, parsed.picture_id());
}
@ -189,11 +188,11 @@ TEST(RtcpPacketRpsiTest, WithMaxPictureId) {
const uint16_t kNumberOfValidBytes = 10;
rpsi.WithPictureId(kPictureId);
rtc::scoped_ptr<RawPacket> packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(*packet));
rtc::Buffer packet = rpsi.Build();
EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
Rpsi parsed;
EXPECT_TRUE(ParseRpsi(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseRpsi(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kPictureId, parsed.picture_id());
}
} // namespace webrtc

25
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc
View File

@ -12,7 +12,6 @@
#include "testing/gtest/include/gtest/gtest.h"
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::Sdes;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -38,9 +37,9 @@ bool Parse(const uint8_t* buffer, size_t length, Sdes* sdes) {
TEST(RtcpPacketSdesTest, WithoutChunks) {
Sdes sdes;
rtc::scoped_ptr<RawPacket> packet = sdes.Build();
rtc::Buffer packet = sdes.Build();
Sdes parsed;
EXPECT_TRUE(Parse(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(Parse(packet.data(), packet.size(), &parsed));
EXPECT_EQ(0u, parsed.chunks().size());
}
@ -51,9 +50,9 @@ TEST(RtcpPacketSdesTest, WithOneChunk) {
Sdes sdes;
EXPECT_TRUE(sdes.WithCName(kSenderSsrc, kCname));
rtc::scoped_ptr<RawPacket> packet = sdes.Build();
rtc::Buffer packet = sdes.Build();
Sdes sdes_parsed;
Parse(packet->Buffer(), packet->Length(), &sdes_parsed);
Parse(packet.data(), packet.size(), &sdes_parsed);
const Sdes& parsed = sdes_parsed; // Ensure accessors are const.
EXPECT_EQ(1u, parsed.chunks().size());
@ -70,9 +69,9 @@ TEST(RtcpPacketSdesTest, WithMultipleChunks) {
EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 4, "abcde"));
EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 5, "abcdef"));
rtc::scoped_ptr<RawPacket> packet = sdes.Build();
rtc::Buffer packet = sdes.Build();
Sdes parsed;
Parse(packet->Buffer(), packet->Length(), &parsed);
Parse(packet.data(), packet.size(), &parsed);
EXPECT_EQ(6u, parsed.chunks().size());
EXPECT_EQ(kSenderSsrc + 5, parsed.chunks()[5].ssrc);
@ -95,9 +94,9 @@ TEST(RtcpPacketSdesTest, CnameItemWithEmptyString) {
Sdes sdes;
EXPECT_TRUE(sdes.WithCName(kSenderSsrc, ""));
rtc::scoped_ptr<RawPacket> packet = sdes.Build();
rtc::Buffer packet = sdes.Build();
Sdes parsed;
Parse(packet->Buffer(), packet->Length(), &parsed);
Parse(packet.data(), packet.size(), &parsed);
EXPECT_EQ(1u, parsed.chunks().size());
EXPECT_EQ(kSenderSsrc, parsed.chunks()[0].ssrc);
@ -236,17 +235,17 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
const std::string kBob = "bob@host";
source.WithCName(kSenderSsrc, kAlice);
rtc::scoped_ptr<RawPacket> packet1 = source.Build();
rtc::Buffer packet1 = source.Build();
Sdes middle;
Parse(packet1->Buffer(), packet1->Length(), &middle);
Parse(packet1.data(), packet1.size(), &middle);
EXPECT_EQ(source.BlockLength(), middle.BlockLength());
middle.WithCName(kSenderSsrc + 1, kBob);
rtc::scoped_ptr<RawPacket> packet2 = middle.Build();
rtc::Buffer packet2 = middle.Build();
Sdes destination;
Parse(packet2->Buffer(), packet2->Length(), &destination);
Parse(packet2.data(), packet2.size(), &destination);
EXPECT_EQ(middle.BlockLength(), destination.BlockLength());

22
webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc
View File

@ -12,7 +12,6 @@
#include "testing/gtest/include/gtest/gtest.h"
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::ReportBlock;
using webrtc::rtcp::SenderReport;
using webrtc::RTCPUtility::RtcpCommonHeader;
@ -25,13 +24,12 @@ class RtcpPacketSenderReportTest : public ::testing::Test {
const uint32_t kSenderSsrc = 0x12345678;
const uint32_t kRemoteSsrc = 0x23456789;
void ParsePacket(const RawPacket& packet) {
void ParsePacket(const rtc::Buffer& packet) {
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet.Buffer(), packet.Length(), &header));
EXPECT_EQ(packet.Length(), header.BlockSize());
EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header));
EXPECT_EQ(packet.size(), header.BlockSize());
EXPECT_TRUE(parsed_.Parse(
header, packet.Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes));
}
// Only ParsePacket can change parsed, tests should use it in readonly mode.
@ -54,8 +52,8 @@ TEST_F(RtcpPacketSenderReportTest, WithoutReportBlocks) {
sr.WithPacketCount(kPacketCount);
sr.WithOctetCount(kOctetCount);
rtc::scoped_ptr<RawPacket> packet = sr.Build();
ParsePacket(*packet);
rtc::Buffer packet = sr.Build();
ParsePacket(packet);
EXPECT_EQ(kSenderSsrc, parsed().sender_ssrc());
EXPECT_EQ(kNtp, parsed().ntp());
@ -73,8 +71,8 @@ TEST_F(RtcpPacketSenderReportTest, WithOneReportBlock) {
sr.From(kSenderSsrc);
EXPECT_TRUE(sr.WithReportBlock(rb));
rtc::scoped_ptr<RawPacket> packet = sr.Build();
ParsePacket(*packet);
rtc::Buffer packet = sr.Build();
ParsePacket(packet);
EXPECT_EQ(kSenderSsrc, parsed().sender_ssrc());
EXPECT_EQ(1u, parsed().report_blocks().size());
@ -92,8 +90,8 @@ TEST_F(RtcpPacketSenderReportTest, WithTwoReportBlocks) {
EXPECT_TRUE(sr.WithReportBlock(rb1));
EXPECT_TRUE(sr.WithReportBlock(rb2));
rtc::scoped_ptr<RawPacket> packet = sr.Build();
ParsePacket(*packet);
rtc::Buffer packet = sr.Build();
ParsePacket(packet);
EXPECT_EQ(kSenderSsrc, parsed().sender_ssrc());
EXPECT_EQ(2u, parsed().report_blocks().size());

11
webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc
View File

@ -15,7 +15,6 @@
using testing::ElementsAreArray;
using testing::make_tuple;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::Sli;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
@ -56,9 +55,9 @@ TEST(RtcpPacketSliTest, Create) {
sli.To(kRemoteSsrc);
sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb);
rtc::scoped_ptr<RawPacket> packet(sli.Build());
rtc::Buffer packet = sli.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}
@ -81,10 +80,10 @@ TEST(RtcpPacketSliTest, ParseFailsOnTooSmallPacket) {
sli.To(kRemoteSsrc);
sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb);
rtc::scoped_ptr<RawPacket> packet(sli.Build());
packet->MutableBuffer()[3]--; // Decrease size by 1 word (4 bytes).
rtc::Buffer packet = sli.Build();
packet.data()[3]--; // Decrease size by 1 word (4 bytes).
EXPECT_FALSE(ParseSli(packet->Buffer(), packet->Length() - 4, &sli));
EXPECT_FALSE(ParseSli(packet.data(), packet.size() - 4, &sli));
}
} // namespace

13
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
View File

@ -16,7 +16,6 @@
using testing::ElementsAreArray;
using testing::IsEmpty;
using testing::make_tuple;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::TmmbItem;
using webrtc::rtcp::Tmmbn;
using webrtc::RTCPUtility::RtcpCommonHeader;
@ -47,9 +46,9 @@ TEST(RtcpPacketTmmbnTest, Create) {
tmmbn.From(kSenderSsrc);
tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
rtc::scoped_ptr<RawPacket> packet = tmmbn.Build();
rtc::Buffer packet = tmmbn.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}
@ -70,9 +69,9 @@ TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) {
Tmmbn tmmbn;
tmmbn.From(kSenderSsrc);
rtc::scoped_ptr<RawPacket> packet = tmmbn.Build();
rtc::Buffer packet = tmmbn.Build();
Tmmbn parsed;
EXPECT_TRUE(ParseTmmbn(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseTmmbn(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_THAT(parsed.items(), IsEmpty());
@ -84,9 +83,9 @@ TEST(RtcpPacketTmmbnTest, CreateAndParseWithTwoItems) {
tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40));
rtc::scoped_ptr<RawPacket> packet = tmmbn.Build();
rtc::Buffer packet = tmmbn.Build();
Tmmbn parsed;
EXPECT_TRUE(ParseTmmbn(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseTmmbn(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(2u, parsed.items().size());

9
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc
View File

@ -16,7 +16,6 @@
using testing::ElementsAreArray;
using testing::IsEmpty;
using testing::make_tuple;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::TmmbItem;
using webrtc::rtcp::Tmmbr;
using webrtc::RTCPUtility::RtcpCommonHeader;
@ -47,9 +46,9 @@ TEST(RtcpPacketTmmbrTest, Create) {
tmmbr.From(kSenderSsrc);
tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
rtc::scoped_ptr<RawPacket> packet = tmmbr.Build();
rtc::Buffer packet = tmmbr.Build();
EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
EXPECT_THAT(make_tuple(packet.data(), packet.size()),
ElementsAreArray(kPacket));
}
@ -71,10 +70,10 @@ TEST(RtcpPacketTmmbrTest, CreateAndParseWithTwoEntries) {
tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, kOverhead + 1));
rtc::scoped_ptr<RawPacket> packet = tmmbr.Build();
rtc::Buffer packet = tmmbr.Build();
Tmmbr parsed;
EXPECT_TRUE(ParseTmmbr(packet->Buffer(), packet->Length(), &parsed));
EXPECT_TRUE(ParseTmmbr(packet.data(), packet.size(), &parsed));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(2u, parsed.requests().size());

33
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc
View File

@ -73,8 +73,8 @@ class FeedbackTester {
void VerifyPacket() {
serialized_ = feedback_->Build();
VerifyInternal();
feedback_ = TransportFeedback::ParseFrom(serialized_->Buffer(),
serialized_->Length());
feedback_ = TransportFeedback::ParseFrom(serialized_.data(),
serialized_.size());
ASSERT_NE(nullptr, feedback_.get());
VerifyInternal();
}
@ -87,7 +87,7 @@ class FeedbackTester {
// Round up to whole 32-bit words.
size_t expected_size_words = (expected_size_ + 3) / 4;
size_t expected_size_bytes = expected_size_words * 4;
EXPECT_EQ(expected_size_bytes, serialized_->Length());
EXPECT_EQ(expected_size_bytes, serialized_.size());
}
std::vector<TransportFeedback::StatusSymbol> symbols =
@ -137,7 +137,7 @@ class FeedbackTester {
size_t expected_size_;
int64_t default_delta_;
rtc::scoped_ptr<TransportFeedback> feedback_;
rtc::scoped_ptr<rtcp::RawPacket> serialized_;
rtc::Buffer serialized_;
};
TEST(RtcpPacketTest, TransportFeedback_OneBitVector) {
@ -397,9 +397,8 @@ TEST(RtcpPacketTest, TransportFeedback_Limits) {
packet->WithBase(0, kMaxBaseTime);
packet->WithReceivedPacket(0, kMaxBaseTime);
// Serialize and de-serialize (verify 24bit parsing).
rtc::scoped_ptr<rtcp::RawPacket> raw_packet = packet->Build();
packet =
TransportFeedback::ParseFrom(raw_packet->Buffer(), raw_packet->Length());
rtc::Buffer raw_packet = packet->Build();
packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
EXPECT_EQ(kMaxBaseTime, packet->GetBaseTimeUs());
// Base time above maximum value.
@ -409,8 +408,7 @@ TEST(RtcpPacketTest, TransportFeedback_Limits) {
packet->WithBase(0, kTooLargeBaseTime);
packet->WithReceivedPacket(0, kTooLargeBaseTime);
raw_packet = packet->Build();
packet =
TransportFeedback::ParseFrom(raw_packet->Buffer(), raw_packet->Length());
packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs());
// TODO(sprang): Once we support max length lower than RTCP length limit,
@ -426,11 +424,11 @@ TEST(RtcpPacketTest, TransportFeedback_Padding) {
feedback.WithBase(0, 0);
EXPECT_TRUE(feedback.WithReceivedPacket(0, 0));
rtc::scoped_ptr<rtcp::RawPacket> packet(feedback.Build());
EXPECT_EQ(kExpectedSizeWords * 4, packet->Length());
rtc::Buffer packet = feedback.Build();
EXPECT_EQ(kExpectedSizeWords * 4, packet.size());
ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes);
for (size_t i = kExpectedSizeBytes; i < kExpectedSizeWords * 4; ++i)
EXPECT_EQ(0u, packet->Buffer()[i]);
EXPECT_EQ(0u, packet.data()[i]);
// Modify packet by adding 4 bytes of padding at the end. Not currently used
// when we're sending, but need to be able to handle it when receiving.
@ -439,7 +437,7 @@ TEST(RtcpPacketTest, TransportFeedback_Padding) {
const size_t kExpectedSizeWithPadding =
(kExpectedSizeWords * 4) + kPaddingBytes;
uint8_t mod_buffer[kExpectedSizeWithPadding];
memcpy(mod_buffer, packet->Buffer(), kExpectedSizeWords * 4);
memcpy(mod_buffer, packet.data(), kExpectedSizeWords * 4);
memset(&mod_buffer[kExpectedSizeWords * 4], 0, kPaddingBytes - 1);
mod_buffer[kExpectedSizeWithPadding - 1] = kPaddingBytes;
const uint8_t padding_flag = 1 << 5;
@ -451,7 +449,7 @@ TEST(RtcpPacketTest, TransportFeedback_Padding) {
rtc::scoped_ptr<TransportFeedback> parsed_packet(
TransportFeedback::ParseFrom(mod_buffer, kExpectedSizeWithPadding));
ASSERT_TRUE(parsed_packet.get() != nullptr);
EXPECT_EQ(kExpectedSizeWords * 4, packet->Length()); // Padding not included.
EXPECT_EQ(kExpectedSizeWords * 4, packet.size()); // Padding not included.
}
TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) {
@ -469,11 +467,10 @@ TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) {
feedback.WithReceivedPacket(i, i * 1000);
feedback.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
rtc::scoped_ptr<rtcp::RawPacket> serialized_packet = feedback.Build();
EXPECT_TRUE(serialized_packet.get() != nullptr);
rtc::Buffer serialized_packet = feedback.Build();
rtc::scoped_ptr<TransportFeedback> deserialized_packet =
TransportFeedback::ParseFrom(serialized_packet->Buffer(),
serialized_packet->Length());
TransportFeedback::ParseFrom(serialized_packet.data(),
serialized_packet.size());
EXPECT_TRUE(deserialized_packet.get() != nullptr);
}
}

193
webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -160,13 +160,12 @@ 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) {
@ -174,8 +173,8 @@ TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) {
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);
}
@ -184,8 +183,8 @@ 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());
@ -203,8 +202,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
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());
@ -226,8 +225,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
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());
@ -263,8 +262,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
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);
@ -286,8 +285,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
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);
@ -325,8 +324,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
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);
@ -347,8 +346,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
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);
@ -381,8 +380,8 @@ TEST_F(RtcpReceiverTest, GetRtt) {
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());
@ -396,8 +395,8 @@ TEST_F(RtcpReceiverTest, GetRtt) {
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);
}
@ -405,8 +404,8 @@ 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);
}
@ -420,8 +419,8 @@ TEST_F(RtcpReceiverTest, InjectAppWithNoData) {
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);
@ -440,8 +439,8 @@ TEST_F(RtcpReceiverTest, InjectAppWithData) {
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);
@ -453,8 +452,8 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
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));
@ -465,16 +464,16 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
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));
}
@ -495,8 +494,8 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
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);
@ -505,14 +504,14 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
// 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);
@ -527,8 +526,8 @@ TEST_F(RtcpReceiverTest, InjectPliPacket) {
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);
}
@ -540,8 +539,8 @@ TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
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);
}
@ -553,8 +552,8 @@ TEST_F(RtcpReceiverTest, InjectFirPacket) {
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);
}
@ -566,16 +565,16 @@ TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
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);
}
@ -583,8 +582,8 @@ TEST_F(RtcpReceiverTest, InjectSliPacket) {
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);
}
@ -603,8 +602,8 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
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);
@ -621,8 +620,8 @@ TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
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);
}
@ -633,8 +632,8 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
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);
}
@ -650,8 +649,8 @@ TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
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);
}
@ -667,8 +666,8 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
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);
@ -687,8 +686,8 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
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);
@ -710,8 +709,8 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
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);
@ -738,13 +737,13 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
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);
@ -772,8 +771,8 @@ TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
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);
@ -811,15 +810,15 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
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));
@ -840,14 +839,14 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
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));
@ -874,8 +873,8 @@ TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
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;
@ -897,12 +896,12 @@ TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
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));
}
@ -920,9 +919,9 @@ TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
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));
}
@ -943,8 +942,8 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
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);
}
@ -1014,8 +1013,8 @@ TEST_F(RtcpReceiverTest, Callbacks) {
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));
@ -1032,8 +1031,8 @@ TEST_F(RtcpReceiverTest, Callbacks) {
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));
}
@ -1052,11 +1051,9 @@ TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
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);
@ -1083,16 +1080,14 @@ TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
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);

6
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -223,9 +223,9 @@ class RtpRtcpImplTest : public ::testing::Test {
nack.From(sender ? kReceiverSsrc : kSenderSsrc);
nack.To(sender ? kSenderSsrc : kReceiverSsrc);
nack.WithList(list, kListLength);
rtc::scoped_ptr<rtcp::RawPacket> packet(nack.Build());
EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet->Buffer(),
packet->Length()));
rtc::Buffer packet = nack.Build();
EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet.data(),
packet.size()));
}
};