Add overhead per packet observer to the rtp_sender.

webrtc/modules/rtp_rtcp/source/rtp_sender.cc

Index: webrtc/modules/rtp_rtcp/source/rtp_sender.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 36915c53afeb7fdf9c3a18bf7de53ce4d7f67f84..d50fc49824d4a861da372acb5c1466d093f8e67f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -75,7 +75,8 @@ RTPSender::RTPSender(
     SendSideDelayObserver* send_side_delay_observer,
     RtcEventLog* event_log,
     SendPacketObserver* send_packet_observer,
-    RateLimiter* retransmission_rate_limiter)
+    RateLimiter* retransmission_rate_limiter,
+    OverheadPerPacketObserver* const overhead_per_packet_observer)
     : clock_(clock),
       // TODO(holmer): Remove this conversion?
       clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
@@ -116,7 +117,10 @@ RTPSender::RTPSender(
       last_packet_marker_bit_(false),
       csrcs_(),
       rtx_(kRtxOff),
-      retransmission_rate_limiter_(retransmission_rate_limiter) {
+      transport_overhead_per_packet_(0),
+      rtp_overhead_per_packet_(0),
+      retransmission_rate_limiter_(retransmission_rate_limiter),
+      overhead_per_packet_observer_(overhead_per_packet_observer) {
   ssrc_ = ssrc_db_->CreateSSRC();
   RTC_DCHECK(ssrc_ != 0);
   ssrc_rtx_ = ssrc_db_->CreateSSRC();
@@ -561,18 +565,10 @@ size_t RTPSender::DeprecatedSendPadData(size_t bytes,
           kTimestampTicksPerMs * (now_ms - capture_time_ms));
     }
     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.payload_size() + padding_packet.padding_size(),
-          probe_cluster_id);
+    PacketOptions options;
+    AddPacketToTransportFeedback(&options, &padding_packet, probe_cluster_id);
 
     if (!SendPacketToNetwork(padding_packet, options))
       break;
@@ -735,13 +731,7 @@ bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
   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->payload_size() + packet_to_send->padding_size(),
-        probe_cluster_id);
-  }
+  AddPacketToTransportFeedback(&options, packet_to_send, probe_cluster_id);
 
   if (!is_retransmit && !send_over_rtx) {
     UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
@@ -858,12 +848,7 @@ bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
   }
 
   PacketOptions options;
-  if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id) &&
-      transport_feedback_observer_) {
-    transport_feedback_observer_->AddPacket(
-        options.packet_id, packet->payload_size() + packet->padding_size(),
-        PacketInfo::kNotAProbe);
-  }
+  AddPacketToTransportFeedback(&options, packet.get(), PacketInfo::kNotAProbe);
 
   UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
   UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
@@ -1244,4 +1229,32 @@ RtpState RTPSender::GetRtxRtpState() const {
   return state;
 }
 
+void RTPSender::SetTransportOverhead(int transport_overhead) {
+  rtc::CritScope lock(&send_critsect_);
+  if (overhead_per_packet_observer_ &&
+      transport_overhead_per_packet_ != transport_overhead) {
+    overhead_per_packet_observer_->OnOverheadPerPacketChange(
+        rtp_overhead_per_packet_ + transport_overhead);
+  }
+  transport_overhead_per_packet_ = transport_overhead;
+}
+
+void RTPSender::AddPacketToTransportFeedback(PacketOptions* options,
+                                             RtpPacketToSend* packet,
+                                             int probe_cluster_id) {
+  rtc::CritScope lock(&send_critsect_);
+  if (UpdateTransportSequenceNumber(packet, &options->packet_id) &&
+      transport_feedback_observer_) {
+    transport_feedback_observer_->AddPacket(
+        options->packet_id, packet->payload_size() + packet->padding_size(),
+        probe_cluster_id);
+  }
+  if (overhead_per_packet_observer_ &&
+      rtp_overhead_per_packet_ != packet->headers_size()) {
+    overhead_per_packet_observer_->OnOverheadPerPacketChange(
+        packet->headers_size() + transport_overhead_per_packet_);
+  }
+  rtp_overhead_per_packet_ = packet->headers_size();
+}
+
 }  // namespace webrtc