| Index: webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
 | 
| diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
 | 
| index ea59dc1b4da2a3878028e758ca6754820a75c2d8..9f2f20b7b5f34c3af6590781aa3d427794bab46e 100644
 | 
| --- a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
 | 
| +++ b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
 | 
| @@ -22,8 +22,8 @@ namespace webrtc {
 | 
|  
 | 
|  void VerifyHeader(uint16_t seq_num,
 | 
|                    uint32_t timestamp,
 | 
| -                  int red_pltype,
 | 
| -                  int fec_pltype,
 | 
| +                  int red_payload_type,
 | 
| +                  int fec_payload_type,
 | 
|                    RedPacket* packet,
 | 
|                    bool marker_bit) {
 | 
|    EXPECT_GT(packet->length(), kRtpHeaderSize);
 | 
| @@ -31,30 +31,21 @@ void VerifyHeader(uint16_t seq_num,
 | 
|    uint8_t* data = packet->data();
 | 
|    // Marker bit not set.
 | 
|    EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80);
 | 
| -  EXPECT_EQ(red_pltype, data[1] & 0x7F);
 | 
| +  EXPECT_EQ(red_payload_type, data[1] & 0x7F);
 | 
|    EXPECT_EQ(seq_num, (data[2] << 8) + data[3]);
 | 
|    uint32_t parsed_timestamp = (data[4] << 24) + (data[5] << 16) +
 | 
|        (data[6] << 8) + data[7];
 | 
|    EXPECT_EQ(timestamp, parsed_timestamp);
 | 
| -  EXPECT_EQ(static_cast<uint8_t>(fec_pltype), data[kRtpHeaderSize]);
 | 
| +  EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]);
 | 
|  }
 | 
|  
 | 
|  class ProducerFecTest : public ::testing::Test {
 | 
|   protected:
 | 
| -  virtual void SetUp() {
 | 
| -    fec_ = new ForwardErrorCorrection();
 | 
| -    producer_ = new ProducerFec(fec_);
 | 
| -    generator_ = new FrameGenerator();
 | 
| -  }
 | 
| +  ProducerFecTest() : producer_(&fec_) {}
 | 
|  
 | 
| -  virtual void TearDown() {
 | 
| -    delete producer_;
 | 
| -    delete fec_;
 | 
| -    delete generator_;
 | 
| -  }
 | 
| -  ForwardErrorCorrection* fec_;
 | 
| -  ProducerFec* producer_;
 | 
| -  FrameGenerator* generator_;
 | 
| +  ForwardErrorCorrection fec_;
 | 
| +  ProducerFec producer_;
 | 
| +  FrameGenerator generator_;
 | 
|  };
 | 
|  
 | 
|  // Verifies bug found via fuzzing, where a gap in the packet sequence caused us
 | 
| @@ -80,7 +71,7 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
 | 
|    protected_packets.push_back({21, 0, 55, 0});
 | 
|    protected_packets.push_back({13, 3, 57, 1});
 | 
|    FecProtectionParams params = {117, 3, kFecMaskBursty};
 | 
| -  producer_->SetFecParameters(¶ms, 0);
 | 
| +  producer_.SetFecParameters(¶ms, 0);
 | 
|    uint8_t packet[28] = {0};
 | 
|    for (Packet p : protected_packets) {
 | 
|      if (p.marker_bit) {
 | 
| @@ -89,18 +80,17 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
 | 
|        packet[1] &= ~0x80;
 | 
|      }
 | 
|      ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num);
 | 
| -    producer_->AddRtpPacketAndGenerateFec(packet, p.payload_size,
 | 
| +    producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size,
 | 
|                                            p.header_size);
 | 
| -    uint16_t num_fec_packets = producer_->NumAvailableFecPackets();
 | 
| -    std::vector<RedPacket*> fec_packets;
 | 
| +    uint16_t num_fec_packets = producer_.NumAvailableFecPackets();
 | 
|      if (num_fec_packets > 0) {
 | 
| -      fec_packets =
 | 
| -          producer_->GetFecPackets(kRedPayloadType, 99, 100, p.header_size);
 | 
| +      std::vector<std::unique_ptr<RedPacket>> fec_packets =
 | 
| +          producer_.GetFecPacketsAsRed(kRedPayloadType,
 | 
| +                                        kFecPayloadType,
 | 
| +                                        100,
 | 
| +                                        p.header_size);
 | 
|        EXPECT_EQ(num_fec_packets, fec_packets.size());
 | 
|      }
 | 
| -    for (RedPacket* fec_packet : fec_packets) {
 | 
| -      delete fec_packet;
 | 
| -    }
 | 
|    }
 | 
|  }
 | 
|  
 | 
| @@ -114,32 +104,32 @@ TEST_F(ProducerFecTest, OneFrameFec) {
 | 
|    const int kNumPackets = 4;
 | 
|    FecProtectionParams params = {15, 3, kFecMaskRandom};
 | 
|    std::list<test::RawRtpPacket*> rtp_packets;
 | 
| -  generator_->NewFrame(kNumPackets);
 | 
| -  producer_->SetFecParameters(¶ms, 0);  // Expecting one FEC packet.
 | 
| +  generator_.NewFrame(kNumPackets);
 | 
| +  producer_.SetFecParameters(¶ms, 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);
 | 
| +    test::RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10);
 | 
|      rtp_packets.push_back(rtp_packet);
 | 
| -    EXPECT_EQ(0, producer_->AddRtpPacketAndGenerateFec(rtp_packet->data,
 | 
| +    EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(rtp_packet->data,
 | 
|                                                         rtp_packet->length,
 | 
|                                                         kRtpHeaderSize));
 | 
|      last_timestamp = rtp_packet->header.header.timestamp;
 | 
|    }
 | 
| -  EXPECT_TRUE(producer_->FecAvailable());
 | 
| -  uint16_t seq_num = generator_->NextSeqNum();
 | 
| -  std::vector<RedPacket*> packets = producer_->GetFecPackets(kRedPayloadType,
 | 
| -                                                             kFecPayloadType,
 | 
| -                                                             seq_num,
 | 
| -                                                             kRtpHeaderSize);
 | 
| -  EXPECT_FALSE(producer_->FecAvailable());
 | 
| +  EXPECT_TRUE(producer_.FecAvailable());
 | 
| +  uint16_t seq_num = generator_.NextSeqNum();
 | 
| +  std::vector<std::unique_ptr<RedPacket>> packets =
 | 
| +      producer_.GetFecPacketsAsRed(kRedPayloadType,
 | 
| +                                    kFecPayloadType,
 | 
| +                                    seq_num,
 | 
| +                                    kRtpHeaderSize);
 | 
| +  EXPECT_FALSE(producer_.FecAvailable());
 | 
|    ASSERT_EQ(1u, packets.size());
 | 
|    VerifyHeader(seq_num, last_timestamp,
 | 
| -               kRedPayloadType, kFecPayloadType, packets.front(), false);
 | 
| +               kRedPayloadType, kFecPayloadType, packets.front().get(), false);
 | 
|    while (!rtp_packets.empty()) {
 | 
|      delete rtp_packets.front();
 | 
|      rtp_packets.pop_front();
 | 
|    }
 | 
| -  delete packets.front();
 | 
|  }
 | 
|  
 | 
|  TEST_F(ProducerFecTest, TwoFrameFec) {
 | 
| @@ -155,43 +145,43 @@ TEST_F(ProducerFecTest, TwoFrameFec) {
 | 
|  
 | 
|    FecProtectionParams params = {15, 3, kFecMaskRandom};
 | 
|    std::list<test::RawRtpPacket*> rtp_packets;
 | 
| -  producer_->SetFecParameters(¶ms, 0);  // Expecting one FEC packet.
 | 
| +  producer_.SetFecParameters(¶ms, 0);  // Expecting one FEC packet.
 | 
|    uint32_t last_timestamp = 0;
 | 
|    for (int i = 0; i < kNumFrames; ++i) {
 | 
| -    generator_->NewFrame(kNumPackets);
 | 
| +    generator_.NewFrame(kNumPackets);
 | 
|      for (int j = 0; j < kNumPackets; ++j) {
 | 
|        test::RawRtpPacket* rtp_packet =
 | 
| -          generator_->NextPacket(i * kNumPackets + j, 10);
 | 
| +          generator_.NextPacket(i * kNumPackets + j, 10);
 | 
|        rtp_packets.push_back(rtp_packet);
 | 
| -      EXPECT_EQ(0, producer_->AddRtpPacketAndGenerateFec(rtp_packet->data,
 | 
| +      EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(rtp_packet->data,
 | 
|                                             rtp_packet->length,
 | 
|                                             kRtpHeaderSize));
 | 
|        last_timestamp = rtp_packet->header.header.timestamp;
 | 
|      }
 | 
|    }
 | 
| -  EXPECT_TRUE(producer_->FecAvailable());
 | 
| -  uint16_t seq_num = generator_->NextSeqNum();
 | 
| -  std::vector<RedPacket*> packets = producer_->GetFecPackets(kRedPayloadType,
 | 
| -                                                             kFecPayloadType,
 | 
| -                                                             seq_num,
 | 
| -                                                             kRtpHeaderSize);
 | 
| -  EXPECT_FALSE(producer_->FecAvailable());
 | 
| +  EXPECT_TRUE(producer_.FecAvailable());
 | 
| +  uint16_t seq_num = generator_.NextSeqNum();
 | 
| +  std::vector<std::unique_ptr<RedPacket>> packets =
 | 
| +      producer_.GetFecPacketsAsRed(kRedPayloadType,
 | 
| +                                    kFecPayloadType,
 | 
| +                                    seq_num,
 | 
| +                                    kRtpHeaderSize);
 | 
| +  EXPECT_FALSE(producer_.FecAvailable());
 | 
|    ASSERT_EQ(1u, packets.size());
 | 
|    VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
 | 
| -               packets.front(), false);
 | 
| +               packets.front().get(), false);
 | 
|    while (!rtp_packets.empty()) {
 | 
|      delete rtp_packets.front();
 | 
|      rtp_packets.pop_front();
 | 
|    }
 | 
| -  delete packets.front();
 | 
|  }
 | 
|  
 | 
|  TEST_F(ProducerFecTest, BuildRedPacket) {
 | 
| -  generator_->NewFrame(1);
 | 
| -  test::RawRtpPacket* packet = generator_->NextPacket(0, 10);
 | 
| -  std::unique_ptr<RedPacket> red_packet(producer_->BuildRedPacket(
 | 
| +  generator_.NewFrame(1);
 | 
| +  test::RawRtpPacket* packet = generator_.NextPacket(0, 10);
 | 
| +  std::unique_ptr<RedPacket> red_packet = ProducerFec::BuildRedPacket(
 | 
|        packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize,
 | 
| -      kRedPayloadType));
 | 
| +      kRedPayloadType);
 | 
|    EXPECT_EQ(packet->length + 1, red_packet->length());
 | 
|    VerifyHeader(packet->header.header.sequenceNumber,
 | 
|                 packet->header.header.timestamp,
 | 
| 
 |