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 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(kPayload);
+  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);
+
+  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
+                                               kMediaSsrc, _, _, _, false));
+  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
+                                               kFlexfecSsrc, _, _, _, false));
+  SendGenericPayload();
+  // TODO(brandtr): Update this code when the FlexFEC packets are no longer
+  // lost between PacedSender and RTPSender.
+  constexpr int kNumPacketsExpected = 1;

[danilchap, 2016/11/09 11:41:44]

rather than test for incorrect behavior, make tests less strict (but leave TODO
to make checks stricter):
EXPECT_CALL(...).Times(AtLeast(1));
...
EXPECT_LE(1, transport_.packets_sent());

[brandtr, 2016/11/09 15:16:30]

Good idea. Done.

+  EXPECT_CALL(mock_rtc_event_log_,
+              LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
+      .Times(kNumPacketsExpected);
+  EXPECT_TRUE(rtp_sender_->TimeToSendPacket(
+      kSeqNum, fake_clock_.TimeInMilliseconds(), false, 0));
+  EXPECT_EQ(kNumPacketsExpected, transport_.packets_sent());
+}
+
+TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
+  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(kPayload);
+
+  // 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 11:41:44]

check that one of those packets is flexfec and another is media (i.e. check
ssrcs and payloadtypes).
If you know media should always go before fec, it is easy.
if order doesn't matter, then still possible, but matcher might be complicated.

[brandtr, 2016/11/09 15:16:30]

Yes, media will always come out before FEC. Adding.

+
 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