Add histogram stats for send delay for a sent video stream.

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 3fbca7b67d8714038067338f325b898e9239e3dc..04698c81fdda78ce29fd8dda1f53cdc82147d7f4 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -114,7 +114,8 @@ RTPSender::RTPSender(
     BitrateStatisticsObserver* bitrate_callback,
     FrameCountObserver* frame_count_observer,
     SendSideDelayObserver* send_side_delay_observer,
-    RtcEventLog* event_log)
+    RtcEventLog* event_log,
+    SendPacketObserver* send_packet_observer)
     : clock_(clock),
       // TODO(holmer): Remove this conversion when we remove the use of
       // TickTime.
@@ -152,6 +153,7 @@ RTPSender::RTPSender(
       frame_count_observer_(frame_count_observer),
       send_side_delay_observer_(send_side_delay_observer),
       event_log_(event_log),
+      send_packet_observer_(send_packet_observer),
       // RTP variables
       start_timestamp_forced_(false),
       start_timestamp_(0),
@@ -675,13 +677,13 @@ size_t RTPSender::SendPadData(size_t bytes,
     UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms);
 
     PacketOptions options;
-    if (using_transport_seq) {
-      options.packet_id =
-          UpdateTransportSequenceNumber(padding_packet, length, rtp_header);
-    }
-
-    if (using_transport_seq && transport_feedback_observer_) {
-      transport_feedback_observer_->AddPacket(options.packet_id, length, true);
+    if (using_transport_seq &&
+        AllocateTransportSequenceNumber(&options.packet_id)) {

[stefan-webrtc, 2016/04/19 11:06:15]

Don't we want to set options.packet_id even if we're not using_transport_seq,
but only write it into the packet header if using_transport_seq?

[åsapersson, 2016/04/19 14:55:32]

Thought it was not necessary to allocate and set options.packet_id if not used
(by stats or transport sequence number). But I can change (remove the
using_transport_seq check), wdyt? 

[stefan-webrtc, 2016/04/20 10:59:54]

It's not, but I can't see that you checked if the sequence numbers are needed
for stats or not? Anyway, I think we might as well add them all the time to
options, but only write them in the bitstream when using the transport sequence
number header extension.

[åsapersson, 2016/04/20 11:16:56]

Stats not updated, UpdateOnSendPacket not called.

Ok, changed so sequence numbers are always allocated either way.

+      UpdateTransportSequenceNumber(options.packet_id, padding_packet, length,
+                                    rtp_header);
+      if (transport_feedback_observer_)
+        transport_feedback_observer_->AddPacket(options.packet_id, length,
+                                                true);
     }
 
     if (!SendPacketToNetwork(padding_packet, length, options))
@@ -886,9 +888,7 @@ bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
     // Packet cannot be found. Allow sending to continue.
     return true;
   }
-  if (!retransmission && capture_time_ms > 0) {
-    UpdateDelayStatistics(capture_time_ms, clock_->TimeInMilliseconds());
-  }
+
   int rtx;
   {
     rtc::CritScope lock(&send_critsect_);
@@ -932,19 +932,19 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
                                diff_ms);
   UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
 
-  // TODO(sprang): Potentially too much overhead in IsRegistered()?
-  bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
-                                 kRtpExtensionTransportSequenceNumber) &&
-                             transport_sequence_number_allocator_;
-
   PacketOptions options;
-  if (using_transport_seq) {
-    options.packet_id =
-        UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
+  if (AllocateTransportSequenceNumber(&options.packet_id)) {
+    if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr,
+                                      length, rtp_header)) {
+      if (transport_feedback_observer_)
+        transport_feedback_observer_->AddPacket(options.packet_id, length,
+                                                true);
+    }
   }
 
-  if (using_transport_seq && transport_feedback_observer_) {
-    transport_feedback_observer_->AddPacket(options.packet_id, length, true);
+  if (!is_retransmit && !send_over_rtx) {
+    UpdateDelayStatistics(capture_time_ms, now_ms);
+    UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc);
   }
 
   bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options);
@@ -1061,23 +1061,18 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
     }
     return 0;
   }
-  if (capture_time_ms > 0) {
-    UpdateDelayStatistics(capture_time_ms, now_ms);
-  }
-
-  // TODO(sprang): Potentially too much overhead in IsRegistered()?
-  bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
-                                 kRtpExtensionTransportSequenceNumber) &&
-                             transport_sequence_number_allocator_;
 
   PacketOptions options;
-  if (using_transport_seq) {
-    options.packet_id =
-        UpdateTransportSequenceNumber(buffer, length, rtp_header);
-    if (transport_feedback_observer_) {
-      transport_feedback_observer_->AddPacket(options.packet_id, length, true);
+  if (AllocateTransportSequenceNumber(&options.packet_id)) {
+    if (UpdateTransportSequenceNumber(options.packet_id, buffer, length,
+                                      rtp_header)) {
+      if (transport_feedback_observer_)
+        transport_feedback_observer_->AddPacket(options.packet_id, length,
+                                                true);
     }
   }
+  UpdateDelayStatistics(capture_time_ms, now_ms);
+  UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc);
 
   bool sent = SendPacketToNetwork(buffer, length, options);
 
@@ -1098,7 +1093,7 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
 }
 
 void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
-  if (!send_side_delay_observer_)
+  if (!send_side_delay_observer_ || capture_time_ms <= 0)
     return;
 
   uint32_t ssrc;
@@ -1130,6 +1125,15 @@ void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
                                                   ssrc);
 }
 
+void RTPSender::UpdateOnSendPacket(int packet_id,
+                                   int64_t capture_time_ms,
+                                   uint32_t ssrc) {
+  if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
+    return;
+
+  send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
+}
+
 void RTPSender::ProcessBitrate() {
   rtc::CritScope lock(&send_critsect_);
   total_bitrate_sent_.Process();
@@ -1613,7 +1617,8 @@ void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet,
                                           ConvertMsTo24Bits(now_ms));
 }
 
-uint16_t RTPSender::UpdateTransportSequenceNumber(
+bool RTPSender::UpdateTransportSequenceNumber(
+    uint16_t sequence_number,
     uint8_t* rtp_packet,
     size_t rtp_packet_length,
     const RTPHeader& rtp_header) const {
@@ -1624,19 +1629,26 @@ uint16_t RTPSender::UpdateTransportSequenceNumber(
                           rtp_packet_length, rtp_header,
                           kTransportSequenceNumberLength, &offset)) {
     case ExtensionStatus::kNotRegistered:
-      return 0;
+      return false;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update transport sequence number";
-      return 0;
+      return false;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
-  uint16_t seq = transport_sequence_number_allocator_->AllocateSequenceNumber();
-  BuildTransportSequenceNumberExtension(rtp_packet + offset, seq);
-  return seq;
+  BuildTransportSequenceNumberExtension(rtp_packet + offset, sequence_number);
+  return true;
+}
+
+bool RTPSender::AllocateTransportSequenceNumber(int* packet_id) const {
+  if (!transport_sequence_number_allocator_)
+    return false;
+
+  *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
+  return true;
 }
 
 void RTPSender::SetSendingStatus(bool enabled) {