Remove deprecated RTPSender::SendPadData

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 461 matching lines @@
       break;
     size_t payload_size = packet->payload_size();
     if (!PrepareAndSendPacket(std::move(packet), true, false, probe_cluster_id))
       break;
     bytes_left -= payload_size;
   }
   return bytes_to_send - bytes_left;
 }
 
 size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
-  return DeprecatedSendPadData(bytes, false, 0, 0, probe_cluster_id);
-}
-
-size_t RTPSender::SendPadData(size_t bytes,
-                              bool timestamp_provided,
-                              uint32_t timestamp,
-                              int64_t capture_time_ms) {
-  return DeprecatedSendPadData(bytes, timestamp_provided, timestamp,
-                               capture_time_ms, PacketInfo::kNotAProbe);
-}
-
-size_t RTPSender::DeprecatedSendPadData(size_t bytes,
-                                        bool timestamp_provided,
-                                        uint32_t timestamp,
-                                        int64_t capture_time_ms,
-                                        int probe_cluster_id) {
   // Always send full padding packets. This is accounted for by the
-  // RtpPacketSender,
-  // which will make sure we don't send too much padding even if a single packet
-  // is larger than requested.
+  // RtpPacketSender, which will make sure we don't send too much padding even
+  // if a single packet is larger than requested.
   size_t padding_bytes_in_packet =
       std::min(MaxDataPayloadLength(), kMaxPaddingLength);
   size_t bytes_sent = 0;
-  bool using_transport_seq =
-      IsRtpHeaderExtensionRegistered(kRtpExtensionTransportSequenceNumber) &&
-      transport_sequence_number_allocator_;
-  for (; bytes > 0; bytes -= padding_bytes_in_packet) {
-    if (bytes < padding_bytes_in_packet)
-      bytes = padding_bytes_in_packet;
-
+  while (bytes_sent < bytes) {
+    int64_t now_ms = clock_->TimeInMilliseconds();
     uint32_t ssrc;
+    uint32_t timestamp;
+    int64_t capture_time_ms;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
       rtc::CritScope lock(&send_critsect_);
       if (!sending_media_)
-        return bytes_sent;
-      if (!timestamp_provided) {
-        timestamp = last_rtp_timestamp_;
-        capture_time_ms = capture_time_ms_;
-      }
+        break;
+      timestamp = last_rtp_timestamp_;
+      capture_time_ms = capture_time_ms_;
       if (rtx_ == kRtxOff) {
         // Without RTX we can't send padding in the middle of frames.
         if (!last_packet_marker_bit_)
-          return 0;
+          break;
         ssrc = ssrc_;
         sequence_number = sequence_number_;
         ++sequence_number_;
         payload_type = payload_type_;
         over_rtx = false;
       } else {
         // Without abs-send-time or transport sequence number a media packet
         // must be sent before padding so that the timestamps used for
         // estimation are correct.
         if (!media_has_been_sent_ &&
-            !(rtp_header_extension_map_.IsRegistered(
-                  kRtpExtensionAbsoluteSendTime) ||
-              using_transport_seq)) {
-          return 0;
+            !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
+              (rtp_header_extension_map_.IsRegistered(
+                   TransportSequenceNumber::kId) &&
+               transport_sequence_number_allocator_))) {
+          break;
         }
         // Only change change the timestamp of padding packets sent over RTX.
         // Padding only packets over RTP has to be sent as part of a media
         // frame (and therefore the same timestamp).
         if (last_timestamp_time_ms_ > 0) {
           timestamp +=
-              (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90;
-          capture_time_ms +=
-              (clock_->TimeInMilliseconds() - last_timestamp_time_ms_);
+              (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
+          capture_time_ms += (now_ms - last_timestamp_time_ms_);
         }
         ssrc = ssrc_rtx_;
         sequence_number = sequence_number_rtx_;
         ++sequence_number_rtx_;
         payload_type = rtx_payload_type_map_.begin()->second;
         over_rtx = true;
       }
     }
 
-    RtpPacketToSend padding_packet(&rtp_header_extension_map_, IP_PACKET_SIZE);
+    RtpPacketToSend padding_packet(&rtp_header_extension_map_);
     padding_packet.SetPayloadType(payload_type);
     padding_packet.SetMarker(false);
     padding_packet.SetSequenceNumber(sequence_number);
     padding_packet.SetTimestamp(timestamp);
     padding_packet.SetSsrc(ssrc);
 
-    int64_t now_ms = clock_->TimeInMilliseconds();
-
     if (capture_time_ms > 0) {
       padding_packet.SetExtension<TransmissionOffset>(
-          kTimestampTicksPerMs * (now_ms - capture_time_ms));
+          (now_ms - capture_time_ms) * kTimestampTicksPerMs);
     }
     padding_packet.SetExtension<AbsoluteSendTime>(now_ms);
     PacketOptions options;
     bool has_transport_seq_num =
         UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
     padding_packet.SetPadding(padding_bytes_in_packet, &random_);
 
     if (has_transport_seq_num) {
       AddPacketToTransportFeedback(options.packet_id, padding_packet,
                                    probe_cluster_id);
@@ skipping 735 matching lines @@
       return;
     }
     rtp_overhead_bytes_per_packet_ = packet.headers_size();
     overhead_bytes_per_packet =
         rtp_overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_;
   }
   overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
 }
 
 }  // namespace webrtc