Correcting the amount of padding when send side bwe includes RTP overhead.

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 589 matching lines @@
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
   rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false,
                                 PacedPacketInfo());
   // Packet should now be sent. This test doesn't verify the regular video
   // packet, since it is tested in another test.
   EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
   timestamp += 90 * kStoredTimeInMs;
 
   // Send padding 4 times, waiting 50 ms between each.
   for (int i = 0; i < 4; ++i) {
-    const int kPaddingPeriodMs = 50;
-    const size_t kPaddingBytes = 100;
-    const size_t kMaxPaddingLength = 224;  // Value taken from rtp_sender.cc.
+    constexpr int kPaddingPeriodMs = 50;
+    constexpr size_t kPaddingBytes = 100;
+    constexpr size_t kMaxPaddingLength =
+        224;  // Value taken from rtp_sender.cc.
+
     // Padding will be forced to full packets.
-    EXPECT_EQ(kMaxPaddingLength,
+    // If BWE includes overhead, the return value of TimeToSendPadding will also
+    // include overhead.
+    const size_t expected_return =
+        GetParam() ? kMaxPaddingLength + rtp_header_len : kMaxPaddingLength;
+    EXPECT_EQ(expected_return,
               rtp_sender_->TimeToSendPadding(kPaddingBytes, PacedPacketInfo()));
 
     // Process send bucket. Padding should now be sent.
     EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
     EXPECT_EQ(kMaxPaddingLength + rtp_header_len,
               transport_.last_sent_packet().size());
 
     transport_.last_sent_packet().GetHeader(&rtp_header);
     EXPECT_EQ(kMaxPaddingLength, rtp_header.paddingLength);
 
@@ skipping 152 matching lines @@
     fake_clock_.AdvanceTimeMilliseconds(33);
   }
 
   EXPECT_CALL(mock_rtc_event_log_,
               LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _, _))
       .Times(::testing::AtLeast(4));
 
   // The amount of padding to send it too small to send a payload packet.
   EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
       .WillOnce(testing::Return(true));
-  EXPECT_EQ(kMaxPaddingSize,
+
+  // If BWE includes overhead, the return value of TimeToSendPadding will also
+  // include overhead.
+  size_t expected_return =
+      GetParam() ? kMaxPaddingSize + rtp_header_len : kMaxPaddingSize;
+  EXPECT_EQ(expected_return,
             rtp_sender_->TimeToSendPadding(49, PacedPacketInfo()));
 
   EXPECT_CALL(transport,
               SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _))
       .WillOnce(testing::Return(true));
-  EXPECT_EQ(kPayloadSizes[0],
+
+  expected_return =
+      GetParam() ? kPayloadSizes[0] + rtp_header_len : kPayloadSizes[0];
+  EXPECT_EQ(expected_return,
             rtp_sender_->TimeToSendPadding(500, PacedPacketInfo()));
 
   EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] +
                                         rtp_header_len + kRtxHeaderSize,
                                  _))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _))
       .WillOnce(testing::Return(true));
-  EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
+
+  expected_return = GetParam()
+                        ? kPayloadSizes[kNumPayloadSizes - 1] +
+                              kMaxPaddingSize + rtp_header_len * 2
+                        : kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize;
+  EXPECT_EQ(expected_return,
             rtp_sender_->TimeToSendPadding(999, PacedPacketInfo()));
 }
 
 TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) {
   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};
 
@@ skipping 697 matching lines @@
       nullptr, nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
       nullptr, &retransmission_rate_limiter_, nullptr));
   rtp_sender_->SetSendPayloadType(kPayload);
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetTimestampOffset(0);
   rtp_sender_->SetSSRC(kSsrc);
 
   const size_t kPaddingSize = 59;
   EXPECT_CALL(transport, SendRtp(_, kPaddingSize + kRtpHeaderSize, _))
       .WillOnce(testing::Return(true));
-  EXPECT_EQ(kPaddingSize,
-            rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
+
+  // If BWE includes overhead, the input value to TimeToSendPadding should also
+  // include overhead.
+  size_t budget = GetParam() ? kPaddingSize + kRtpHeaderSize : kPaddingSize;
+  EXPECT_EQ(budget, rtp_sender_->TimeToSendPadding(budget, PacedPacketInfo()));
 
   // Requested padding size is too small, will send a larger one.
   const size_t kMinPaddingSize = 50;
   EXPECT_CALL(transport, SendRtp(_, kMinPaddingSize + kRtpHeaderSize, _))
       .WillOnce(testing::Return(true));
-  EXPECT_EQ(
-      kMinPaddingSize,
-      rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5, PacedPacketInfo()));
+
+  budget =
+      GetParam() ? kMinPaddingSize - 5 + kRtpHeaderSize : kMinPaddingSize - 5;
+  const size_t expected_return =
+      GetParam() ? kMinPaddingSize + kRtpHeaderSize : kMinPaddingSize;
+  EXPECT_EQ(expected_return,
+            rtp_sender_->TimeToSendPadding(budget, PacedPacketInfo()));
 }
 
 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
                         RtpSenderTest,
                         ::testing::Bool());
 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
                         RtpSenderTestWithoutPacer,
                         ::testing::Bool());
 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
                         RtpSenderVideoTest,
                         ::testing::Bool());
 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
                         RtpSenderAudioTest,
                         ::testing::Bool());
 }  // namespace webrtc