webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc - Issue 2099243003: Use std::unique_ptr in ForwardErrorCorrection.

Unified Diff: webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

Issue 2099243003: Use std::unique_ptr in ForwardErrorCorrection. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@flexfec-pt1a_mini-fixes-in-ULPFEC

Patch Set: Rebase on top of FlexFEC pt. 1a. Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

diff --git a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

index 2f3ae6f2077bafdfc811dd22f239732159cb0e40..9970a25ad462191a890ab7604df8134da3142026 100644

--- a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

+++ b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

@@ -53,24 +53,25 @@ void ReceivePackets(

}

random_variable = random->Rand<float>();

}

- ForwardErrorCorrection::ReceivedPacket* received_packet = *it;

- to_decode_list->push_back(received_packet);

+ to_decode_list->push_back(std::move(*it));

+ received_packet_list->erase(it);

+ ForwardErrorCorrection::ReceivedPacket* received_packet =

+ to_decode_list->back().get();

// Duplicate packets.

random_variable = random->Rand<float>();

while (random_variable < duplicate_rate) {

- ForwardErrorCorrection::ReceivedPacket* duplicate_packet =

- new ForwardErrorCorrection::ReceivedPacket;

+ std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> duplicate_packet(

+ new ForwardErrorCorrection::ReceivedPacket);

stefan-webrtc 2016/06/29 19:36:18 ()

brandtr 2016/06/30 14:05:55 Done.

*duplicate_packet = *received_packet;

duplicate_packet->pkt = new ForwardErrorCorrection::Packet;

memcpy(duplicate_packet->pkt->data, received_packet->pkt->data,

received_packet->pkt->length);

duplicate_packet->pkt->length = received_packet->pkt->length;

- to_decode_list->push_back(duplicate_packet);

+ to_decode_list->push_back(std::move(duplicate_packet));

random_variable = random->Rand<float>();

}

- received_packet_list->erase(it);

}

@@ -105,13 +106,12 @@ TEST(FecTest, MAYBE_FecTest) {

ForwardErrorCorrection fec;

ForwardErrorCorrection::PacketList media_packet_list;

- ForwardErrorCorrection::PacketList fec_packet_list;

+ std::list<ForwardErrorCorrection::Packet*> fec_packet_list;

ForwardErrorCorrection::ReceivedPacketList to_decode_list;

ForwardErrorCorrection::ReceivedPacketList received_packet_list;

ForwardErrorCorrection::RecoveredPacketList recovered_packet_list;

std::list<uint8_t*> fec_mask_list;

- ForwardErrorCorrection::Packet* media_packet = nullptr;

// Running over only one loss rate to limit execution time.

const float loss_rate[] = {0.5f};

const uint32_t loss_rate_size = sizeof(loss_rate) / sizeof(*loss_rate);

@@ -230,8 +230,8 @@ TEST(FecTest, MAYBE_FecTest) {

// around is detected. This case is currently not handled below.

seq_num = 0;

for (uint32_t i = 0; i < num_media_packets; ++i) {

- media_packet = new ForwardErrorCorrection::Packet;

- media_packet_list.push_back(media_packet);

+ std::unique_ptr<ForwardErrorCorrection::Packet> media_packet(

+ new ForwardErrorCorrection::Packet);

const uint32_t kMinPacketSize = 12;

const uint32_t kMaxPacketSize = static_cast<uint32_t>(

IP_PACKET_SIZE - 12 - 28 -

@@ -269,9 +269,10 @@ TEST(FecTest, MAYBE_FecTest) {

for (size_t j = 12; j < media_packet->length; ++j) {

media_packet->data[j] = random.Rand<uint8_t>();

}

+ media_packet_list.push_back(std::move(media_packet));

seq_num++;

}

- media_packet->data[1] |= 0x80;

+ media_packet_list.back()->data[1] |= 0x80;

ASSERT_EQ(0, fec.GenerateFEC(media_packet_list, protection_factor,

num_imp_packets, kUseUnequalProtection,

@@ -284,23 +285,22 @@ TEST(FecTest, MAYBE_FecTest) {

memset(media_loss_mask, 0, sizeof(media_loss_mask));

uint32_t media_packet_idx = 0;

- for (auto* media_packet : media_packet_list) {

+ for (auto& media_packet : media_packet_list) {

// We want a value between 0 and 1.

const float loss_random_variable = random.Rand<float>();

if (loss_random_variable >= loss_rate[loss_rate_idx]) {

media_loss_mask[media_packet_idx] = 1;

- auto received_packet =

- new ForwardErrorCorrection::ReceivedPacket;

+ std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>

+ received_packet(new ForwardErrorCorrection::ReceivedPacket);

received_packet->pkt = new ForwardErrorCorrection::Packet;

- received_packet_list.push_back(received_packet);

received_packet->pkt->length = media_packet->length;

memcpy(received_packet->pkt->data, media_packet->data,

media_packet->length);

received_packet->seq_num =

ByteReader<uint16_t>::ReadBigEndian(&media_packet->data[2]);

received_packet->is_fec = false;

+ received_packet_list.push_back(std::move(received_packet));

}

media_packet_idx++;

}

@@ -311,19 +311,16 @@ TEST(FecTest, MAYBE_FecTest) {

const float loss_random_variable = random.Rand<float>();

if (loss_random_variable >= loss_rate[loss_rate_idx]) {

fec_loss_mask[fec_packet_idx] = 1;

- auto received_packet =

- new ForwardErrorCorrection::ReceivedPacket;

+ std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>

+ received_packet(new ForwardErrorCorrection::ReceivedPacket);

received_packet->pkt = new ForwardErrorCorrection::Packet;

- received_packet_list.push_back(received_packet);

received_packet->pkt->length = fec_packet->length;

memcpy(received_packet->pkt->data, fec_packet->data,

fec_packet->length);

received_packet->seq_num = seq_num;

received_packet->is_fec = true;

received_packet->ssrc = ssrc;

+ received_packet_list.push_back(std::move(received_packet));

fec_mask_list.push_back(fec_packet_masks[fec_packet_idx]);

}

@@ -384,7 +381,7 @@ TEST(FecTest, MAYBE_FecTest) {

duplicate_rate, &random);

if (fec_packet_received == false) {

- for (auto* received_packet : to_decode_list) {

+ for (auto& received_packet : to_decode_list) {

if (received_packet->is_fec) {

fec_packet_received = true;

}

@@ -397,7 +394,7 @@ TEST(FecTest, MAYBE_FecTest) {

<< "Received packet list is not empty.";

}

media_packet_idx = 0;

- for (auto* media_packet : media_packet_list) {

+ for (auto& media_packet : media_packet_list) {

if (media_loss_mask[media_packet_idx] == 1) {

// Should have recovered this packet.

auto recovered_packet_list_it = recovered_packet_list.cbegin();

@@ -406,7 +403,7 @@ TEST(FecTest, MAYBE_FecTest) {

recovered_packet_list.end())

<< "Insufficient number of recovered packets.";

ForwardErrorCorrection::RecoveredPacket* recovered_packet =

- *recovered_packet_list_it;

+ recovered_packet_list_it->get();

ASSERT_EQ(recovered_packet->pkt->length, media_packet->length)

<< "Recovered packet length not identical to original "

@@ -415,7 +412,6 @@ TEST(FecTest, MAYBE_FecTest) {

media_packet->data, media_packet->length))

<< "Recovered packet payload not identical to original "

<< "media packet";

- delete recovered_packet;

recovered_packet_list.pop_front();

}

++media_packet_idx;

@@ -425,12 +421,7 @@ TEST(FecTest, MAYBE_FecTest) {

<< "Excessive number of recovered packets.\t size is: "

<< recovered_packet_list.size();

// -- Teardown --

- auto media_packet_list_it = media_packet_list.begin();

- while (media_packet_list_it != media_packet_list.end()) {

- delete *media_packet_list_it;

- ++media_packet_list_it;

- media_packet_list.pop_front();

- }

+ media_packet_list.clear();

RTC_DCHECK(media_packet_list.empty());

// Clear FEC packet list, so we don't pass in a non-empty

@@ -439,12 +430,7 @@ TEST(FecTest, MAYBE_FecTest) {

// Delete received packets we didn't pass to DecodeFEC(), due to

// early frame completion.

- auto received_packet_it = received_packet_list.cbegin();

- while (received_packet_it != received_packet_list.end()) {

- delete *received_packet_it;

- ++received_packet_it;

- received_packet_list.pop_front();

- }

+ received_packet_list.clear();

RTC_DCHECK(received_packet_list.empty());

while (!fec_mask_list.empty()) {

@@ -458,7 +444,7 @@ TEST(FecTest, MAYBE_FecTest) {

} // loop over loss rates

} // loop over mask types

- // Have DecodeFEC free allocated memory.

+ // Have DecodeFEC clear the recovered packet list.

fec.ResetState(&recovered_packet_list);

ASSERT_TRUE(recovered_packet_list.empty())

<< "Recovered packet list is not empty";

« webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc ('K') | « webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc ('k') | no next file » | no next file with comments »