Disable pacer disabling.

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 694 matching lines @@
   if (paced_sender_) {
     RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length);
     RTPHeader header;
     if (!rtp_parser.Parse(header)) {
       assert(false);
       return -1;
     }
     // Convert from TickTime to Clock since capture_time_ms is based on
     // TickTime.
     int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_;
-    if (!paced_sender_->SendPacket(
-            RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
-            corrected_capture_tims_ms, length - header.headerLength, true)) {
-      // We can't send the packet right now.
-      // We will be called when it is time.
-      return length;
-    }
+    paced_sender_->InsertPacket(
+        RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
+        corrected_capture_tims_ms, length - header.headerLength, true);
+
+    return length;
   }
   int rtx = kRtxOff;
   {
     CriticalSectionScoped lock(send_critsect_.get());
     rtx = rtx_;
   }
   if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms,
                             (rtx & kRtxRetransmitted) > 0, true)) {
     return -1;
   }
@@ skipping 298 matching lines @@
 
   UpdateAbsoluteSendTime(buffer, payload_length + rtp_header_length,
                          rtp_header, now_ms);
 
   // Used for NACK and to spread out the transmission of packets.
   if (packet_history_.PutRTPPacket(buffer, rtp_header_length + payload_length,
                                    capture_time_ms, storage) != 0) {
     return -1;
   }
 
   if (paced_sender_ && storage != kDontStore) {

[stefan-webrtc, 2015/10/06 14:32:33]

It worries me a bit that we allow some packets to not go through the pacer even
if it's there.

Looking into this, it appears to only be FIR over RTP that has kDontStore set. I
suggest we remove that value and at the same time remove FIR over RTP, which we
never enable in the new API.

I think this is safe since this is a very old an deprecated way of sending FIRs,
which is only actually defined for H.261: https://tools.ietf.org/html/rfc2032

[pbos-webrtc, 2015/10/06 14:58:25]

Done.

     // Correct offset between implementations of millisecond time stamps in
     // TickTime and Clock.
     int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_;
-    if (!paced_sender_->SendPacket(priority, rtp_header.ssrc,
-                                   rtp_header.sequenceNumber, corrected_time_ms,
-                                   payload_length, false)) {
-      if (last_capture_time_ms_sent_ == 0 ||
-          corrected_time_ms > last_capture_time_ms_sent_) {
-        last_capture_time_ms_sent_ = corrected_time_ms;
-        TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
-                                 "PacedSend", corrected_time_ms,
-                                 "capture_time_ms", corrected_time_ms);
-      }
-      // We can't send the packet right now.
-      // We will be called when it is time.
-      return 0;
+    paced_sender_->InsertPacket(priority, rtp_header.ssrc,
+                                rtp_header.sequenceNumber, corrected_time_ms,
+                                payload_length, false);
+    if (last_capture_time_ms_sent_ == 0 ||
+        corrected_time_ms > last_capture_time_ms_sent_) {
+      last_capture_time_ms_sent_ = corrected_time_ms;
+      TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                               "PacedSend", corrected_time_ms,
+                               "capture_time_ms", corrected_time_ms);
     }
+    return 0;
   }
   if (capture_time_ms > 0) {
     UpdateDelayStatistics(capture_time_ms, now_ms);
   }
 
   size_t length = payload_length + rtp_header_length;
   bool sent = SendPacketToNetwork(buffer, length, PacketOptions());
 
   if (storage != kDontStore) {
     // Mark the packet as sent in the history even if send failed. Dropping a
@@ skipping 836 matching lines @@
   CriticalSectionScoped lock(send_critsect_.get());
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc