Use std::unique_ptr in ForwardErrorCorrection.

webrtc/modules/rtp_rtcp/test/testFec/test_fec.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 35 matching lines @@
     // Reorder packets.
     float random_variable = random->Rand<float>();
     while (random_variable < reorder_rate) {
       ++it;
       if (it == received_packet_list->end()) {
         --it;
         break;
       }
       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);
   }
 }
 
 // Too slow to finish before timeout on iOS. See webrtc:4755.
 #if defined(WEBRTC_IOS)
 #define MAYBE_FecTest DISABLED_FecTest
 #else
 #define MAYBE_FecTest FecTest
 #endif
 TEST(FecTest, MAYBE_FecTest) {
@@ skipping 14 matching lines @@
   // Maximum number of media packets allowed for the mask type.
   const uint16_t kMaxMediaPackets[] = {
       kMaxNumberMediaPackets,
       sizeof(kPacketMaskBurstyTbl) / sizeof(*kPacketMaskBurstyTbl)};
 
   ASSERT_EQ(12, kMaxMediaPackets[1]) << "Max media packets for bursty mode not "
                                      << "equal to 12.";
 
   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);
   const float reorder_rate = 0.1f;
   const float duplicate_rate = 0.1f;
 
   uint8_t media_loss_mask[kMaxNumberMediaPackets];
   uint8_t fec_loss_mask[kMaxNumberFecPackets];
   uint8_t fec_packet_masks[kMaxNumberFecPackets][kMaxNumberMediaPackets];
 
@@ skipping 98 matching lines @@
               ASSERT_NE(0u, column_sum) << "Column is all zero " << j;
             }
 
             // Construct media packets.
             // Reset the sequence number here for each FEC code/mask tested
             // below, to avoid sequence number wrap-around. In actual decoding,
             // old FEC packets in list are dropped if sequence number wrap
             // 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 -
                   ForwardErrorCorrection::PacketOverhead());
               media_packet->length = random.Rand(kMinPacketSize,
                                                  kMaxPacketSize);
 
               // Generate random values for the first 2 bytes.
               media_packet->data[0] = random.Rand<uint8_t>();
               media_packet->data[1] = random.Rand<uint8_t>();
@@ skipping 17 matching lines @@
               ByteWriter<uint16_t>::WriteBigEndian(&media_packet->data[2],
                                                    seq_num);
               ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[4],
                                                    timestamp);
               ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8],
                                                    ssrc);
               // Generate random values for payload
               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,
                                          fec_mask_type, &fec_packet_list))
                 << "GenerateFEC() failed";
 
             ASSERT_EQ(num_fec_packets, fec_packet_list.size())
                 << "We requested " << num_fec_packets << " FEC packets, but "
                 << "GenerateFEC() produced " << fec_packet_list.size();
 
             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++;
             }
 
             memset(fec_loss_mask, 0, sizeof(fec_loss_mask));
             uint32_t fec_packet_idx = 0;
             for (auto* fec_packet : fec_packet_list) {
               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]);
               }
               ++fec_packet_idx;
               ++seq_num;
             }
 
 #ifdef VERBOSE_OUTPUT
             printf("Media loss mask:\n");
             for (uint32_t i = 0; i < num_media_packets; i++) {
@@ skipping 40 matching lines @@
             // For error-checking frame completion.
             bool fec_packet_received = false;
             while (!received_packet_list.empty()) {
               size_t num_packets_to_decode = random.Rand(
                   1u, static_cast<uint32_t>(received_packet_list.size()));
               ReceivePackets(&to_decode_list, &received_packet_list,
                              num_packets_to_decode, reorder_rate,
                              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;
                   }
                 }
               }
               ASSERT_EQ(0, fec.DecodeFEC(&to_decode_list,
                                          &recovered_packet_list))
                   << "DecodeFEC() failed";
               ASSERT_TRUE(to_decode_list.empty())
                   << "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();
 
                 ASSERT_FALSE(recovered_packet_list_it ==
                              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 "
                     << "media packet";
                 ASSERT_EQ(0, memcmp(recovered_packet->pkt->data,
                                     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;
             }
             fec.ResetState(&recovered_packet_list);
             ASSERT_TRUE(recovered_packet_list.empty())
                 << "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
             // list in the next call to DecodeFEC().
             fec_packet_list.clear();
 
             // 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()) {
               fec_mask_list.pop_front();
             }
             timestamp += 90000 / 30;
           }  // loop over num_imp_packets
         }    // loop over FecPackets
       }      // loop over num_media_packets
       delete[] packet_mask;
     }  // 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";
 }
 
 }  // namespace test
 }  // namespace webrtc