Change ForwardErrorCorrection class to accept one received packet at a time.

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 17 matching lines @@
 // #define VERBOSE_OUTPUT
 
 namespace webrtc {
 namespace fec_private_tables {
 extern const uint8_t** kPacketMaskBurstyTbl[12];
 }
 namespace test {
 using fec_private_tables::kPacketMaskBurstyTbl;
 
 void ReceivePackets(
-    ForwardErrorCorrection::ReceivedPacketList* to_decode_list,
-    ForwardErrorCorrection::ReceivedPacketList* received_packet_list,
+    std::vector<std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>>*
+        to_decode_list,
+    std::vector<std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>>*
+        received_packet_list,
     size_t num_packets_to_decode,
     float reorder_rate,
     float duplicate_rate,
     Random* random) {
   RTC_DCHECK(to_decode_list->empty());
   RTC_DCHECK_LE(num_packets_to_decode, received_packet_list->size());
 
   for (size_t i = 0; i < num_packets_to_decode; i++) {
     auto it = received_packet_list->begin();
     // Reorder packets.
@@ skipping 46 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::PacketList media_packet_list;
   std::list<ForwardErrorCorrection::Packet*> fec_packet_list;
-  ForwardErrorCorrection::ReceivedPacketList to_decode_list;
-  ForwardErrorCorrection::ReceivedPacketList received_packet_list;
+  std::vector<std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>>
+      to_decode_list;
+  std::vector<std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>>
+      received_packet_list;
   ForwardErrorCorrection::RecoveredPacketList recovered_packet_list;
   std::list<uint8_t*> fec_mask_list;
 
   // Running over only two loss rates to limit execution time.
   const float loss_rate[] = {0.05f, 0.01f};
   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];
@@ skipping 278 matching lines @@
                              num_packets_to_decode, reorder_rate,
                              duplicate_rate, &random);
 
               if (fec_packet_received == false) {
                 for (const 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.";
+              for (const auto& received_packet : to_decode_list) {
+                fec->DecodeFec(*received_packet, &recovered_packet_list);
+              }
+              to_decode_list.clear();
             }
             media_packet_idx = 0;
             for (const 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.";
@@ skipping 45 matching lines @@
 TEST(FecTest, UlpfecTest) {
   RunTest(false);
 }
 
 TEST(FecTest, FlexfecTest) {
   RunTest(true);
 }
 
 }  // namespace test
 }  // namespace webrtc