Style updates for ForwardErrorCorrection and related classes

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 20 matching lines @@
 namespace webrtc {
 
 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());
   }
 
-  void GenerateFEC(std::list<Packet*>* media_packets,
-                   std::list<Packet*>* fec_packets,
+  void GenerateFec(ForwardErrorCorrection::PacketList* media_packets,
+                   ForwardErrorCorrection::PacketList* 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,
+    EXPECT_EQ(0, fec_->GenerateFec(*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<Packet*>* media_packets) {
+                     ForwardErrorCorrection::PacketList* media_packets) {
     generator_->NewFrame(num_media_packets);
     for (int i = 0; i < num_media_packets; ++i) {
       media_rtp_packets->push_back(
           generator_->NextPacket(frame_offset + i, kRtpHeaderSize + 10));
       media_packets->push_back(media_rtp_packets->back());
     }
   }
 
   void VerifyReconstructedMediaPacket(const test::RawRtpPacket* packet,
                                       int times) {
@@ skipping 26 matching lines @@
   static void SurvivesMaliciousPacket(const uint8_t* data,
                                       size_t length,
                                       uint8_t ulpfec_payload_type);
 
   MockRtpData rtp_data_callback_;
   std::unique_ptr<ForwardErrorCorrection> fec_;
   std::unique_ptr<FecReceiver> receiver_fec_;
   std::unique_ptr<FrameGenerator> generator_;
 };
 
-void DeletePackets(std::list<Packet*>* packets) {
+void DeletePackets(ForwardErrorCorrection::PacketList* packets) {
   while (!packets->empty()) {
     delete packets->front();
     packets->pop_front();
   }
 }
 
 TEST_F(ReceiverFecTest, TwoMediaOneFec) {
   const unsigned int kNumFecPackets = 1u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
-  std::list<test::RawRtpPacket*>::iterator it = media_rtp_packets.begin();
+  auto it = media_rtp_packets.begin();
   BuildAndAddRedMediaPacket(*it);
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   // Drop one media packet.
-  std::list<Packet*>::iterator fec_it = fec_packets.begin();
+  auto fec_it = fec_packets.begin();
   BuildAndAddRedFecPacket(*fec_it);
   ++it;
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   FecPacketCounter counter = receiver_fec_->GetPacketCounter();
   EXPECT_EQ(2U, counter.num_packets);
   EXPECT_EQ(1U, counter.num_fec_packets);
   EXPECT_EQ(1U, counter.num_recovered_packets);
 
   DeletePackets(&media_packets);
 }
 
 void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) {
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .WillRepeatedly(Return(true));
 
   const unsigned int kNumFecPackets = 1u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
   ByteWriter<uint16_t>::WriteBigEndian(
       &fec_packets.front()->data[fec_garbage_offset], 0x4711);
 
   // Inject first media packet, then first FEC packet, skipping the second media
   // packet to cause a recovery from the FEC packet.
   BuildAndAddRedMediaPacket(media_rtp_packets.front());
   BuildAndAddRedFecPacket(fec_packets.front());
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   FecPacketCounter counter = receiver_fec_->GetPacketCounter();
@@ skipping 11 matching lines @@
 
 TEST_F(ReceiverFecTest, InjectGarbageFecLevelHeaderProtectionLength) {
   // Byte offset 10 is the 'protection length' field in the first FEC level
   // header.
   InjectGarbagePacketLength(10);
 }
 
 TEST_F(ReceiverFecTest, TwoMediaTwoFec) {
   const unsigned int kNumFecPackets = 2u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
   // Drop both media packets.
-  std::list<test::RawRtpPacket*>::iterator it = media_rtp_packets.begin();
-  std::list<Packet*>::iterator fec_it = fec_packets.begin();
+  auto it = media_rtp_packets.begin();
+  auto fec_it = fec_packets.begin();
   BuildAndAddRedFecPacket(*fec_it);
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   ++fec_it;
   BuildAndAddRedFecPacket(*fec_it);
   ++it;
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   DeletePackets(&media_packets);
 }
 
 TEST_F(ReceiverFecTest, TwoFramesOneFec) {
   const unsigned int kNumFecPackets = 1u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
   GenerateFrame(1, 1, &media_rtp_packets, &media_packets);
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
-  std::list<test::RawRtpPacket*>::iterator it = media_rtp_packets.begin();
+  auto it = media_rtp_packets.begin();
   BuildAndAddRedMediaPacket(media_rtp_packets.front());
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   // Drop one media packet.
   BuildAndAddRedFecPacket(fec_packets.front());
   ++it;
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   DeletePackets(&media_packets);
 }
 
 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) {
   const unsigned int kNumFecPackets = 1u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
   GenerateFrame(2, 1, &media_rtp_packets, &media_packets);
 
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
-  std::list<test::RawRtpPacket*>::iterator it = media_rtp_packets.begin();
+  auto it = media_rtp_packets.begin();
   BuildAndAddRedMediaPacket(*it);  // First frame: one packet.
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   ++it;
   BuildAndAddRedMediaPacket(*it);  // First packet of second frame.
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   DeletePackets(&media_packets);
 }
 
 TEST_F(ReceiverFecTest, MaxFramesOneFec) {
   const unsigned int kNumFecPackets = 1u;
   const unsigned int kNumMediaPackets = 48u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
     GenerateFrame(1, i, &media_rtp_packets, &media_packets);
   }
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets, &fec_packets, kNumFecPackets);
 
   // Recovery
-  std::list<test::RawRtpPacket*>::iterator it = media_rtp_packets.begin();
+  auto it = media_rtp_packets.begin();
   ++it;  // Drop first packet.
   for (; it != media_rtp_packets.end(); ++it) {
     BuildAndAddRedMediaPacket(*it);
     VerifyReconstructedMediaPacket(*it, 1);
     EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   }
   BuildAndAddRedFecPacket(fec_packets.front());
   it = media_rtp_packets.begin();
   VerifyReconstructedMediaPacket(*it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   DeletePackets(&media_packets);
 }
 
 TEST_F(ReceiverFecTest, TooManyFrames) {
   const unsigned int kNumFecPackets = 1u;
   const unsigned int kNumMediaPackets = 49u;
   std::list<test::RawRtpPacket*> media_rtp_packets;
-  std::list<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
     GenerateFrame(1, i, &media_rtp_packets, &media_packets);
   }
-  std::list<Packet*> fec_packets;
-  EXPECT_EQ(-1, fec_->GenerateFEC(media_packets,
+  ForwardErrorCorrection::PacketList fec_packets;
+  EXPECT_EQ(-1, fec_->GenerateFec(media_packets,
                                   kNumFecPackets * 255 / kNumMediaPackets, 0,
                                   false, kFecMaskBursty, &fec_packets));
 
   DeletePackets(&media_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<test::RawRtpPacket*> media_rtp_packets_batch1;
-  std::list<Packet*> media_packets_batch1;
+  ForwardErrorCorrection::PacketList media_packets_batch1;
   GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
                 &media_packets_batch1);
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
 
   BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   delayed_fec = fec_packets.front();
 
   // Fill the FEC decoder. No packets should be dropped.
   const unsigned int kNumMediaPacketsBatch2 = 46u;
   std::list<test::RawRtpPacket*> media_rtp_packets_batch2;
-  std::list<Packet*> media_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);
   }
-  for (std::list<test::RawRtpPacket*>::iterator it =
-           media_rtp_packets_batch2.begin();
+  for (auto it = media_rtp_packets_batch2.begin();
        it != media_rtp_packets_batch2.end(); ++it) {
     BuildAndAddRedMediaPacket(*it);
     EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
         .Times(1).WillRepeatedly(Return(true));
     EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   }
 
   // Add the delayed FEC packet. One packet should be reconstructed.
   BuildAndAddRedFecPacket(delayed_fec);
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   DeletePackets(&media_packets_batch1);
   DeletePackets(&media_packets_batch2);
 }
 
 TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) {
   // 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<test::RawRtpPacket*> media_rtp_packets_batch1;
-  std::list<Packet*> media_packets_batch1;
+  ForwardErrorCorrection::PacketList media_packets_batch1;
   GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
                 &media_packets_batch1);
-  std::list<Packet*> fec_packets;
-  GenerateFEC(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
+  ForwardErrorCorrection::PacketList fec_packets;
+  GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
 
   BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   delayed_fec = fec_packets.front();
 
   // 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<Packet*> media_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);
   }
-  for (std::list<test::RawRtpPacket*>::iterator it =
-           media_rtp_packets_batch2.begin();
+  for (auto it = media_rtp_packets_batch2.begin();
        it != media_rtp_packets_batch2.end(); ++it) {
     BuildAndAddRedMediaPacket(*it);
     EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
         .Times(1).WillRepeatedly(Return(true));
     EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   }
 
   // Add the delayed FEC packet. No packet should be reconstructed since the
   // first media packet of that frame has been dropped due to being too old.
   BuildAndAddRedFecPacket(delayed_fec);
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .Times(0);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 
   DeletePackets(&media_packets_batch1);
   DeletePackets(&media_packets_batch2);
 }
 
 TEST_F(ReceiverFecTest, OldFecPacketDropped) {
   // 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<Packet*> media_packets;
+  ForwardErrorCorrection::PacketList media_packets;
   for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) {
     std::list<test::RawRtpPacket*> frame_media_rtp_packets;
-    std::list<Packet*> frame_media_packets;
-    std::list<Packet*> fec_packets;
+    ForwardErrorCorrection::PacketList frame_media_packets;
+    ForwardErrorCorrection::PacketList fec_packets;
     GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets);
-    GenerateFEC(&frame_media_packets, &fec_packets, 1);
-    for (std::list<Packet*>::iterator it = fec_packets.begin();
-         it != fec_packets.end(); ++it) {
+    GenerateFec(&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);
       EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
           .Times(0);
       EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
     }
     media_packets.insert(media_packets.end(), frame_media_packets.begin(),
                          frame_media_packets.end());
     media_rtp_packets.insert(media_rtp_packets.end(),
                              frame_media_rtp_packets.begin(),
@@ skipping 132 matching lines @@
                              0x27,
                              0xc4,
                              0x2a,
                              0x21,
                              0x2a,
                              0x28};
   SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100);
 }
 
 }  // namespace webrtc