Don't include RTP headers in send-side BWE.

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 611 matching lines @@
     padding_packet.SetExtension<AbsoluteSendTime>(now_ms);
 
     PacketOptions options;
     bool has_transport_seq_no =
         UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
 
     padding_packet.SetPadding(padding_bytes_in_packet, &random_);
 
     if (has_transport_seq_no && transport_feedback_observer_)
       transport_feedback_observer_->AddPacket(
-          options.packet_id, padding_packet.size(), probe_cluster_id);
+          options.packet_id,
+          padding_packet.payload_size() + padding_packet.padding_size(),
+          probe_cluster_id);
 
     if (!SendPacketToNetwork(padding_packet, options))
       break;
 
     bytes_sent += padding_bytes_in_packet;
     UpdateRtpStats(padding_packet, over_rtx, false);
   }
 
   return bytes_sent;
 }
@@ skipping 98 matching lines @@
 }
 
 // Called from pacer when we can send the packet.
 bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
                                  int64_t capture_time_ms,
                                  bool retransmission,
                                  int probe_cluster_id) {
   std::unique_ptr<RtpPacketToSend> packet =
       packet_history_.GetPacketAndSetSendTime(sequence_number, 0,
                                               retransmission);
-  if (!packet)
+  if (!packet) {
     // Packet cannot be found. Allow sending to continue.
     return true;
+  }
 
   return PrepareAndSendPacket(
       std::move(packet),
       retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
       probe_cluster_id);
 }
 
 bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
                                      bool send_over_rtx,
                                      bool is_retransmit,
@@ skipping 22 matching lines @@
   int64_t now_ms = clock_->TimeInMilliseconds();
   int64_t diff_ms = now_ms - capture_time_ms;
   packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
                                                    diff_ms);
   packet_to_send->SetExtension<AbsoluteSendTime>(now_ms);
 
   PacketOptions options;
   if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id) &&
       transport_feedback_observer_) {
     transport_feedback_observer_->AddPacket(
-        options.packet_id, packet_to_send->size(), probe_cluster_id);
+        options.packet_id,
+        packet_to_send->payload_size() + packet_to_send->padding_size(),
+        probe_cluster_id);
   }
 
   if (!is_retransmit && !send_over_rtx) {
     UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
     UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
                        packet->Ssrc());
   }
 
   if (!SendPacketToNetwork(*packet_to_send, options))
     return false;
@@ skipping 108 matching lines @@
       TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                                "PacedSend", corrected_time_ms,
                                "capture_time_ms", corrected_time_ms);
     }
     return true;
   }
 
   PacketOptions options;
   if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id) &&
       transport_feedback_observer_) {
-    transport_feedback_observer_->AddPacket(options.packet_id, packet->size(),
-                                            PacketInfo::kNotAProbe);
+    transport_feedback_observer_->AddPacket(
+        options.packet_id, packet->payload_size() + packet->padding_size(),
+        PacketInfo::kNotAProbe);
   }
 
   UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
   UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
                      packet->Ssrc());
 
   bool sent = SendPacketToNetwork(*packet, options);
 
   if (sent) {
     {
@@ skipping 777 matching lines @@
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = timestamp_offset_;
 
   return state;
 }
 
 }  // namespace webrtc