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: Feedback response. 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 3e9a5989d608b151aff7fdeebc754a79ac438258..fbc572caeb1c185ebacb8120f964b328601f3f7e 100644

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

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

@@ -56,24 +56,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());

*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);

}

@@ -108,13 +109,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);

@@ -234,8 +234,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 -

@@ -273,9 +273,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,

@@ -288,23 +289,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++;

}

@@ -315,19 +315,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]);

}

@@ -388,7 +385,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;

}

@@ -401,7 +398,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();

@@ -410,7 +407,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 "

@@ -419,7 +416,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;

@@ -429,12 +425,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());

danilchap 2016/06/30 19:58:37 this DCHECK looks pointless after the simplificati

brandtr 2016/07/01 10:45:34 Removed.

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

@@ -443,12 +434,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());

danilchap 2016/06/30 19:58:37 Same here

brandtr 2016/07/01 10:45:34 Done.

while (!fec_mask_list.empty()) {

@@ -461,7 +447,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/producer_fec.cc ('K') | « webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc ('k') | no next file » | no next file with comments »