Count FlexFEC packets in |fec_bitrate_| in RTPSenderVideo.

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 873 matching lines @@
   SendGenericPayload();
   ASSERT_EQ(2, transport_.packets_sent());
   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, FecOverheadRate) {
+  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_, nullptr));
+  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);
+
+  // Send 10 media packet, and therefore 10 FEC packets.
+  EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, false))
+      .WillRepeatedly(testing::Return());

[danilchap, 2017/01/24 09:56:27]

if it doesn't matter how many times InsertPacket will run, you can try to use
ON_CALL instead of EXPECT_CALL.
but may be instead of WillRepeatedly write Times(20) since you sure how many
packets will be sent.
or, if you want to remove comments:
const size_t kMediaPackets = 10;
const size_t kFecPackets = kMediaPackets;
.Times(kMediaPackets + kFecPackets);

[brandtr, 2017/01/24 10:28:13]

Done.

+  for (int i = 0; i < 10; ++i) {
+    SendGenericPayload();
+    fake_clock_.AdvanceTimeMilliseconds(10);
+  }
+  constexpr size_t kRtpHeaderLength = 12;
+  constexpr size_t kFlexfecHeaderLength = 20;
+  constexpr size_t kGenericCodecHeaderLength = 1;
+  constexpr size_t kPayloadLength = sizeof(kPayloadData);
+  constexpr size_t kPacketLength = kRtpHeaderLength + kFlexfecHeaderLength +
+                                   kGenericCodecHeaderLength + kPayloadLength;
+  EXPECT_EQ(static_cast<uint32_t>(10 * 8 * kPacketLength / 0.101f),

[danilchap, 2017/01/24 09:56:27]

may be EXPECT_NEAR to avoid cast and magic constant 0.101f

[brandtr, 2017/01/24 10:28:13]

Done. WDYT?

[danilchap, 2017/01/24 10:35:13]

Nice!

+            rtp_sender_->FecOverheadRate());
+}
+
 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;
@@ skipping 535 matching lines @@
                             kRtpOverheadBytesPerPacket,
                         PacketInfo::kNotAProbe))
       .Times(1);
   EXPECT_CALL(mock_overhead_observer,
               OnOverheadChanged(kRtpOverheadBytesPerPacket))
       .Times(1);
   SendGenericPayload();
 }
 
 }  // namespace webrtc