Simplify public interface of ProducerFec.

webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 76 matching lines @@
     if (p.marker_bit) {
       packet[1] |= 0x80;
     } else {
       packet[1] &= ~0x80;
     }
     ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num);
     producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size, p.header_size);
     size_t num_fec_packets = producer_.NumAvailableFecPackets();
     if (num_fec_packets > 0) {
       std::vector<std::unique_ptr<RedPacket>> fec_packets =
-          producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
-                                       p.header_size);
+          producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
+                                          p.header_size);
       EXPECT_EQ(num_fec_packets, fec_packets.size());
     }
   }
 }
 
 TEST_F(ProducerFecTest, OneFrameFec) {
   // The number of media packets (|kNumPackets|), number of frames (one for
   // this test), and the protection factor (|params->fec_rate|) are set to make
   // sure the conditions for generating FEC are satisfied. This means:
   // (1) protection factor is high enough so that actual overhead over 1 frame
   // of packets is within |kMaxExcessOverhead|, and (2) the total number of
   // media packets for 1 frame is at least |minimum_media_packets_fec_|.
   constexpr size_t kNumPackets = 4;
   FecProtectionParams params = {15, 3, kFecMaskRandom};
   packet_generator_.NewFrame(kNumPackets);
   producer_.SetFecParameters(&params, 0);  // Expecting one FEC packet.
   uint32_t last_timestamp = 0;
   for (size_t i = 0; i < kNumPackets; ++i) {
     std::unique_ptr<AugmentedPacket> packet =
         packet_generator_.NextPacket(i, 10);
     EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
                      packet->data, packet->length, kRtpHeaderSize));
     last_timestamp = packet->header.header.timestamp;
   }
   EXPECT_TRUE(producer_.FecAvailable());
   uint16_t seq_num = packet_generator_.NextPacketSeqNum();
   std::vector<std::unique_ptr<RedPacket>> red_packets =
-      producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num,
-                                   kRtpHeaderSize);
+      producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num,
+                                      kRtpHeaderSize);
   EXPECT_FALSE(producer_.FecAvailable());
   ASSERT_EQ(1u, red_packets.size());
   VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
                red_packets.front().get(), false);
 }
 
 TEST_F(ProducerFecTest, TwoFrameFec) {
   // The number of media packets/frame (|kNumPackets|), the number of frames
   // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to
   // make sure the conditions for generating FEC are satisfied. This means:
@@ skipping 13 matching lines @@
       std::unique_ptr<AugmentedPacket> packet =
           packet_generator_.NextPacket(i * kNumPackets + j, 10);
       EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
                        packet->data, packet->length, kRtpHeaderSize));
       last_timestamp = packet->header.header.timestamp;
     }
   }
   EXPECT_TRUE(producer_.FecAvailable());
   uint16_t seq_num = packet_generator_.NextPacketSeqNum();
   std::vector<std::unique_ptr<RedPacket>> red_packets =
-      producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num,
-                                   kRtpHeaderSize);
+      producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num,
+                                      kRtpHeaderSize);
   EXPECT_FALSE(producer_.FecAvailable());
   ASSERT_EQ(1u, red_packets.size());
   VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
                red_packets.front().get(), false);
 }
 
 TEST_F(ProducerFecTest, BuildRedPacket) {
   packet_generator_.NewFrame(1);
   std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10);
   std::unique_ptr<RedPacket> red_packet =
@@ skipping 21 matching lines @@
       ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize,
                                   kRtpHeaderSize, kRedPayloadType);
   EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length());
   VerifyHeader(packet->header.header.sequenceNumber,
                packet->header.header.timestamp, kRedPayloadType,
                packet->header.header.payloadType, red_packet.get(),
                true);  // Marker bit set.
 }
 
 }  // namespace webrtc