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

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 961b53a139c3901984ee907fc10d491a68210b3a..ff4c4919b96e3571785b894412ae8e88c4d5c9e5 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -607,11 +607,17 @@ TEST_P(RtpSenderTest, SendPadding) {
 
   // 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.
@@ -784,13 +790,21 @@ TEST_P(RtpSenderTest, SendRedundantPayloads) {
   // 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] +
@@ -799,7 +813,12 @@ TEST_P(RtpSenderTest, SendRedundantPayloads) {
       .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

[danilchap, 2017/03/30 11:58:08]

can you add a comment why * 2?

[minyue-webrtc, 2017/03/30 13:07:11]

because two RTP packets are created.

+                        : kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize;
+  EXPECT_EQ(expected_return,
             rtp_sender_->TimeToSendPadding(999, PacedPacketInfo()));
 }
 
@@ -1517,16 +1536,23 @@ TEST_P(RtpSenderTest, SendAudioPadding) {
   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,