Wire up FlexfecSender in RTPSender and add unit tests.

webrtc/modules/rtp_rtcp/source/rtp_sender_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 129 matching lines @@
         rtp_sender_(),
         payload_(kPayload),
         transport_(),
         kMarkerBit(true) {}
 
   void SetUp() override { SetUpRtpSender(true); }
 
   void SetUpRtpSender(bool pacer) {
     rtp_sender_.reset(new RTPSender(
         false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr,
-        &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
+        nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
         &mock_rtc_event_log_, &send_packet_observer_,
         &retransmission_rate_limiter_));
     rtp_sender_->SetSequenceNumber(kSeqNum);
     rtp_sender_->SetSendPayloadType(kPayload);
     rtp_sender_->SetTimestampOffset(0);
   }
 
   SimulatedClock fake_clock_;
   testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_;
   MockRtpPacketSender mock_paced_sender_;
@@ skipping 71 matching lines @@
  public:
   void SetUp() override { SetUpRtpSender(false); }
 };
 
 class RtpSenderVideoTest : public RtpSenderTest {
  protected:
   void SetUp() override {
     // TODO(pbos): Set up to use pacer.
     SetUpRtpSender(false);
     rtp_sender_video_.reset(
-        new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
+        new RTPSenderVideo(&fake_clock_, rtp_sender_.get(), nullptr));
   }
   std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
 };
 
 TEST_F(RtpSenderTestWithoutPacer,
        RegisterRtpTransmissionTimeOffsetHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
@@ skipping 180 matching lines @@
   ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   ASSERT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, -1));
 
   ASSERT_EQ(1u, transport_.sent_packets_.size());
   // Verify padding packet timestamp.
   EXPECT_EQ(kTimestamp, transport_.last_sent_packet().Timestamp());
 }
 
 TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, nullptr,
-      &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
-      &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_));
+      false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
+      &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &send_packet_observer_, &retransmission_rate_limiter_));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
       .WillOnce(testing::Return(kTransportSequenceNumber));
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
   EXPECT_CALL(feedback_observer_,
@@ skipping 22 matching lines @@
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
       .WillOnce(testing::Return(kTransportSequenceNumber));
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
 
   SendGenericPayload();
 }
 
 TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
-  rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, &mock_paced_sender_,
-      &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
-      &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_));
+  rtp_sender_.reset(
+      new RTPSender(false, &fake_clock_, &transport_, &mock_paced_sender_,
+                    nullptr, &seq_num_allocator_, &feedback_observer_, nullptr,
+                    nullptr, nullptr, &mock_rtc_event_log_,
+                    &send_packet_observer_, &retransmission_rate_limiter_));
   rtp_sender_->SetStorePacketsStatus(true, 10);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
   uint16_t seq_num = 0;
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
       .Times(1).WillRepeatedly(testing::SaveArg<2>(&seq_num));
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
       .WillOnce(testing::Return(kTransportSequenceNumber));
@@ skipping 257 matching lines @@
 
   SendGenericPayload();  // Packet passed to pacer.
   const bool kIsRetransmit = true;
   rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
                                 kIsRetransmit, PacketInfo::kNotAProbe);
   EXPECT_EQ(1, transport_.packets_sent());
 }
 
 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
   rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, &mock_paced_sender_,
+      false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
       nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
       nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetStorePacketsStatus(true, 10);
 
   EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1);
 
   SendGenericPayload();  // Packet passed to pacer.
   const bool kIsRetransmit = false;
   rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
                                 kIsRetransmit, PacketInfo::kNotAProbe);
   EXPECT_EQ(1, transport_.packets_sent());
 }
 
 TEST_F(RtpSenderTest, SendRedundantPayloads) {
   MockTransport transport;
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
-      nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
+      nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
       &retransmission_rate_limiter_));
 
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
 
   uint16_t seq_num = kSeqNum;
   rtp_sender_->SetStorePacketsStatus(true, 10);
   int32_t rtp_header_len = kRtpHeaderSize;
   EXPECT_EQ(
       0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
@@ skipping 88 matching lines @@
 
   EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
   EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
 
   ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
             transport_.last_sent_packet().payload_size());
 
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
 }
 
+TEST_F(RtpSenderTest, SendFlexfecPackets) {
+  constexpr int kMediaPayloadType = 127;
+  constexpr int kFlexfecPayloadType = 118;
+  constexpr uint32_t kMediaSsrc = 1234;
+  constexpr uint32_t kFlexfecSsrc = 5678;
+  const std::vector<RtpExtension> kNoRtpExtensions;
+  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
+                               kNoRtpExtensions, &fake_clock_);
+
+  // Reset |rtp_sender_| to use FlexFEC.
+  rtp_sender_.reset(
+      new RTPSender(false, &fake_clock_, &transport_, &mock_paced_sender_,
+                    &flexfec_sender, &seq_num_allocator_, nullptr, nullptr,
+                    nullptr, nullptr, &mock_rtc_event_log_,
+                    &send_packet_observer_, &retransmission_rate_limiter_));
+  rtp_sender_->SetSSRC(kMediaSsrc);
+  rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSendPayloadType(kMediaPayloadType);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+
+  // Parameters selected to generate a single FEC packet per media packet.
+  FecProtectionParams params;
+  params.fec_rate = 15;
+  params.max_fec_frames = 1;
+  params.fec_mask_type = kFecMaskRandom;
+  rtp_sender_->SetFecParameters(params, params);
+
+  uint16_t media_seq_num;
+  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
+                                               kMediaSsrc, _, _, _, false))
+      .WillOnce(testing::SaveArg<2>(&media_seq_num));

[danilchap, 2016/11/09 16:27:42]

shouldn't media_seq_num == kSeqNum? becuase of line
rtp_sender_->SetSequenceNumber(kSeqNum)
you can adjust EXPECT_CALL then (kSeqNum instead of 2nd _)

[brandtr, 2016/11/10 08:34:41]

Yep, that is the case. But in the followup CL, where I fix the pacer problem,
this way looks more symmetric :)

I will reconsider when I upload that CL.

+  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
+                                               kFlexfecSsrc, _, _, _, false));
+  SendGenericPayload();
+  // TODO(brandtr): Make these tests stricter when the FlexFEC packets are no
+  // longer lost between PacedSender and RTPSender.
+  EXPECT_CALL(mock_rtc_event_log_,
+              LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
+      .Times(testing::AtLeast(1));
+  EXPECT_TRUE(rtp_sender_->TimeToSendPacket(
+      media_seq_num, fake_clock_.TimeInMilliseconds(), false, 0));
+  EXPECT_LE(1, transport_.packets_sent());
+  const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
+  EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
+  EXPECT_EQ(media_seq_num, media_packet.SequenceNumber());
+  EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
+}
+
+TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
+  constexpr int kMediaPayloadType = 127;
+  constexpr int kFlexfecPayloadType = 118;
+  constexpr uint32_t kMediaSsrc = 1234;
+  constexpr uint32_t kFlexfecSsrc = 5678;
+  const std::vector<RtpExtension> kNoRtpExtensions;
+  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
+                               kNoRtpExtensions, &fake_clock_);
+
+  // Reset |rtp_sender_| to use FlexFEC.
+  rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
+                                  &flexfec_sender, &seq_num_allocator_, nullptr,
+                                  nullptr, nullptr, nullptr,
+                                  &mock_rtc_event_log_, &send_packet_observer_,
+                                  &retransmission_rate_limiter_));
+  rtp_sender_->SetSSRC(kMediaSsrc);
+  rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSendPayloadType(kMediaPayloadType);
+
+  // Parameters selected to generate a single FEC packet per media packet.
+  FecProtectionParams params;
+  params.fec_rate = 15;
+  params.max_fec_frames = 1;
+  params.fec_mask_type = kFecMaskRandom;
+  rtp_sender_->SetFecParameters(params, params);
+
+  EXPECT_CALL(mock_rtc_event_log_,
+              LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
+      .Times(2);
+  SendGenericPayload();
+  EXPECT_EQ(2, transport_.packets_sent());

[danilchap, 2016/11/09 16:27:42]

EXPECT_EQ -> ASSERT_EQ (to avoid crash if test will fail sending less packets)

[brandtr, 2016/11/10 08:34:41]

Done.

+  const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
+  EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
+  EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
+  const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
+  EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
+  EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
+}
+
 TEST_F(RtpSenderTest, FrameCountCallbacks) {
   class TestCallback : public FrameCountObserver {
    public:
     TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
     virtual ~TestCallback() {}
 
     void FrameCountUpdated(const FrameCounts& frame_counts,
                            uint32_t ssrc) override {
       ++num_calls_;
       ssrc_ = ssrc;
       frame_counts_ = frame_counts;
     }
 
     uint32_t num_calls_;
     uint32_t ssrc_;
     FrameCounts frame_counts_;
   } callback;
 
   rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_,
                                   &mock_paced_sender_, nullptr, nullptr,
-                                  nullptr, &callback, nullptr, nullptr, nullptr,
-                                  &retransmission_rate_limiter_));
+                                  nullptr, nullptr, &callback, nullptr, nullptr,
+                                  nullptr, &retransmission_rate_limiter_));
 
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
   rtp_sender_->SetStorePacketsStatus(true, 1);
   uint32_t ssrc = rtp_sender_->SSRC();
 
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
@@ skipping 38 matching lines @@
       ssrc_ = ssrc;
       total_bitrate_ = total_bitrate;
       retransmit_bitrate_ = retransmit_bitrate;
     }
 
     uint32_t num_calls_;
     uint32_t ssrc_;
     uint32_t total_bitrate_;
     uint32_t retransmit_bitrate_;
   } callback;
-  rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, &callback,
-      nullptr, nullptr, nullptr, nullptr, &retransmission_rate_limiter_));
+  rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
+                                  nullptr, nullptr, nullptr, &callback, nullptr,
+                                  nullptr, nullptr, nullptr,
+                                  &retransmission_rate_limiter_));
 
   // Simulate kNumPackets sent with kPacketInterval ms intervals, with the
   // number of packets selected so that we fill (but don't overflow) the one
   // second averaging window.
   const uint32_t kWindowSizeMs = 1000;
   const uint32_t kPacketInterval = 20;
   const uint32_t kNumPackets =
       (kWindowSizeMs - kPacketInterval) / kPacketInterval;
   // Overhead = 12 bytes RTP header + 1 byte generic header.
   const uint32_t kPacketOverhead = 13;
@@ skipping 34 matching lines @@
 
   rtp_sender_.reset();
 }
 
 class RtpSenderAudioTest : public RtpSenderTest {
  protected:
   RtpSenderAudioTest() {}
 
   void SetUp() override {
     payload_ = kAudioPayload;
-    rtp_sender_.reset(new RTPSender(
-        true, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
-        nullptr, nullptr, nullptr, nullptr, &retransmission_rate_limiter_));
+    rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr,
+                                    nullptr, nullptr, nullptr, nullptr, nullptr,
+                                    nullptr, nullptr, nullptr,
+                                    &retransmission_rate_limiter_));
     rtp_sender_->SetSequenceNumber(kSeqNum);
   }
 };
 
 TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
   class TestCallback : public StreamDataCountersCallback {
    public:
     TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {}
     virtual ~TestCallback() {}
 
@@ skipping 331 matching lines @@
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0));
   EXPECT_EQ(kVideoRotation_90,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1));
   EXPECT_EQ(kVideoRotation_180,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2));
   EXPECT_EQ(kVideoRotation_270,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
 }
 
 }  // namespace webrtc