Generalize UlpfecPacketGenerator into AugmentedPacketGenerator. (pt. 8)

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.
  */
 
 #include <string.h>
 
 #include <list>
 #include <memory>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/rtp_rtcp/include/fec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.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"
 
 namespace webrtc {
 
 namespace {
 using ::testing::_;

[philipel, 2016/09/23 11:52:14]

Using should be outside the anonymous namespace.

[danilchap, 2016/09/23 12:41:47]

why? I have strong reason to believe it should be inside. 

[philipel, 2016/09/23 13:14:41]

Just looking through the codebase I can't find any other place where using
statements are inside an anonymous namespace, but maybe there is a good reason
to have them inside the namespace?

[philipel, 2016/09/23 14:47:09]

After some offline discussion with Danil I now think the using statements should
stay inside the anonymous namespace. :)

 using ::testing::Args;
 using ::testing::ElementsAreArray;
 using ::testing::Return;
 
+using test::fec::AugmentedPacket;
 using Packet = ForwardErrorCorrection::Packet;
-using test::fec::RawRtpPacket;
 using test::fec::UlpfecPacketGenerator;
 
 constexpr int kFecPayloadType = 96;
+constexpr uint32_t kMediaSsrc = 835424;
 }  // namespace
 
 class ReceiverFecTest : public ::testing::Test {
  protected:
   ReceiverFecTest()
       : fec_(ForwardErrorCorrection::CreateUlpfec()),
-        receiver_fec_(FecReceiver::Create(&rtp_data_callback_)) {}
+        receiver_fec_(FecReceiver::Create(&rtp_data_callback_)),
+        packet_generator_(kMediaSsrc) {}
 
   void EncodeFec(const ForwardErrorCorrection::PacketList& media_packets,
                  size_t num_fec_packets,
                  std::list<ForwardErrorCorrection::Packet*>* 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));
     ASSERT_EQ(num_fec_packets, fec_packets->size());
   }
 
   void GenerateFrame(size_t num_media_packets,
                      size_t frame_offset,
-                     std::list<RawRtpPacket*>* media_rtp_packets,
+                     std::list<AugmentedPacket*>* augmented_packets,
                      ForwardErrorCorrection::PacketList* media_packets) {
-    generator_.NewFrame(num_media_packets);
+    packet_generator_.NewFrame(num_media_packets);
     for (size_t i = 0; i < num_media_packets; ++i) {
-      std::unique_ptr<RawRtpPacket> next_packet(
-          generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10));
-      media_rtp_packets->push_back(next_packet.get());
+      std::unique_ptr<AugmentedPacket> next_packet(
+          packet_generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10));
+      augmented_packets->push_back(next_packet.get());
       media_packets->push_back(std::move(next_packet));
     }
   }
 
-  void VerifyReconstructedMediaPacket(const RawRtpPacket& packet,
+  void VerifyReconstructedMediaPacket(const AugmentedPacket& packet,
                                       size_t 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.
     EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet.length))
         .With(Args<0, 1>(ElementsAreArray(packet.data, packet.length)))
         .Times(times)
         .WillRepeatedly(Return(true));
   }
 
-  void BuildAndAddRedMediaPacket(RawRtpPacket* packet) {
-    std::unique_ptr<RawRtpPacket> red_packet(
-        generator_.BuildMediaRedPacket(packet));
+  void BuildAndAddRedMediaPacket(AugmentedPacket* packet) {
+    std::unique_ptr<AugmentedPacket> red_packet(
+        UlpfecPacketGenerator::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<RawRtpPacket> red_packet(
-        generator_.BuildFecRedPacket(packet));
+    std::unique_ptr<AugmentedPacket> red_packet(
+        packet_generator_.BuildUlpfecRedPacket(*packet));
     EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
                      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_;
   std::unique_ptr<ForwardErrorCorrection> fec_;
   std::unique_ptr<FecReceiver> receiver_fec_;
-  UlpfecPacketGenerator generator_;
+  UlpfecPacketGenerator packet_generator_;
 };
 
 TEST_F(ReceiverFecTest, TwoMediaOneFec) {
   const size_t kNumFecPackets = 1;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
-  GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
+  GenerateFrame(2, 0, &augmented_media_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets, kNumFecPackets, &fec_packets);
 
   // Recovery
-  auto it = media_rtp_packets.begin();
+  auto it = augmented_media_packets.begin();
   BuildAndAddRedMediaPacket(*it);
   VerifyReconstructedMediaPacket(**it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   // Drop one media packet.
   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);
 }
 
 void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) {
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .WillRepeatedly(Return(true));
 
   const size_t kNumFecPackets = 1;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
-  GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
+  GenerateFrame(2, 0, &augmented_media_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets, kNumFecPackets, &fec_packets);
   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());
+  BuildAndAddRedMediaPacket(augmented_media_packets.front());
   BuildAndAddRedFecPacket(fec_packets.front());
   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(0U, counter.num_recovered_packets);
 }
 
 TEST_F(ReceiverFecTest, InjectGarbageFecHeaderLengthRecovery) {
   // Byte offset 8 is the 'length recovery' field of the FEC header.
   InjectGarbagePacketLength(8);
 }
 
 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 size_t kNumFecPackets = 2;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
-  GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
+  GenerateFrame(2, 0, &augmented_media_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets, kNumFecPackets, &fec_packets);
 
   // Recovery
   // Drop both media packets.
-  auto it = media_rtp_packets.begin();
+  auto it = augmented_media_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());
 }
 
 TEST_F(ReceiverFecTest, TwoFramesOneFec) {
   const size_t kNumFecPackets = 1;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
-  GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
-  GenerateFrame(1, 1, &media_rtp_packets, &media_packets);
+  GenerateFrame(1, 0, &augmented_media_packets, &media_packets);
+  GenerateFrame(1, 1, &augmented_media_packets, &media_packets);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets, kNumFecPackets, &fec_packets);
 
   // Recovery
-  auto it = media_rtp_packets.begin();
-  BuildAndAddRedMediaPacket(media_rtp_packets.front());
+  auto it = augmented_media_packets.begin();
+  BuildAndAddRedMediaPacket(augmented_media_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());
 }
 
 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) {
   const size_t kNumFecPackets = 1;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
-  GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
-  GenerateFrame(2, 1, &media_rtp_packets, &media_packets);
+  GenerateFrame(1, 0, &augmented_media_packets, &media_packets);
+  GenerateFrame(2, 1, &augmented_media_packets, &media_packets);
 
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets, kNumFecPackets, &fec_packets);
 
   // Recovery
-  auto it = media_rtp_packets.begin();
+  auto it = augmented_media_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());
 }
 
 TEST_F(ReceiverFecTest, MaxFramesOneFec) {
   const size_t kNumFecPackets = 1;
   const size_t kNumMediaPackets = 48;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
   for (size_t i = 0; i < kNumMediaPackets; ++i) {
-    GenerateFrame(1, i, &media_rtp_packets, &media_packets);
+    GenerateFrame(1, i, &augmented_media_packets, &media_packets);
   }
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets, kNumFecPackets, &fec_packets);
 
   // Recovery
-  auto it = media_rtp_packets.begin();
+  auto it = augmented_media_packets.begin();
   ++it;  // Drop first packet.
-  for (; it != media_rtp_packets.end(); ++it) {
+  for (; it != augmented_media_packets.end(); ++it) {
     BuildAndAddRedMediaPacket(*it);
     VerifyReconstructedMediaPacket(**it, 1);
     EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
   }
   BuildAndAddRedFecPacket(fec_packets.front());
-  it = media_rtp_packets.begin();
+  it = augmented_media_packets.begin();
   VerifyReconstructedMediaPacket(**it, 1);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 }
 
 TEST_F(ReceiverFecTest, TooManyFrames) {
   const size_t kNumFecPackets = 1;
   const size_t kNumMediaPackets = 49;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
   for (size_t i = 0; i < kNumMediaPackets; ++i) {
-    GenerateFrame(1, i, &media_rtp_packets, &media_packets);
+    GenerateFrame(1, i, &augmented_media_packets, &media_packets);
   }
   std::list<ForwardErrorCorrection::Packet*> 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 = nullptr;
   const size_t kNumFecPacketsBatch1 = 1;
   const size_t kNumMediaPacketsBatch1 = 2;
-  std::list<RawRtpPacket*> media_rtp_packets_batch1;
+  std::list<AugmentedPacket*> augmented_media_packets_batch1;
   ForwardErrorCorrection::PacketList media_packets_batch1;
-  GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
+  GenerateFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1,
                 &media_packets_batch1);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets);
 
-  BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
+  BuildAndAddRedMediaPacket(augmented_media_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 size_t kNumMediaPacketsBatch2 = 46;
-  std::list<RawRtpPacket*> media_rtp_packets_batch2;
+  std::list<AugmentedPacket*> augmented_media_packets_batch2;
   ForwardErrorCorrection::PacketList media_packets_batch2;
   for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) {
-    GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
+    GenerateFrame(1, i, &augmented_media_packets_batch2, &media_packets_batch2);
   }
-  for (auto it = media_rtp_packets_batch2.begin();
-       it != media_rtp_packets_batch2.end(); ++it) {
+  for (auto it = augmented_media_packets_batch2.begin();
+       it != augmented_media_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());
 }
 
 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 = nullptr;
   const size_t kNumFecPacketsBatch1 = 1;
   const size_t kNumMediaPacketsBatch1 = 2;
-  std::list<RawRtpPacket*> media_rtp_packets_batch1;
+  std::list<AugmentedPacket*> augmented_media_packets_batch1;
   ForwardErrorCorrection::PacketList media_packets_batch1;
-  GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
+  GenerateFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1,
                 &media_packets_batch1);
   std::list<ForwardErrorCorrection::Packet*> fec_packets;
   EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets);
 
-  BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
+  BuildAndAddRedMediaPacket(augmented_media_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 size_t kNumMediaPacketsBatch2 = 48;
-  std::list<RawRtpPacket*> media_rtp_packets_batch2;
+  std::list<AugmentedPacket*> augmented_media_packets_batch2;
   ForwardErrorCorrection::PacketList media_packets_batch2;
   for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) {
-    GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
+    GenerateFrame(1, i, &augmented_media_packets_batch2, &media_packets_batch2);
   }
-  for (auto it = media_rtp_packets_batch2.begin();
-       it != media_rtp_packets_batch2.end(); ++it) {
+  for (auto it = augmented_media_packets_batch2.begin();
+       it != augmented_media_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());
 }
 
 TEST_F(ReceiverFecTest, OldFecPacketDropped) {
   // 49 frames with 2 media packets and one FEC packet. All media packets
   // missing.
   const size_t kNumMediaPackets = 49 * 2;
-  std::list<RawRtpPacket*> media_rtp_packets;
+  std::list<AugmentedPacket*> augmented_media_packets;
   ForwardErrorCorrection::PacketList media_packets;
   for (size_t i = 0; i < kNumMediaPackets / 2; ++i) {
-    std::list<RawRtpPacket*> frame_media_rtp_packets;
+    std::list<AugmentedPacket*> frame_augmented_media_packets;
     ForwardErrorCorrection::PacketList frame_media_packets;
     std::list<ForwardErrorCorrection::Packet*> fec_packets;
-    GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets);
+    GenerateFrame(2, 0, &frame_augmented_media_packets, &frame_media_packets);
     EncodeFec(frame_media_packets, 1, &fec_packets);
     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());
     }
     // Move unique_ptr's to media_packets for lifetime management.
     media_packets.insert(media_packets.end(),
                          std::make_move_iterator(frame_media_packets.begin()),
                          std::make_move_iterator(frame_media_packets.end()));
-    media_rtp_packets.insert(media_rtp_packets.end(),
-                             frame_media_rtp_packets.begin(),
-                             frame_media_rtp_packets.end());
+    augmented_media_packets.insert(augmented_media_packets.end(),
+                                   frame_augmented_media_packets.begin(),
+                                   frame_augmented_media_packets.end());
   }
   // Insert the oldest media packet. The corresponding FEC packet is too old
   // and should have been dropped. Only the media packet we inserted will be
   // returned.
-  BuildAndAddRedMediaPacket(media_rtp_packets.front());
+  BuildAndAddRedMediaPacket(augmented_media_packets.front());
   EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
 }
 
 void ReceiverFecTest::SurvivesMaliciousPacket(const uint8_t* data,
                                               size_t length,
                                               uint8_t ulpfec_payload_type) {
   webrtc::RTPHeader header;
   std::unique_ptr<webrtc::RtpHeaderParser> parser(
@@ skipping 114 matching lines @@
                              0x27,
                              0xc4,
                              0x2a,
                              0x21,
                              0x2a,
                              0x28};
   SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100);
 }
 
 }  // namespace webrtc