Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/source/fec_receiver_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 21 matching lines @@
 using ::testing::Args;
 using ::testing::ElementsAreArray;
 using ::testing::Return;
 
 using ::webrtc::test::fec::FrameGenerator;
 using Packet = ::webrtc::ForwardErrorCorrection::Packet;
 using ::webrtc::test::fec::RawRtpPacket;
 
 class ReceiverFecTest : public ::testing::Test {
  protected:
-  ReceiverFecTest() : receiver_fec_(FecReceiver::Create(&rtp_data_callback_)) {}
+  ReceiverFecTest()
+      : fec_(ForwardErrorCorrection::CreateUlpfec()),
+        receiver_fec_(FecReceiver::Create(&rtp_data_callback_)) {}
 
   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_.EncodeFec(*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<RawRtpPacket*>* media_rtp_packets,
                      ForwardErrorCorrection::PacketList* media_packets) {
     generator_.NewFrame(num_media_packets);
     for (int i = 0; i < num_media_packets; ++i) {
       std::unique_ptr<RawRtpPacket> next_packet(
@@ skipping 28 matching lines @@
                      red_packet->header.header, red_packet->data,
                      red_packet->length, kFecPayloadType));
   }
 
   void InjectGarbagePacketLength(size_t fec_garbage_offset);
   static void SurvivesMaliciousPacket(const uint8_t* data,
                                       size_t length,
                                       uint8_t ulpfec_payload_type);
 
   MockRtpData rtp_data_callback_;
-  ForwardErrorCorrection fec_;
+  std::unique_ptr<ForwardErrorCorrection> fec_;
   std::unique_ptr<FecReceiver> receiver_fec_;
   FrameGenerator generator_;
 };
 
 TEST_F(ReceiverFecTest, TwoMediaOneFec) {
   const unsigned int kNumFecPackets = 1u;
   std::list<RawRtpPacket*> media_rtp_packets;
   ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
@@ skipping 144 matching lines @@
 
 TEST_F(ReceiverFecTest, TooManyFrames) {
   const unsigned int kNumFecPackets = 1u;
   const unsigned int kNumMediaPackets = 49u;
   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_.EncodeFec(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) {
   // 1 frame with 2 media packets and one FEC packet. One media packet missing.
   // Delay the FEC packet.
   Packet* delayed_fec = NULL;
   const unsigned int kNumFecPacketsBatch1 = 1u;
   const unsigned int kNumMediaPacketsBatch1 = 2u;
   std::list<RawRtpPacket*> media_rtp_packets_batch1;
   ForwardErrorCorrection::PacketList media_packets_batch1;
@@ skipping 230 matching lines @@
                              0x27,
                              0xc4,
                              0x2a,
                              0x21,
                              0x2a,
                              0x28};
   SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100);
 }
 
 }  // namespace webrtc