diff --git a/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc
index 1c30f37..110e7c0 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/fec_receiver_unittest.cc
@@ -22,46 +22,48 @@
 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 
+namespace webrtc {
+
+namespace {
+constexpr uint8_t kFecPayloadType = 96;
+}  // namespace
+
 using ::testing::_;
 using ::testing::Args;
 using ::testing::ElementsAreArray;
 using ::testing::Return;
-using Packet = webrtc::ForwardErrorCorrection::Packet;
 
-namespace webrtc {
+using ::webrtc::test::fec::FrameGenerator;
+using Packet = ::webrtc::ForwardErrorCorrection::Packet;
+using ::webrtc::test::fec::RawRtpPacket;
 
 class ReceiverFecTest : public ::testing::Test {
  protected:
-  virtual void SetUp() {
-    fec_.reset(new ForwardErrorCorrection());
-    receiver_fec_.reset(FecReceiver::Create(&rtp_data_callback_));
-    generator_.reset(new FrameGenerator());
-  }
+  ReceiverFecTest() : receiver_fec_(FecReceiver::Create(&rtp_data_callback_)) {}
 
-  void GenerateFec(ForwardErrorCorrection::PacketList* media_packets,
-                   std::list<ForwardErrorCorrection::Packet*>* fec_packets,
-                   unsigned int num_fec_packets) {
+  void EncodeFec(ForwardErrorCorrection::PacketList* media_packets,
+                 std::list<ForwardErrorCorrection::Packet*>* fec_packets,
+                 unsigned int num_fec_packets) {
     uint8_t protection_factor = num_fec_packets * 255 / media_packets->size();
-    EXPECT_EQ(0, fec_->GenerateFec(*media_packets, protection_factor,
-                                   0, false, kFecMaskBursty, fec_packets));
+    EXPECT_EQ(0, fec_.EncodeFec(*media_packets, protection_factor, 0, false,
+                                kFecMaskBursty, fec_packets));
     ASSERT_EQ(num_fec_packets, fec_packets->size());
   }
 
   void GenerateFrame(int num_media_packets,
                      int frame_offset,
-                     std::list<test::RawRtpPacket*>* media_rtp_packets,
+                     std::list<RawRtpPacket*>* media_rtp_packets,
                      ForwardErrorCorrection::PacketList* media_packets) {
-    generator_->NewFrame(num_media_packets);
+    generator_.NewFrame(num_media_packets);
     for (int i = 0; i < num_media_packets; ++i) {
-      std::unique_ptr<test::RawRtpPacket> next_packet(
-        generator_->NextPacket(frame_offset + i, kRtpHeaderSize + 10));
+      std::unique_ptr<RawRtpPacket> next_packet(
+          generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10));
       media_rtp_packets->push_back(next_packet.get());
       media_packets->push_back(std::move(next_packet));
     }
   }
 
-  void VerifyReconstructedMediaPacket(const test::RawRtpPacket* packet,
-                                      int times) {
+  void VerifyReconstructedMediaPacket(const RawRtpPacket* packet, int times) {
     // Verify that the content of the reconstructed packet is equal to the
     // content of |packet|, and that the same content is received |times| number
     // of times in a row.
@@ -71,17 +73,17 @@
         .Times(times).WillRepeatedly(Return(true));
   }
 
-  void BuildAndAddRedMediaPacket(test::RawRtpPacket* packet) {
-    std::unique_ptr<test::RawRtpPacket> red_packet(
-        generator_->BuildMediaRedPacket(packet));
+  void BuildAndAddRedMediaPacket(RawRtpPacket* packet) {
+    std::unique_ptr<RawRtpPacket> red_packet(
+        generator_.BuildMediaRedPacket(packet));
     EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
                      red_packet->header.header, red_packet->data,
                      red_packet->length, kFecPayloadType));
   }
 
   void BuildAndAddRedFecPacket(Packet* packet) {
-    std::unique_ptr<test::RawRtpPacket> red_packet(
-        generator_->BuildFecRedPacket(packet));
+    std::unique_ptr<RawRtpPacket> red_packet(
+        generator_.BuildFecRedPacket(packet));
     EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
                      red_packet->header.header, red_packet->data,
                      red_packet->length, kFecPayloadType));
@@ -93,18 +95,18 @@
                                       uint8_t ulpfec_payload_type);
 
   MockRtpData rtp_data_callback_;
-  std::unique_ptr<ForwardErrorCorrection> fec_;
+  ForwardErrorCorrection fec_;
   std::unique_ptr<FecReceiver> receiver_fec_;
-  std::unique_ptr<FrameGenerator> generator_;
+  FrameGenerator generator_;
 };
 
 TEST_F(ReceiverFecTest, TwoMediaOneFec) {
   const unsigned int kNumFecPackets = 1u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
+  EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
   auto it = media_rtp_packets.begin();
@@ -129,11 +131,11 @@
       .WillRepeatedly(Return(true));
 
   const unsigned int kNumFecPackets = 1u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
+  EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
   ByteWriter<uint16_t>::WriteBigEndian(
       &fec_packets.front()->data[fec_garbage_offset], 0x4711);
 
@@ -162,11 +164,11 @@
 
 TEST_F(ReceiverFecTest, TwoMediaTwoFec) {
   const unsigned int kNumFecPackets = 2u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
+  EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
   // Drop both media packets.
@@ -184,12 +186,12 @@
 
 TEST_F(ReceiverFecTest, TwoFramesOneFec) {
   const unsigned int kNumFecPackets = 1u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
   GenerateFrame(1, 1, &media_rtp_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
+  EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
   auto it = media_rtp_packets.begin();
@@ -205,13 +207,13 @@
 
 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) {
   const unsigned int kNumFecPackets = 1u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
   GenerateFrame(2, 1, &media_rtp_packets, &media_packets);
 
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
+  EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
   auto it = media_rtp_packets.begin();
@@ -227,13 +229,13 @@
 TEST_F(ReceiverFecTest, MaxFramesOneFec) {
   const unsigned int kNumFecPackets = 1u;
   const unsigned int kNumMediaPackets = 48u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
     GenerateFrame(1, i, &media_rtp_packets, &media_packets);
   }
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
+  EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
   auto it = media_rtp_packets.begin();
@@ -252,15 +254,15 @@
 TEST_F(ReceiverFecTest, TooManyFrames) {
   const unsigned int kNumFecPackets = 1u;
   const unsigned int kNumMediaPackets = 49u;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
     GenerateFrame(1, i, &media_rtp_packets, &media_packets);
   }
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  EXPECT_EQ(-1, fec_->GenerateFec(media_packets,
-                                  kNumFecPackets * 255 / kNumMediaPackets, 0,
-                                  false, kFecMaskBursty, &fec_packets));
+  EXPECT_EQ(
+      -1, fec_.EncodeFec(media_packets, kNumFecPackets * 255 / kNumMediaPackets,
+                         0, false, kFecMaskBursty, &fec_packets));
 }
 
 TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) {
@@ -269,12 +271,12 @@
   Packet* delayed_fec = NULL;
   const unsigned int kNumFecPacketsBatch1 = 1u;
   const unsigned int kNumMediaPacketsBatch1 = 2u;
-  std::list<test::RawRtpPacket*> media_rtp_packets_batch1;
+  std::list<RawRtpPacket*> media_rtp_packets_batch1;
   ForwardErrorCorrection::PacketList media_packets_batch1;
   GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
                 &media_packets_batch1);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
+  EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
 
   BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
@@ -284,7 +286,7 @@
 
   // Fill the FEC decoder. No packets should be dropped.
   const unsigned int kNumMediaPacketsBatch2 = 46u;
-  std::list<test::RawRtpPacket*> media_rtp_packets_batch2;
+  std::list<RawRtpPacket*> media_rtp_packets_batch2;
   ForwardErrorCorrection::PacketList media_packets_batch2;
   for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) {
     GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
@@ -310,12 +312,12 @@
   Packet* delayed_fec = NULL;
   const unsigned int kNumFecPacketsBatch1 = 1u;
   const unsigned int kNumMediaPacketsBatch1 = 2u;
-  std::list<test::RawRtpPacket*> media_rtp_packets_batch1;
+  std::list<RawRtpPacket*> media_rtp_packets_batch1;
   ForwardErrorCorrection::PacketList media_packets_batch1;
   GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
                 &media_packets_batch1);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
-  GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
+  EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
 
   BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
@@ -325,7 +327,7 @@
 
   // Fill the FEC decoder and force the last packet to be dropped.
   const unsigned int kNumMediaPacketsBatch2 = 48u;
-  std::list<test::RawRtpPacket*> media_rtp_packets_batch2;
+  std::list<RawRtpPacket*> media_rtp_packets_batch2;
   ForwardErrorCorrection::PacketList media_packets_batch2;
   for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) {
     GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
@@ -350,14 +352,14 @@
   // 49 frames with 2 media packets and one FEC packet. All media packets
   // missing.
   const unsigned int kNumMediaPackets = 49 * 2;
-  std::list<test::RawRtpPacket*> media_rtp_packets;
+  std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) {
-    std::list<test::RawRtpPacket*> frame_media_rtp_packets;
+    std::list<RawRtpPacket*> frame_media_rtp_packets;
     ForwardErrorCorrection::PacketList frame_media_packets;
     std::list<ForwardErrorCorrection::Packet*> fec_packets;
     GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets);
-    GenerateFec(&frame_media_packets, &fec_packets, 1);
+    EncodeFec(&frame_media_packets, &fec_packets, 1);
     for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) {
       // Only FEC packets inserted. No packets recoverable at this time.
       BuildAndAddRedFecPacket(*it);
diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
index e767f5a..235720d 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
+++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
@@ -10,10 +10,21 @@
 
 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
 
+#include <memory>
+#include <utility>
+
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
 namespace webrtc {
+namespace test {
+namespace fec {
+
+namespace {
+constexpr uint8_t kFecPayloadType = 96;
+constexpr uint8_t kRedPayloadType = 97;
+constexpr uint8_t kVp8PayloadType = 120;
+}  // namespace
 
 FrameGenerator::FrameGenerator()
     : num_packets_(0), seq_num_(0), timestamp_(0) {}
@@ -25,8 +36,8 @@
 
 uint16_t FrameGenerator::NextSeqNum() { return ++seq_num_; }
 
-test::RawRtpPacket* FrameGenerator::NextPacket(int offset, size_t length) {
-  test::RawRtpPacket* rtp_packet = new test::RawRtpPacket;
+RawRtpPacket* FrameGenerator::NextPacket(int offset, size_t length) {
+  RawRtpPacket* rtp_packet = new RawRtpPacket;
   for (size_t i = 0; i < length; ++i)
     rtp_packet->data[i + kRtpHeaderSize] = offset + i;
   rtp_packet->length = length + kRtpHeaderSize;
@@ -44,10 +55,9 @@
 }
 
 // Creates a new RtpPacket with the RED header added to the packet.
-test::RawRtpPacket* FrameGenerator::BuildMediaRedPacket(
-    const test::RawRtpPacket* packet) {
+RawRtpPacket* FrameGenerator::BuildMediaRedPacket(const RawRtpPacket* packet) {
   const size_t kHeaderLength = packet->header.header.headerLength;
-  test::RawRtpPacket* red_packet = new test::RawRtpPacket;
+  RawRtpPacket* red_packet = new RawRtpPacket;
   red_packet->header = packet->header;
   red_packet->length = packet->length + 1;  // 1 byte RED header.
   memset(red_packet->data, 0, red_packet->length);
@@ -59,14 +69,14 @@
   return red_packet;
 }
 
-// Creates a new RtpPacket with FEC payload and red header. Does this by
+// Creates a new RtpPacket with FEC payload and RED header. Does this by
 // creating a new fake media RtpPacket, clears the marker bit and adds a RED
 // header. Finally replaces the payload with the content of |packet->data|.
-test::RawRtpPacket* FrameGenerator::BuildFecRedPacket(
+RawRtpPacket* FrameGenerator::BuildFecRedPacket(
     const ForwardErrorCorrection::Packet* packet) {
   // Create a fake media packet to get a correct header. 1 byte RED header.
   ++num_packets_;
-  test::RawRtpPacket* red_packet = NextPacket(0, packet->length + 1);
+  RawRtpPacket* red_packet = NextPacket(0, packet->length + 1);
   red_packet->data[1] &= ~0x80;  // Clear marker bit.
   const size_t kHeaderLength = red_packet->header.header.headerLength;
   SetRedHeader(red_packet, kFecPayloadType, kHeaderLength);
@@ -95,4 +105,69 @@
   ByteWriter<uint32_t>::WriteBigEndian(data + 8, header->ssrc);
 }
 
+ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
+    int num_media_packets,
+    uint16_t start_seq_num) {
+  RTC_DCHECK_GT(num_media_packets, 0);
+  uint16_t seq_num = start_seq_num;
+  int time_stamp = random_->Rand<int>();
+
+  ForwardErrorCorrection::PacketList media_packets;
+
+  for (int i = 0; i < num_media_packets; ++i) {
+    std::unique_ptr<ForwardErrorCorrection::Packet> media_packet(
+        new ForwardErrorCorrection::Packet());
+    media_packet->length = random_->Rand(min_packet_size_, max_packet_size_);
+
+    // Generate random values for the first 2 bytes
+    media_packet->data[0] = random_->Rand<uint8_t>();
+    media_packet->data[1] = random_->Rand<uint8_t>();
+
+    // The first two bits are assumed to be 10 by the FEC encoder.
+    // In fact the FEC decoder will set the two first bits to 10 regardless of
+    // what they actually were. Set the first two bits to 10 so that a memcmp
+    // can be performed for the whole restored packet.
+    media_packet->data[0] |= 0x80;
+    media_packet->data[0] &= 0xbf;
+
+    // FEC is applied to a whole frame.
+    // A frame is signaled by multiple packets without the marker bit set
+    // followed by the last packet of the frame for which the marker bit is set.
+    // Only push one (fake) frame to the FEC.
+    media_packet->data[1] &= 0x7f;
+
+    webrtc::ByteWriter<uint16_t>::WriteBigEndian(&media_packet->data[2],
+                                                 seq_num);
+    webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[4],
+                                                 time_stamp);
+    webrtc::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>();
+    }
+    seq_num++;
+    media_packets.push_back(std::move(media_packet));
+  }
+  // Last packet, set marker bit.
+  ForwardErrorCorrection::Packet* media_packet = media_packets.back().get();
+  RTC_DCHECK(media_packet);
+  media_packet->data[1] |= 0x80;
+
+  fec_seq_num_ = seq_num;
+
+  return media_packets;
+}
+
+ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
+    int num_media_packets) {
+  return ConstructMediaPackets(num_media_packets, random_->Rand<uint16_t>());
+}
+
+uint16_t MediaPacketGenerator::GetFecSeqNum() {
+  return fec_seq_num_;
+}
+
+}  // namespace fec
+}  // namespace test
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.h b/webrtc/modules/rtp_rtcp/source/fec_test_helper.h
index 6af7f9c..9c0a323 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.h
+++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.h
@@ -11,19 +11,20 @@
 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_FEC_TEST_HELPER_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_FEC_TEST_HELPER_H_
 
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/random.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 
 namespace webrtc {
 namespace test {
+
+// Needed to not clash with another webrtc::FrameGenerator.
+namespace fec {
+
 struct RawRtpPacket : public ForwardErrorCorrection::Packet {
   WebRtcRTPHeader header;
 };
-}  // namespace test
-
-const uint8_t kFecPayloadType = 96;
-const uint8_t kRedPayloadType = 97;
-const uint8_t kVp8PayloadType = 120;
 
 class FrameGenerator {
  public:
@@ -33,16 +34,15 @@
 
   uint16_t NextSeqNum();
 
-  test::RawRtpPacket* NextPacket(int offset, size_t length);
+  RawRtpPacket* NextPacket(int offset, size_t length);
 
   // Creates a new RtpPacket with the RED header added to the packet.
-  test::RawRtpPacket* BuildMediaRedPacket(const test::RawRtpPacket* packet);
+  RawRtpPacket* BuildMediaRedPacket(const RawRtpPacket* packet);
 
   // Creates a new RtpPacket with FEC payload and red header. Does this by
   // creating a new fake media RtpPacket, clears the marker bit and adds a RED
   // header. Finally replaces the payload with the content of |packet->data|.
-  test::RawRtpPacket* BuildFecRedPacket(
-      const ForwardErrorCorrection::Packet* packet);
+  RawRtpPacket* BuildFecRedPacket(const ForwardErrorCorrection::Packet* packet);
 
   void SetRedHeader(ForwardErrorCorrection::Packet* red_packet,
                     uint8_t payload_type,
@@ -55,6 +55,39 @@
   uint16_t seq_num_;
   uint32_t timestamp_;
 };
+
+class MediaPacketGenerator {
+ public:
+  MediaPacketGenerator(uint32_t min_packet_size,
+                       uint32_t max_packet_size,
+                       uint32_t ssrc,
+                       Random* random)
+      : min_packet_size_(min_packet_size),
+        max_packet_size_(max_packet_size),
+        ssrc_(ssrc),
+        random_(random) {}
+
+  // Construct the media packets, up to |num_media_packets| packets.
+  ForwardErrorCorrection::PacketList ConstructMediaPackets(
+      int num_media_packets,
+      uint16_t start_seq_num);
+  ForwardErrorCorrection::PacketList ConstructMediaPackets(
+      int num_media_packets);
+
+  uint16_t GetFecSeqNum();
+
+ private:
+  uint32_t min_packet_size_;
+  uint32_t max_packet_size_;
+  uint32_t ssrc_;
+  Random* random_;
+
+  ForwardErrorCorrection::PacketList media_packets_;
+  uint16_t fec_seq_num_;
+};
+
+}  // namespace fec
+}  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_FEC_TEST_HELPER_H_
diff --git a/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc b/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
index b214f60..a89b71b 100644
--- a/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
+++ b/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc
@@ -94,19 +94,18 @@
 //   |                                                               |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //
-// Note that any potential RED headers are added/removed before calling
-// GenerateFec() or DecodeFec().
-int ForwardErrorCorrection::GenerateFec(const PacketList& media_packets,
-                                        uint8_t protection_factor,
-                                        int num_important_packets,
-                                        bool use_unequal_protection,
-                                        FecMaskType fec_mask_type,
-                                        std::list<Packet*>* fec_packets) {
-  const uint16_t num_media_packets = media_packets.size();
+int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets,
+                                      uint8_t protection_factor,
+                                      int num_important_packets,
+                                      bool use_unequal_protection,
+                                      FecMaskType fec_mask_type,
+                                      std::list<Packet*>* fec_packets) {
+  const size_t num_media_packets = media_packets.size();
+
   // Sanity check arguments.
-  RTC_DCHECK_GT(num_media_packets, 0);
+  RTC_DCHECK_GT(num_media_packets, 0u);
   RTC_DCHECK_GE(num_important_packets, 0);
-  RTC_DCHECK_LE(num_important_packets, num_media_packets);
+  RTC_DCHECK_LE(static_cast<size_t>(num_important_packets), num_media_packets);
   RTC_DCHECK(fec_packets->empty());
 
   if (num_media_packets > kMaxMediaPackets) {
diff --git a/webrtc/modules/rtp_rtcp/source/forward_error_correction.h b/webrtc/modules/rtp_rtcp/source/forward_error_correction.h
index 7d2e5aa..21f2afb 100644
--- a/webrtc/modules/rtp_rtcp/source/forward_error_correction.h
+++ b/webrtc/modules/rtp_rtcp/source/forward_error_correction.h
@@ -147,14 +147,16 @@
   //                                of type Packet. Must be empty on entry.
   //                                The memory available through the list will
   //                                be valid until the next call to
-  //                                GenerateFec().
+  //                                EncodeFec().
   //
   // Returns 0 on success, -1 on failure.
   //
-  int GenerateFec(const PacketList& media_packets,
-                  uint8_t protection_factor, int num_important_packets,
-                  bool use_unequal_protection, FecMaskType fec_mask_type,
-                  std::list<Packet*>* fec_packets);
+  int EncodeFec(const PacketList& media_packets,
+                uint8_t protection_factor,
+                int num_important_packets,
+                bool use_unequal_protection,
+                FecMaskType fec_mask_type,
+                std::list<Packet*>* fec_packets);
 
   //
   // Decodes a list of received media and FEC packets. It will parse the
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec.cc b/webrtc/modules/rtp_rtcp/source/producer_fec.cc
index cf58cee..06f1540 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec.cc
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec.cc
@@ -24,12 +24,12 @@
 constexpr size_t kRedForFecHeaderLength = 1;
 
 // This controls the maximum amount of excess overhead (actual - target)
-// allowed in order to trigger GenerateFec(), before |params_.max_fec_frames|
+// allowed in order to trigger EncodeFec(), before |params_.max_fec_frames|
 // is reached. Overhead here is defined as relative to number of media packets.
 constexpr int kMaxExcessOverhead = 50;  // Q8.
 
 // This is the minimum number of media packets required (above some protection
-// level) in order to trigger GenerateFec(), before |params_.max_fec_frames| is
+// level) in order to trigger EncodeFec(), before |params_.max_fec_frames| is
 // reached.
 constexpr size_t kMinMediaPackets = 4;
 
@@ -175,9 +175,9 @@
     // Since unequal protection is disabled, the value of
     // |num_important_packets_| has no importance when calling GenerateFec().
     constexpr bool kUseUnequalProtection = false;
-    int ret = fec_.GenerateFec(media_packets_, params_.fec_rate,
-                               num_important_packets_, kUseUnequalProtection,
-                               params_.fec_mask_type, &generated_fec_packets_);
+    int ret = fec_.EncodeFec(media_packets_, params_.fec_rate,
+                             num_important_packets_, kUseUnequalProtection,
+                             params_.fec_mask_type, &generated_fec_packets_);
     if (generated_fec_packets_.empty()) {
       num_protected_frames_ = 0;
       DeleteMediaPackets();
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
index 5f26401..ae51605 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
@@ -20,6 +20,14 @@
 
 namespace webrtc {
 
+namespace {
+constexpr uint8_t kFecPayloadType = 96;
+constexpr uint8_t kRedPayloadType = 97;
+}  // namespace
+
+using ::webrtc::test::fec::FrameGenerator;
+using ::webrtc::test::fec::RawRtpPacket;
+
 void VerifyHeader(uint16_t seq_num,
                   uint32_t timestamp,
                   int red_payload_type,
@@ -97,12 +105,12 @@
   // media packets for 1 frame is at least |minimum_media_packets_fec_|.
   const int kNumPackets = 4;
   FecProtectionParams params = {15, 3, kFecMaskRandom};
-  std::list<test::RawRtpPacket*> rtp_packets;
+  std::list<RawRtpPacket*> rtp_packets;
   generator_.NewFrame(kNumPackets);
   producer_.SetFecParameters(&params, 0);  // Expecting one FEC packet.
   uint32_t last_timestamp = 0;
   for (int i = 0; i < kNumPackets; ++i) {
-    test::RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10);
+    RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10);
     rtp_packets.push_back(rtp_packet);
     EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
                      rtp_packet->data, rtp_packet->length, kRtpHeaderSize));
@@ -135,14 +143,13 @@
   const int kNumFrames = 2;
 
   FecProtectionParams params = {15, 3, kFecMaskRandom};
-  std::list<test::RawRtpPacket*> rtp_packets;
+  std::list<RawRtpPacket*> rtp_packets;
   producer_.SetFecParameters(&params, 0);  // Expecting one FEC packet.
   uint32_t last_timestamp = 0;
   for (int i = 0; i < kNumFrames; ++i) {
     generator_.NewFrame(kNumPackets);
     for (int j = 0; j < kNumPackets; ++j) {
-      test::RawRtpPacket* rtp_packet =
-          generator_.NextPacket(i * kNumPackets + j, 10);
+      RawRtpPacket* rtp_packet = generator_.NextPacket(i * kNumPackets + j, 10);
       rtp_packets.push_back(rtp_packet);
       EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
                        rtp_packet->data, rtp_packet->length, kRtpHeaderSize));
@@ -166,16 +173,14 @@
 
 TEST_F(ProducerFecTest, BuildRedPacket) {
   generator_.NewFrame(1);
-  test::RawRtpPacket* packet = generator_.NextPacket(0, 10);
+  RawRtpPacket* packet = generator_.NextPacket(0, 10);
   std::unique_ptr<RedPacket> red_packet =
       ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize,
                                   kRtpHeaderSize, kRedPayloadType);
   EXPECT_EQ(packet->length + 1, red_packet->length());
   VerifyHeader(packet->header.header.sequenceNumber,
-               packet->header.header.timestamp,
-               kRedPayloadType,
-               packet->header.header.payloadType,
-               red_packet.get(),
+               packet->header.header.timestamp, kRedPayloadType,
+               packet->header.header.payloadType, red_packet.get(),
                true);  // Marker bit set.
   for (int i = 0; i < 10; ++i)
     EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]);
@@ -188,7 +193,7 @@
   constexpr size_t kRedForFecHeaderLength = 1;
 
   generator_.NewFrame(kNumFrames);
-  std::unique_ptr<test::RawRtpPacket> packet(
+  std::unique_ptr<RawRtpPacket> packet(
       generator_.NextPacket(0, kPayloadLength));
   std::unique_ptr<RedPacket> red_packet =
       ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize,
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
index 1bb1d65..9f6dee2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc
@@ -10,45 +10,55 @@
 
 #include <algorithm>
 #include <list>
+#include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/basictypes.h"
 #include "webrtc/base/random.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 
-using webrtc::ForwardErrorCorrection;
+namespace webrtc {
 
-// Minimum RTP header size in bytes.
-constexpr uint8_t kRtpHeaderSize = 12;
+namespace {
 
 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum.
-constexpr uint8_t kTransportOverhead = 28;
+constexpr size_t kTransportOverhead = 28;
 
-// Maximum number of media packets used in the FEC (RFC 5109).
-constexpr uint8_t kMaxNumberMediaPackets =
-    ForwardErrorCorrection::kMaxMediaPackets;
+constexpr uint32_t kMediaSsrc = 83542;
 
-using PacketList = ForwardErrorCorrection::PacketList;
-using ReceivedPacketList = ForwardErrorCorrection::ReceivedPacketList;
-using RecoveredPacketList = ForwardErrorCorrection::RecoveredPacketList;
+// Deep copies |src| to |dst|, but only keeps every Nth packet.
+void DeepCopyEveryNthPacket(const ForwardErrorCorrection::PacketList& src,
+                            int n,
+                            ForwardErrorCorrection::PacketList* dst) {
+  RTC_DCHECK_GT(n, 0);
+  int i = 0;
+  for (const auto& packet : src) {
+    if (i % n == 0) {
+      dst->emplace_back(new ForwardErrorCorrection::Packet(*packet));
+    }
+    ++i;
+  }
+}
 
+}  // namespace
+
+using ::testing::Types;
+
+template <typename ForwardErrorCorrectionType>
 class RtpFecTest : public ::testing::Test {
  protected:
   RtpFecTest()
-      : random_(0xfec133700742),
-        ssrc_(random_.Rand<uint32_t>()),
-        fec_seq_num_(0) {}
+      : random_(0xabcdef123456),
+        media_packet_generator_(
+            kRtpHeaderSize,  // Minimum packet size.
+            IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead -
+                fec_.MaxPacketOverhead(),  // Maximum packet size.
+            kMediaSsrc,
+            &random_) {}
 
-  // Construct the media packet list, up to |num_media_packets| packets.
-  // Returns the next sequence number after the last media packet.
-  // (this will be the sequence of the first FEC packet)
-  int ConstructMediaPacketsSeqNum(int num_media_packets, int start_seq_num);
-  int ConstructMediaPackets(int num_media_packets);
-
-  // Deep copies |src| to |dst|, but only keeps every Nth packet.
-  void DeepCopyEveryNthPacket(const PacketList& src, int n, PacketList* dst);
-
-  // Construct |received_packet_list_|: a subset of the media and FEC packets.
+  // Construct |received_packets_|: a subset of the media and FEC packets.
   //
   // Media packet "i" is lost if media_loss_mask_[i] = 1, received if
   // media_loss_mask_[i] = 0.
@@ -66,91 +76,102 @@
   // Check for complete recovery after FEC decoding.
   bool IsRecoveryComplete();
 
-  // Delete the media and FEC packets.
-  void TearDown();
+  ForwardErrorCorrectionType fec_;
 
-  webrtc::Random random_;
-  ForwardErrorCorrection fec_;
-  int ssrc_;
-  uint16_t fec_seq_num_;
+  Random random_;
+  test::fec::MediaPacketGenerator media_packet_generator_;
 
-  PacketList media_packet_list_;
-  std::list<ForwardErrorCorrection::Packet*> fec_packet_list_;
-  ReceivedPacketList received_packet_list_;
-  RecoveredPacketList recovered_packet_list_;
+  ForwardErrorCorrection::PacketList media_packets_;
+  std::list<ForwardErrorCorrection::Packet*> generated_fec_packets_;
+  ForwardErrorCorrection::ReceivedPacketList received_packets_;
+  ForwardErrorCorrection::RecoveredPacketList recovered_packets_;
 
-  int media_loss_mask_[kMaxNumberMediaPackets];
-  int fec_loss_mask_[kMaxNumberMediaPackets];
+  int media_loss_mask_[ForwardErrorCorrection::kMaxMediaPackets];
+  int fec_loss_mask_[ForwardErrorCorrection::kMaxMediaPackets];
 };
 
-TEST_F(RtpFecTest, FecRecoveryNoLoss) {
+// Define gTest typed test to loop over both ULPFEC and FlexFEC.
+// Since the tests now are parameterized, we need to access
+// member variables using |this|, thereby enforcing runtime
+// resolution.
+using FecTypes = Types<ForwardErrorCorrection>;
+TYPED_TEST_CASE(RtpFecTest, FecTypes);
+
+TYPED_TEST(RtpFecTest, FecRecoveryNoLoss) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // No packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // No packets lost, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
+  EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
-TEST_F(RtpFecTest, FecRecoveryWithLoss) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithLoss) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // 1 media packet lost
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // One packet lost, one FEC packet, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 2 media packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // 2 packets lost, one FEC packet, cannot get complete recovery.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 // Verify that we don't use an old FEC packet for FEC decoding.
-TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 20;
@@ -163,43 +184,47 @@
   // try to decode using "old" FEC packet #2.
 
   // Construct media packets for first frame, starting at sequence number 0.
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(2, 0);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(2, 0);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
   // Add FEC packet (seq#2) of this first frame to received list (i.e., assume
   // the two media packet were lost).
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  ReceivedPackets(fec_packet_list_, fec_loss_mask_, true);
+  memset(this->fec_loss_mask_, 0, sizeof(this->fec_loss_mask_));
+  this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
+                        true);
 
   // Construct media packets for second frame, with sequence number wrap.
-  media_packet_list_.clear();
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65535);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(3, 65535);
 
   // Expect 3 media packets for this frame.
-  EXPECT_EQ(3u, media_packet_list_.size());
+  EXPECT_EQ(3u, this->media_packets_.size());
 
   // Second media packet lost (seq#0).
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  media_loss_mask_[1] = 1;
+  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.
-  ReceivedPackets(media_packet_list_, media_loss_mask_, false);
+  this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
 
-  EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &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, recovered_packet_list_.size());
-  EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size());
+  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.
-TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 20;
@@ -207,29 +232,33 @@
   // One frame, with sequence number wrap in media packets.
   //         -----Frame 1----
   //  #65534(media) #65535(media) #0(media) #1(FEC).
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65534);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(3, 65534);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // Lose one media packet (seq# 65535).
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 1;
-  ReceivedPackets(media_packet_list_, media_loss_mask_, false);
+  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.
-  ReceivedPackets(fec_packet_list_, fec_loss_mask_, true);
+  this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
+                        true);
 
-  EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &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, recovered_packet_list_.size());
-  EXPECT_TRUE(IsRecoveryComplete());
+  EXPECT_EQ(3u, this->recovered_packets_.size());
+  EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 // Sequence number wrap occurs within the FEC packets for the frame.
@@ -238,7 +267,7 @@
 // received before the media packets. This may be improved if timing information
 // is used to detect old FEC packets.
 // TODO(marpan): Update test if wrap-around handling changes in FEC decoding.
-TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 200;
@@ -247,36 +276,40 @@
   // Sequence number wrap in FEC packets.
   //           -----Frame 1----
   // #65532(media) #65533(media) #65534(media) #65535(FEC) #0(FEC).
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65532);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(3, 65532);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 2 FEC packets.
-  EXPECT_EQ(2u, fec_packet_list_.size());
+  EXPECT_EQ(2u, this->generated_fec_packets_.size());
 
   // Lose the last two media packets (seq# 65533, 65534).
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[2] = 1;
-  ReceivedPackets(media_packet_list_, media_loss_mask_, false);
-  ReceivedPackets(fec_packet_list_, fec_loss_mask_, true);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // The two FEC packets are received and should allow for complete recovery,
   // but because of the wrap the second FEC packet will be discarded, and only
   // one media packet is recoverable. So exepct 2 media packets on recovered
   // list and no complete recovery.
-  EXPECT_EQ(2u, recovered_packet_list_.size());
-  EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size());
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_EQ(2u, this->recovered_packets_.size());
+  EXPECT_TRUE(this->recovered_packets_.size() != this->media_packets_.size());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 // Verify we can still recover frame if media packets are reordered.
-TEST_F(RtpFecTest, FecRecoveryWithMediaOutOfOrder) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithMediaOutOfOrder) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 20;
@@ -284,36 +317,39 @@
   // One frame: 3 media packets, 1 FEC packet.
   //         -----Frame 1----
   //  #0(media) #1(media) #2(media) #3(FEC).
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(3, 0);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // Lose one media packet (seq# 1).
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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_);
 
   // Reorder received media packets.
-  auto it0 = received_packet_list_.begin();
-  auto it2 = received_packet_list_.begin();
+  auto it0 = this->received_packets_.begin();
+  auto it2 = this->received_packets_.begin();
   it2++;
   std::swap(*it0, *it2);
 
-  EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Expect 3 media packets in recovered list, and complete recovery.
-  EXPECT_EQ(3u, recovered_packet_list_.size());
-  EXPECT_TRUE(IsRecoveryComplete());
+  EXPECT_EQ(3u, this->recovered_packets_.size());
+  EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
 // Verify we can still recover frame if FEC is received before media packets.
-TEST_F(RtpFecTest, FecRecoveryWithFecOutOfOrder) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithFecOutOfOrder) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr uint8_t kProtectionFactor = 20;
@@ -321,35 +357,39 @@
   // One frame: 3 media packets, 1 FEC packet.
   //         -----Frame 1----
   //  #0(media) #1(media) #2(media) #3(FEC).
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(3, 0);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // Lose one media packet (seq# 1).
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 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.
-  ReceivedPackets(fec_packet_list_, fec_loss_mask_, true);
+  this->ReceivedPackets(this->generated_fec_packets_, this->fec_loss_mask_,
+                        true);
   // Add media packets to received list.
-  ReceivedPackets(media_packet_list_, media_loss_mask_, false);
+  this->ReceivedPackets(this->media_packets_, this->media_loss_mask_, false);
 
-  EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Expect 3 media packets in recovered list, and complete recovery.
-  EXPECT_EQ(3u, recovered_packet_list_.size());
-  EXPECT_TRUE(IsRecoveryComplete());
+  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.
-TEST_F(RtpFecTest, FecRecoveryWithLoss50percRandomMask) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percRandomMask) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
@@ -365,49 +405,53 @@
   // fec#3:    0          1        0          1
   //
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskRandom, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskRandom, &this->generated_fec_packets_));
 
   // Expect 4 FEC packets.
-  EXPECT_EQ(4u, fec_packet_list_.size());
+  EXPECT_EQ(4u, this->generated_fec_packets_.size());
 
   // 4 packets lost: 3 media packets (0, 2, 3), and one FEC packet (0) lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  fec_loss_mask_[0] = 1;
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[2] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // With media packet#1 and FEC packets #1, #2, #3, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 4 consecutive packets lost: media packets 0, 1, 2, 3.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[2] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Cannot get complete recovery for this loss configuration with random mask.
-  EXPECT_FALSE(IsRecoveryComplete());
+  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.
-TEST_F(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
@@ -423,128 +467,140 @@
   // fec#3:    0          0        1          1
   //
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 4 FEC packets.
-  EXPECT_EQ(4u, fec_packet_list_.size());
+  EXPECT_EQ(4u, this->generated_fec_packets_.size());
 
   // 4 consecutive packets lost: media packets 0,1,2,3.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[2] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Expect complete recovery for consecutive packet loss <= 50%.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 4 consecutive packets lost: media packets 1,2, 3, and FEC packet 0.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  fec_loss_mask_[0] = 1;
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[2] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Expect complete recovery for consecutive packet loss <= 50%.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 4 packets lost (non-consecutive loss): media packets 0, 3, and FEC# 0, 3.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  fec_loss_mask_[0] = 1;
-  fec_loss_mask_[3] = 1;
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Cannot get complete recovery for this loss configuration.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
-TEST_F(RtpFecTest, FecRecoveryNoLossUep) {
+TYPED_TEST(RtpFecTest, FecRecoveryNoLossUep) {
   constexpr int kNumImportantPackets = 2;
   constexpr bool kUseUnequalProtection = true;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // No packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // No packets lost, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
+  EXPECT_TRUE(this->IsRecoveryComplete());
 }
 
-TEST_F(RtpFecTest, FecRecoveryWithLossUep) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithLossUep) {
   constexpr int kNumImportantPackets = 2;
   constexpr bool kUseUnequalProtection = true;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // 1 media packet lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // One packet lost, one FEC packet, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 2 media packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // 2 packets lost, one FEC packet, cannot get complete recovery.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
 // Test 50% protection with random mask type for UEP on.
-TEST_F(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) {
+TYPED_TEST(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) {
   constexpr int kNumImportantPackets = 1;
   constexpr bool kUseUnequalProtection = true;
   constexpr int kNumMediaPackets = 4;
@@ -560,241 +616,254 @@
   // fec#3:    0          1        1          0
   //
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskRandom, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskRandom, &this->generated_fec_packets_));
 
   // Expect 4 FEC packets.
-  EXPECT_EQ(4u, fec_packet_list_.size());
+  EXPECT_EQ(4u, this->generated_fec_packets_.size());
 
   // 4 packets lost: 3 media packets and FEC packet#1 lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  fec_loss_mask_[1] = 1;
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[2] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // With media packet#3 and FEC packets #0, #1, #3, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 5 packets lost: 4 media packets and one FEC packet#2 lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  fec_loss_mask_[2] = 1;
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[1] = 1;
-  media_loss_mask_[2] = 1;
-  media_loss_mask_[3] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Cannot get complete recovery for this loss configuration.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
-TEST_F(RtpFecTest, FecRecoveryNonConsecutivePackets) {
+TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePackets) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 5;
   constexpr uint8_t kProtectionFactor = 60;
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
   // Create a new temporary packet list for generating FEC packets.
   // This list should have every other packet removed.
-  PacketList protected_media_packets;
-  DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets);
+  ForwardErrorCorrection::PacketList protected_media_packets;
+  DeepCopyEveryNthPacket(this->media_packets_, 2, &protected_media_packets);
 
-  EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(protected_media_packets, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 1 FEC packet.
-  EXPECT_EQ(1u, fec_packet_list_.size());
+  EXPECT_EQ(1u, this->generated_fec_packets_.size());
 
   // 1 protected media packet lost
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[2] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // One packet lost, one FEC packet, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // Unprotected packet lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[1] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Unprotected packet lost. Recovery not possible.
-  EXPECT_FALSE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_FALSE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 2 media packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[0] = 1;
-  media_loss_mask_[2] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // 2 protected packets lost, one FEC packet, cannot get complete recovery.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
-TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) {
+TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 21;
   uint8_t kProtectionFactor = 127;
 
-  fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
+  this->media_packets_ =
+      this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
 
   // Create a new temporary packet list for generating FEC packets.
   // This list should have every other packet removed.
-  PacketList protected_media_packets;
-  DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets);
+  ForwardErrorCorrection::PacketList protected_media_packets;
+  DeepCopyEveryNthPacket(this->media_packets_, 2, &protected_media_packets);
 
   // Zero column insertion will have to extend the size of the packet
   // mask since the number of actual packets are 21, while the number
   // of protected packets are 11.
-  EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(protected_media_packets, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 5 FEC packet.
-  EXPECT_EQ(5u, fec_packet_list_.size());
+  EXPECT_EQ(5u, this->generated_fec_packets_.size());
 
   // Last protected media packet lost
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[kNumMediaPackets - 1] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // One packet lost, one FEC packet, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // Last unprotected packet lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[kNumMediaPackets - 2] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Unprotected packet lost. Recovery not possible.
-  EXPECT_FALSE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_FALSE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 6 media packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[kNumMediaPackets - 11] = 1;
-  media_loss_mask_[kNumMediaPackets - 9] = 1;
-  media_loss_mask_[kNumMediaPackets - 7] = 1;
-  media_loss_mask_[kNumMediaPackets - 5] = 1;
-  media_loss_mask_[kNumMediaPackets - 3] = 1;
-  media_loss_mask_[kNumMediaPackets - 1] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // 5 protected packets lost, one FEC packet, cannot get complete recovery.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
-TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) {
+TYPED_TEST(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 21;
   uint8_t kProtectionFactor = 127;
 
-  fec_seq_num_ = ConstructMediaPacketsSeqNum(kNumMediaPackets, 0xFFFF - 5);
+  this->media_packets_ = this->media_packet_generator_.ConstructMediaPackets(
+      kNumMediaPackets, 0xFFFF - 5);
 
   // Create a new temporary packet list for generating FEC packets.
   // This list should have every other packet removed.
-  PacketList protected_media_packets;
-  DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets);
+  ForwardErrorCorrection::PacketList protected_media_packets;
+  DeepCopyEveryNthPacket(this->media_packets_, 2, &protected_media_packets);
 
   // Zero column insertion will have to extend the size of the packet
   // mask since the number of actual packets are 21, while the number
   // of protected packets are 11.
-  EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor,
-                                kNumImportantPackets, kUseUnequalProtection,
-                                webrtc::kFecMaskBursty, &fec_packet_list_));
+  EXPECT_EQ(
+      0, this->fec_.EncodeFec(protected_media_packets, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &this->generated_fec_packets_));
 
   // Expect 5 FEC packet.
-  EXPECT_EQ(5u, fec_packet_list_.size());
+  EXPECT_EQ(5u, this->generated_fec_packets_.size());
 
   // Last protected media packet lost
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[kNumMediaPackets - 1] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // One packet lost, one FEC packet, expect complete recovery.
-  EXPECT_TRUE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_TRUE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // Last unprotected packet lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[kNumMediaPackets - 2] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // Unprotected packet lost. Recovery not possible.
-  EXPECT_FALSE(IsRecoveryComplete());
-  recovered_packet_list_.clear();
+  EXPECT_FALSE(this->IsRecoveryComplete());
+  this->recovered_packets_.clear();
 
   // 6 media packets lost.
-  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
-  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
-  media_loss_mask_[kNumMediaPackets - 11] = 1;
-  media_loss_mask_[kNumMediaPackets - 9] = 1;
-  media_loss_mask_[kNumMediaPackets - 7] = 1;
-  media_loss_mask_[kNumMediaPackets - 5] = 1;
-  media_loss_mask_[kNumMediaPackets - 3] = 1;
-  media_loss_mask_[kNumMediaPackets - 1] = 1;
-  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+  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, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_));
+  EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
+                                    &this->recovered_packets_));
 
   // 5 protected packets lost, one FEC packet, cannot get complete recovery.
-  EXPECT_FALSE(IsRecoveryComplete());
+  EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
-void RtpFecTest::TearDown() {
-  fec_.ResetState(&recovered_packet_list_);
-  recovered_packet_list_.clear();
-  media_packet_list_.clear();
-  EXPECT_TRUE(media_packet_list_.empty());
-}
-
-bool RtpFecTest::IsRecoveryComplete() {
+template <typename ForwardErrorCorrectionType>
+bool RtpFecTest<ForwardErrorCorrectionType>::IsRecoveryComplete() {
   // We must have equally many recovered packets as original packets.
-  if (recovered_packet_list_.size() != media_packet_list_.size()) {
+  if (recovered_packets_.size() != media_packets_.size()) {
     return false;
   }
 
@@ -815,21 +884,26 @@
     }
     return true;
   };
-  return std::equal(media_packet_list_.cbegin(), media_packet_list_.cend(),
-                    recovered_packet_list_.cbegin(), cmp);
+  return std::equal(media_packets_.cbegin(), media_packets_.cend(),
+                    recovered_packets_.cbegin(), cmp);
 }
 
-void RtpFecTest::NetworkReceivedPackets(int* media_loss_mask,
-                                        int* fec_loss_mask) {
+template <typename ForwardErrorCorrectionType>
+void RtpFecTest<ForwardErrorCorrectionType>::NetworkReceivedPackets(
+    int* media_loss_mask,
+    int* fec_loss_mask) {
   constexpr bool kFecPacket = true;
-  ReceivedPackets(media_packet_list_, media_loss_mask, !kFecPacket);
-  ReceivedPackets(fec_packet_list_, fec_loss_mask, kFecPacket);
+  ReceivedPackets(media_packets_, media_loss_mask, !kFecPacket);
+  ReceivedPackets(generated_fec_packets_, fec_loss_mask, kFecPacket);
 }
 
-template <typename T>
-void RtpFecTest::ReceivedPackets(const T& packet_list, int* loss_mask,
-                                 bool is_fec) {
-  int seq_num = fec_seq_num_;
+template <typename ForwardErrorCorrectionType>
+template <typename PacketListType>
+void RtpFecTest<ForwardErrorCorrectionType>::ReceivedPackets(
+    const PacketListType& packet_list,
+    int* loss_mask,
+    bool is_fec) {
+  uint16_t fec_seq_num = media_packet_generator_.GetFecSeqNum();
   int packet_idx = 0;
 
   for (const auto& packet : packet_list) {
@@ -844,91 +918,25 @@
         // For media packets, the sequence number and marker bit is
         // obtained from RTP header. These were set in ConstructMediaPackets().
         received_packet->seq_num =
-            webrtc::ByteReader<uint16_t>::ReadBigEndian(&packet->data[2]);
+            ByteReader<uint16_t>::ReadBigEndian(&packet->data[2]);
       } else {
         // The sequence number, marker bit, and ssrc number are defined in the
         // RTP header of the FEC packet, which is not constructed in this test.
         // So we set these values below based on the values generated in
         // ConstructMediaPackets().
-        received_packet->seq_num = seq_num;
+        received_packet->seq_num = fec_seq_num;
         // The ssrc value for FEC packets is set to the one used for the
         // media packets in ConstructMediaPackets().
-        received_packet->ssrc = ssrc_;
+        received_packet->ssrc = kMediaSsrc;
       }
-      received_packet_list_.push_back(std::move(received_packet));
+      received_packets_.push_back(std::move(received_packet));
     }
     packet_idx++;
     // Sequence number of FEC packets are defined as increment by 1 from
     // last media packet in frame.
-    if (is_fec) seq_num++;
+    if (is_fec)
+      fec_seq_num++;
   }
 }
 
-int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets,
-                                            int start_seq_num) {
-  RTC_DCHECK_GT(num_media_packets, 0);
-  int sequence_number = start_seq_num;
-  int time_stamp = random_.Rand<int>();
-
-  for (int i = 0; i < num_media_packets; ++i) {
-    std::unique_ptr<ForwardErrorCorrection::Packet> media_packet(
-        new ForwardErrorCorrection::Packet());
-    constexpr uint32_t kMinPacketSize = kRtpHeaderSize;
-    const uint32_t kMaxPacketSize = IP_PACKET_SIZE - kRtpHeaderSize -
-                                    kTransportOverhead -
-                                    fec_.MaxPacketOverhead();
-    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>();
-
-    // The first two bits are assumed to be 10 by the FEC encoder.
-    // In fact the FEC decoder will set the two first bits to 10 regardless of
-    // what they actually were. Set the first two bits to 10 so that a memcmp
-    // can be performed for the whole restored packet.
-    media_packet->data[0] |= 0x80;
-    media_packet->data[0] &= 0xbf;
-
-    // FEC is applied to a whole frame.
-    // A frame is signaled by multiple packets without the marker bit set
-    // followed by the last packet of the frame for which the marker bit is set.
-    // Only push one (fake) frame to the FEC.
-    media_packet->data[1] &= 0x7f;
-
-    webrtc::ByteWriter<uint16_t>::WriteBigEndian(&media_packet->data[2],
-                                                 sequence_number);
-    webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[4],
-                                                 time_stamp);
-    webrtc::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>();
-    }
-    sequence_number++;
-    media_packet_list_.push_back(std::move(media_packet));
-  }
-  // Last packet, set marker bit.
-  ForwardErrorCorrection::Packet* media_packet =
-      media_packet_list_.back().get();
-  RTC_DCHECK(media_packet);
-  media_packet->data[1] |= 0x80;
-  return sequence_number;
-}
-
-int RtpFecTest::ConstructMediaPackets(int num_media_packets) {
-  return ConstructMediaPacketsSeqNum(num_media_packets, random_.Rand<int>());
-}
-
-void RtpFecTest::DeepCopyEveryNthPacket(const PacketList& src, int n,
-                                        PacketList* dst) {
-  RTC_DCHECK_GT(n, 0);
-  int i = 0;
-  for (const auto& packet : src) {
-    if (i % n == 0) {
-      dst->emplace_back(new ForwardErrorCorrection::Packet(*packet));
-    }
-    ++i;
-  }
-}
+}  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
index bea52d7..be01038 100644
--- a/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
+++ b/webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc
@@ -277,14 +277,14 @@
             }
             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(0, fec.EncodeFec(media_packet_list, protection_factor,
+                                       num_imp_packets, kUseUnequalProtection,
+                                       fec_mask_type, &fec_packet_list))
+                << "EncodeFec() failed";
 
             ASSERT_EQ(num_fec_packets, fec_packet_list.size())
                 << "We requested " << num_fec_packets << " FEC packets, but "
-                << "GenerateFec() produced " << fec_packet_list.size();
+                << "EncodeFec() produced " << fec_packet_list.size();
 
             memset(media_loss_mask, 0, sizeof(media_loss_mask));
             uint32_t media_packet_idx = 0;
@@ -392,8 +392,8 @@
                   }
                 }
               }
-              ASSERT_EQ(0, fec.DecodeFec(&to_decode_list,
-                                         &recovered_packet_list))
+              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.";
diff --git a/webrtc/test/fuzzers/producer_fec_fuzzer.cc b/webrtc/test/fuzzers/producer_fec_fuzzer.cc
index 50a5e5e..3319138 100644
--- a/webrtc/test/fuzzers/producer_fec_fuzzer.cc
+++ b/webrtc/test/fuzzers/producer_fec_fuzzer.cc
@@ -17,6 +17,11 @@
 
 namespace webrtc {
 
+namespace {
+constexpr uint8_t kFecPayloadType = 96;
+constexpr uint8_t kRedPayloadType = 97;
+}  // namespace
+
 void FuzzOneInput(const uint8_t* data, size_t size) {
   ProducerFec producer;
   size_t i = 0;