Enable probing with repeated payload packets by default.

webrtc/modules/rtp_rtcp/source/rtp_sender.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 551 matching lines @@
     if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false))
       break;
     RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
     RTPHeader rtp_header;
     rtp_parser.Parse(rtp_header);
     bytes_left -= static_cast<int>(length - rtp_header.headerLength);
   }
   return bytes_to_send - bytes_left;
 }
 
-size_t RTPSender::BuildPaddingPacket(uint8_t* packet, size_t header_length) {
-  size_t padding_bytes_in_packet = kMaxPaddingLength;
+size_t RTPSender::BuildPaddingPacket(uint8_t* packet,
+                                     size_t header_length,
+                                     size_t max_padding_length) {

[mflodman, 2015/09/08 12:33:51]

This could be named only padding_length, since we'll use this and it's not
really a max that we might send less than.

[stefan-webrtc, 2015/09/08 13:17:34]

Done.

+  size_t padding_bytes_in_packet = max_padding_length;

[mflodman, 2015/09/08 12:33:51]

No need for this variable.

[stefan-webrtc, 2015/09/08 13:17:34]

Done.

   packet[0] |= 0x20;  // Set padding bit.
   int32_t *data =
       reinterpret_cast<int32_t *>(&(packet[header_length]));
 
   // Fill data buffer with random data.
   for (size_t j = 0; j < (padding_bytes_in_packet >> 2); ++j) {
     data[j] = rand();  // NOLINT
   }
   // Set number of padding bytes in the last byte of the packet.
   packet[header_length + padding_bytes_in_packet - 1] =
       static_cast<uint8_t>(padding_bytes_in_packet);
   return padding_bytes_in_packet;

[mflodman, 2015/09/08 12:33:51]

And no need to return the length here, it will always be = max_padding_length.

[stefan-webrtc, 2015/09/08 13:17:34]

Done.

 }
 
 size_t RTPSender::TrySendPadData(size_t bytes) {
   int64_t capture_time_ms;
   uint32_t timestamp;
   {
     CriticalSectionScoped cs(send_critsect_.get());
     timestamp = timestamp_;
     capture_time_ms = capture_time_ms_;
-    if (last_timestamp_time_ms_ > 0) {
+    if (rtx_ != kRtxOff && last_timestamp_time_ms_ > 0) {
       timestamp +=
           (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90;
       capture_time_ms +=
           (clock_->TimeInMilliseconds() - last_timestamp_time_ms_);
     }
   }
   return SendPadData(timestamp, capture_time_ms, bytes);
 }
 
 size_t RTPSender::SendPadData(uint32_t timestamp,
                               int64_t capture_time_ms,
                               size_t bytes) {
   size_t padding_bytes_in_packet = 0;

[mflodman, 2015/09/08 12:33:51]

Won't this always be = std::min(MaxDataPayloadLength(), kMaxPaddingLength) and
never change?

[stefan-webrtc, 2015/09/08 13:17:34]

Done.

   size_t bytes_sent = 0;
   bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
                                  kRtpExtensionTransportSequenceNumber) &&
                              packet_router_;
   for (; bytes > 0; bytes -= padding_bytes_in_packet) {
     // Always send full padding packets.

[mflodman, 2015/09/08 12:33:51]

Can you extend this comment to indicate this is take care of by the budget and
we're not sending too much over time.

[stefan-webrtc, 2015/09/08 13:17:35]

Done.

-    if (bytes < kMaxPaddingLength)
-      bytes = kMaxPaddingLength;
+    size_t max_padding_length =
+        std::min(MaxDataPayloadLength(), kMaxPaddingLength);
+    if (bytes < max_padding_length)
+      bytes = max_padding_length;
 
     uint32_t ssrc;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
       CriticalSectionScoped cs(send_critsect_.get());
       // Only send padding packets following the last packet of a frame,
       // indicated by the marker bit.
       if (rtx_ == kRtxOff) {
@@ skipping 17 matching lines @@
         payload_type = rtx_payload_type_;
         over_rtx = true;
       }
     }
 
     uint8_t padding_packet[IP_PACKET_SIZE];
     size_t header_length =
         CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp,
                         sequence_number, std::vector<uint32_t>());
     assert(header_length != static_cast<size_t>(-1));
-    padding_bytes_in_packet = BuildPaddingPacket(padding_packet, header_length);
+    padding_bytes_in_packet =
+        BuildPaddingPacket(padding_packet, header_length, max_padding_length);
     assert(padding_bytes_in_packet <= bytes);
     size_t length = padding_bytes_in_packet + header_length;
     int64_t now_ms = clock_->TimeInMilliseconds();
 
     RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length);
     RTPHeader rtp_header;
     rtp_parser.Parse(rtp_header);
 
     if (capture_time_ms > 0) {
       UpdateTransmissionTimeOffset(
@@ skipping 1233 matching lines @@
   CriticalSectionScoped lock(send_critsect_.get());
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc