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

modules/rtp_rtcp/source/rtp_fec_unittest.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 68 matching lines @@
   // Check for complete recovery after FEC decoding.
   bool IsRecoveryComplete();
 
   ForwardErrorCorrectionType fec_;
 
   Random random_;
   test::fec::MediaPacketGenerator media_packet_generator_;
 
   ForwardErrorCorrection::PacketList media_packets_;
   std::list<ForwardErrorCorrection::Packet*> generated_fec_packets_;
-  ForwardErrorCorrection::ReceivedPacketList received_packets_;
+  std::vector<std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>>
+      received_packets_;
   ForwardErrorCorrection::RecoveredPacketList recovered_packets_;
 
   int media_loss_mask_[kUlpfecMaxMediaPackets];
   int fec_loss_mask_[kUlpfecMaxMediaPackets];
 };
 
 template <typename ForwardErrorCorrectionType>
 void RtpFecTest<ForwardErrorCorrectionType>::NetworkReceivedPackets(
     int* media_loss_mask,
     int* fec_loss_mask) {
   constexpr bool kFecPacket = true;
+  this->received_packets_.clear();
   ReceivedPackets(media_packets_, media_loss_mask, !kFecPacket);
   ReceivedPackets(generated_fec_packets_, fec_loss_mask, kFecPacket);
 }
 
 template <typename ForwardErrorCorrectionType>
 template <typename PacketListType>
 void RtpFecTest<ForwardErrorCorrectionType>::ReceivedPackets(
     const PacketListType& packet_list,
     int* loss_mask,
     bool is_fec) {
@@ skipping 119 matching lines @@
                               kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
   EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // No packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // No packets lost, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 TYPED_TEST(RtpFecTest, FecRecoveryWithLoss) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
   this->media_packets_ =
       this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
   EXPECT_EQ(
       0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
                               kNumImportantPackets, kUseUnequalProtection,
                               kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
   EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // 1 media packet lost
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // One packet lost, one FEC packet, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 2 media packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // 2 packets lost, one FEC packet, cannot get complete recovery.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 // Verify that we don't use an old FEC packet for FEC decoding.
 TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 20;
@@ skipping 27 matching lines @@
 
   // Expect 3 media packets for this frame.
   EXPECT_EQ(3u, this->media_packets_.size());
 
   // Second media packet lost (seq#0).
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   this->media_loss_mask_[1] = 1;
   // Add packets #65535, and #1 to received list.
   this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Expect that no decoding is done to get missing packet (seq#0) of second
   // frame, using old FEC packet (seq#2) from first (old) frame. So number of
   // recovered packets is 2, and not equal to number of media packets (=3).
   EXPECT_EQ(2u, this->recovered_packets_.size());
   EXPECT_TRUE(this->recovered_packets_.size() != this->media_packets_.size());
 }
 
 // Verify we can still recover frame if sequence number wrap occurs within
 // the frame and FEC packet following wrap is received after media packets.
@@ skipping 18 matching lines @@
 
   // Lose one media packet (seq# 65535).
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
   // Add FEC packet to received list following the media packets.
   this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
                         true);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Expect 3 media packets in recovered list, and complete recovery.
   // Wrap-around won't remove FEC packet, as it follows the wrap.
   EXPECT_EQ(3u, this->recovered_packets_.size());
   EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 // Sequence number wrap occurs within the ULPFEC packets for the frame.
-// In this case we will discard ULPFEC packet and full recovery is not expected.
 // Same problem will occur if wrap is within media packets but ULPFEC packet is
 // received before the media packets. This may be improved if timing information
 // is used to detect old ULPFEC packets.
-// TODO(marpan): Update test if wrap-around handling changes in FEC decoding.
+
+// TODO(nisse): There's some logic to discard ULPFEC packets at wrap-around,
+// however, that is not actually exercised by this test: When the first FEC
+// packet is processed, it results in full recovery of one media packet and the
+// FEC packet is forgotten. And then the wraparound isn't noticed when the next
+// FEC packet is received. We should fix wraparound handling, which currently
+// appears broken, and then figure out how to test it properly.
 using RtpFecTestUlpfecOnly = RtpFecTest<UlpfecForwardErrorCorrection>;
-TEST_F(RtpFecTestUlpfecOnly, FecRecoveryWithSeqNumGapOneFrameNoRecovery) {
+TEST_F(RtpFecTestUlpfecOnly, FecRecoveryWithSeqNumGapOneFrameRecovery) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 200;
 
   // 1 frame: 3 media packets and 2 FEC packets.
   // Sequence number wrap in FEC packets.
   //           -----Frame 1----
   // #65532(media) #65533(media) #65534(media) #65535(FEC) #0(FEC).
   this->media_packets_ =
       this->media_packet_generator_.ConstructMediaPackets(3, 65532);
 
   EXPECT_EQ(
       0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
                               kNumImportantPackets, kUseUnequalProtection,
                               kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 2 FEC packets.
   EXPECT_EQ(2u, this->generated_fec_packets_.size());
 
   // Lose the last two media packets (seq# 65533, 65534).
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[2] = 1;
   this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
   this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
                         true);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // The two FEC packets are received and should allow for complete recovery,
   // but because of the wrap the first FEC packet will be discarded, and only
   // one media packet is recoverable. So expect 2 media packets on recovered
   // list and no complete recovery.
-  EXPECT_EQ(2u, this->recovered_packets_.size());
-  EXPECT_TRUE(this->recovered_packets_.size() != this->media_packets_.size());
-  EXPECT_FALSE(this->IsRecoveryComplete());
+  EXPECT_EQ(3u, this->recovered_packets_.size());
+  EXPECT_EQ(this->recovered_packets_.size(), this->media_packets_.size());
+  EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 // TODO(brandtr): This test mimics the one above, ensuring that the recovery
 // strategy of FlexFEC matches the recovery strategy of ULPFEC. Since FlexFEC
 // does not share the sequence number space with the media, however, having a
 // matching recovery strategy may be suboptimal. Study this further.
+// TODO(nisse): In this test, recovery based on the first FEC packet fails with
+// the log message "The recovered packet had a length larger than a typical IP
+// packet, and is thus dropped." This is probably not intended, and needs
+// investigation.
 using RtpFecTestFlexfecOnly = RtpFecTest<FlexfecForwardErrorCorrection>;
 TEST_F(RtpFecTestFlexfecOnly, FecRecoveryWithSeqNumGapOneFrameNoRecovery) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 200;
 
   // 1 frame: 3 media packets and 2 FEC packets.
   // Sequence number wrap in FEC packets.
   //           -----Frame 1----
   // #65532(media) #65533(media) #65534(media) #65535(FEC) #0(FEC).
@@ skipping 17 matching lines @@
 
   // Lose the last two media packets (seq# 65533, 65534).
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[2] = 1;
   this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
   this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
                         true);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // The two FEC packets are received and should allow for complete recovery,
   // but because of the wrap the first FEC packet will be discarded, and only
   // one media packet is recoverable. So expect 2 media packets on recovered
   // list and no complete recovery.
   EXPECT_EQ(2u, this->recovered_packets_.size());
   EXPECT_TRUE(this->recovered_packets_.size() != this->media_packets_.size());
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
@@ skipping 22 matching lines @@
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
   // Reorder received media packets.
   auto it0 = this->received_packets_.begin();
   auto it1 = this->received_packets_.begin();
   it1++;
   std::swap(*it0, *it1);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Expect 3 media packets in recovered list, and complete recovery.
   EXPECT_EQ(3u, this->recovered_packets_.size());
   EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 // Verify we can still recover frame if FEC is received before media packets.
 TYPED_TEST(RtpFecTest, FecRecoveryWithFecOutOfOrder) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
@@ skipping 16 matching lines @@
   // Lose one media packet (seq# 1).
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   // Add FEC packet to received list before the media packets.
   this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
                         true);
   // Add media packets to received list.
   this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Expect 3 media packets in recovered list, and complete recovery.
   EXPECT_EQ(3u, this->recovered_packets_.size());
   EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 // Test 50% protection with random mask type: Two cases are considered:
 // a 50% non-consecutive loss which can be fully recovered, and a 50%
 // consecutive loss which cannot be fully recovered.
 TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percRandomMask) {
@@ skipping 25 matching lines @@
 
   // 4 packets lost: 3 media packets (0, 2, 3), and one FEC packet (0) lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->fec_loss_mask_[0] = 1;
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[2] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // With media packet#1 and FEC packets #1, #2, #3, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 4 consecutive packets lost: media packets 0, 1, 2, 3.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[2] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Cannot get complete recovery for this loss configuration with random mask.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 // Test 50% protection with bursty type: Three cases are considered:
 // two 50% consecutive losses which can be fully recovered, and one
 // non-consecutive which cannot be fully recovered.
 TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) {
   constexpr int kNumImportantPackets = 0;
@@ skipping 24 matching lines @@
 
   // 4 consecutive packets lost: media packets 0,1,2,3.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[2] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Expect complete recovery for consecutive packet loss <= 50%.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 4 consecutive packets lost: media packets 1,2, 3, and FEC packet 0.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->fec_loss_mask_[0] = 1;
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[2] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Expect complete recovery for consecutive packet loss <= 50%.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 4 packets lost (non-consecutive loss): media packets 0, 3, and FEC# 0, 3.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->fec_loss_mask_[0] = 1;
   this->fec_loss_mask_[3] = 1;
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Cannot get complete recovery for this loss configuration.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 TYPED_TEST(RtpFecTest, FecRecoveryNoLossUep) {
   constexpr int kNumImportantPackets = 2;
   constexpr bool kUseUnequalProtection = true;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
   this->media_packets_ =
       this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
   EXPECT_EQ(
       0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
                               kNumImportantPackets, kUseUnequalProtection,
                               kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
   EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // No packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // No packets lost, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 TYPED_TEST(RtpFecTest, FecRecoveryWithLossUep) {
   constexpr int kNumImportantPackets = 2;
   constexpr bool kUseUnequalProtection = true;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
   this->media_packets_ =
       this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
   EXPECT_EQ(
       0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
                               kNumImportantPackets, kUseUnequalProtection,
                               kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
   EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // 1 media packet lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // One packet lost, one FEC packet, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 2 media packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // 2 packets lost, one FEC packet, cannot get complete recovery.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 // Test 50% protection with random mask type for UEP on.
 TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) {
   constexpr int kNumImportantPackets = 1;
   constexpr bool kUseUnequalProtection = true;
   constexpr int kNumMediaPackets = 4;
@@ skipping 22 matching lines @@
 
   // 4 packets lost: 3 media packets and FEC packet#1 lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->fec_loss_mask_[1] = 1;
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[2] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // With media packet#3 and FEC packets #0, #1, #3, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 5 packets lost: 4 media packets and one FEC packet#2 lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->fec_loss_mask_[2] = 1;
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[1] = 1;
   this->media_loss_mask_[2] = 1;
   this->media_loss_mask_[3] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Cannot get complete recovery for this loss configuration.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePackets) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 5;
   constexpr uint8_t kProtectionFactor = 60;
@@ skipping 13 matching lines @@
 
   // Expect 1 FEC packet.
   EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // 1 protected media packet lost
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[2] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // One packet lost, one FEC packet, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // Unprotected packet lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Unprotected packet lost. Recovery not possible.
   EXPECT_FALSE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 2 media packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[0] = 1;
   this->media_loss_mask_[2] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // 2 protected packets lost, one FEC packet, cannot get complete recovery.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 21;
   uint8_t kProtectionFactor = 127;
@@ skipping 16 matching lines @@
 
   // Expect 5 FEC packet.
   EXPECT_EQ(5u, this->generated_fec_packets_.size());
 
   // Last protected media packet lost
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[kNumMediaPackets - 1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // One packet lost, one FEC packet, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // Last unprotected packet lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[kNumMediaPackets - 2] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Unprotected packet lost. Recovery not possible.
   EXPECT_FALSE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 6 media packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[kNumMediaPackets - 11] = 1;
   this->media_loss_mask_[kNumMediaPackets - 9] = 1;
   this->media_loss_mask_[kNumMediaPackets - 7] = 1;
   this->media_loss_mask_[kNumMediaPackets - 5] = 1;
   this->media_loss_mask_[kNumMediaPackets - 3] = 1;
   this->media_loss_mask_[kNumMediaPackets - 1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // 5 protected packets lost, one FEC packet, cannot get complete recovery.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 21;
   uint8_t kProtectionFactor = 127;
@@ skipping 16 matching lines @@
 
   // Expect 5 FEC packet.
   EXPECT_EQ(5u, this->generated_fec_packets_.size());
 
   // Last protected media packet lost
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[kNumMediaPackets - 1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // One packet lost, one FEC packet, expect complete recovery.
   EXPECT_TRUE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // Last unprotected packet lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[kNumMediaPackets - 2] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // Unprotected packet lost. Recovery not possible.
   EXPECT_FALSE(this->IsRecoveryComplete());
   this->recovered_packets_.clear();
 
   // 6 media packets lost.
   memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));
   memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
   this->media_loss_mask_[kNumMediaPackets - 11] = 1;
   this->media_loss_mask_[kNumMediaPackets - 9] = 1;
   this->media_loss_mask_[kNumMediaPackets - 7] = 1;
   this->media_loss_mask_[kNumMediaPackets - 5] = 1;
   this->media_loss_mask_[kNumMediaPackets - 3] = 1;
   this->media_loss_mask_[kNumMediaPackets - 1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
-  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
-                                    &this->recovered_packets_));
+  for (const auto& received_packet : this->received_packets_) {
+    this->fec_.DecodeFec(*received_packet,
+                         &this->recovered_packets_);
+  }
 
   // 5 protected packets lost, one FEC packet, cannot get complete recovery.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 }  // namespace webrtc