Propagate probing cluster id to SendTimeHistory.

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 525 matching lines @@
   } else if (frame_type == kVideoFrameDelta) {
     ++frame_counts_.delta_frames;
   }
   if (frame_count_observer_) {
     frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
   }
 
   return ret_val;
 }
 
-size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) {
+size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
+                                           int probe_cluster_id) {
   {
     rtc::CritScope lock(&send_critsect_);
     if (!sending_media_)
       return 0;
     if ((rtx_ & kRtxRedundantPayloads) == 0)
       return 0;
   }
 
   uint8_t buffer[IP_PACKET_SIZE];
   int bytes_left = static_cast<int>(bytes_to_send);
   while (bytes_left > 0) {
     size_t length = bytes_left;
     int64_t capture_time_ms;
     if (!packet_history_.GetBestFittingPacket(buffer, &length,
                                               &capture_time_ms)) {
       break;
     }
-    if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false))
+    if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false,
+                              probe_cluster_id))
       break;
     RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
     RTPHeader rtp_header;
     rtp_parser.Parse(&rtp_header);
     bytes_left -= static_cast<int>(length - rtp_header.headerLength);
   }
   return bytes_to_send - bytes_left;
 }
 
 void RTPSender::BuildPaddingPacket(uint8_t* packet,
@@ skipping 151 matching lines @@
         corrected_capture_tims_ms, length - header.headerLength, true);
 
     return length;
   }
   int rtx = kRtxOff;
   {
     rtc::CritScope lock(&send_critsect_);
     rtx = rtx_;
   }
   if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms,
-                            (rtx & kRtxRetransmitted) > 0, true)) {
+                            (rtx & kRtxRetransmitted) > 0, true, -1)) {
     return -1;
   }
   return static_cast<int32_t>(length);
 }
 
 bool RTPSender::SendPacketToNetwork(const uint8_t* packet,
                                     size_t size,
                                     const PacketOptions& options) {
   int bytes_sent = -1;
   if (transport_) {
@@ skipping 115 matching lines @@
     nack_byte_count_[i + 1] = nack_byte_count_[i];
     nack_byte_count_times_[i + 1] = nack_byte_count_times_[i];
   }
   nack_byte_count_[0] = bytes;
   nack_byte_count_times_[0] = now;
 }
 
 // Called from pacer when we can send the packet.
 bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
                                  int64_t capture_time_ms,
-                                 bool retransmission) {
+                                 bool retransmission,
+                                 int probe_cluster_id) {
   size_t length = IP_PACKET_SIZE;
   uint8_t data_buffer[IP_PACKET_SIZE];
   int64_t stored_time_ms;
 
   if (!packet_history_.GetPacketAndSetSendTime(sequence_number,
                                                0,
                                                retransmission,
                                                data_buffer,
                                                &length,
                                                &stored_time_ms)) {
     // Packet cannot be found. Allow sending to continue.
     return true;
   }
 
   int rtx;
   {
     rtc::CritScope lock(&send_critsect_);
     rtx = rtx_;
   }
-  return PrepareAndSendPacket(data_buffer,
-                              length,
-                              capture_time_ms,
+  return PrepareAndSendPacket(data_buffer, length, capture_time_ms,
                               retransmission && (rtx & kRtxRetransmitted) > 0,
-                              retransmission);
+                              retransmission, probe_cluster_id);
 }
 
 bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
                                      size_t length,
                                      int64_t capture_time_ms,
                                      bool send_over_rtx,
-                                     bool is_retransmit) {
+                                     bool is_retransmit,
+                                     int probe_cluster_id) {
   uint8_t* buffer_to_send_ptr = buffer;
 
   RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
   if (!is_retransmit && rtp_header.markerBit) {
     TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
                            capture_time_ms);
   }
 
@@ skipping 12 matching lines @@
   UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header,
                                diff_ms);
   UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
 
   PacketOptions options;
   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);
+                                                probe_cluster_id);
     }
   }
 
   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);
   if (ret) {
@@ skipping 46 matching lines @@
   }
   bool fec_enabled;
   uint8_t pt_red;
   uint8_t pt_fec;
   video_->GenericFECStatus(&fec_enabled, &pt_red, &pt_fec);
   return fec_enabled &&
       header.payloadType == pt_red &&
       buffer[header.headerLength] == pt_fec;
 }
 
-size_t RTPSender::TimeToSendPadding(size_t bytes) {
+size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
   if (audio_configured_ || bytes == 0)
     return 0;
-  size_t bytes_sent = TrySendRedundantPayloads(bytes);
+  size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id);
   if (bytes_sent < bytes)
     bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0);
   return bytes_sent;
 }
 
 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
 int32_t RTPSender::SendToNetwork(uint8_t* buffer,
                                  size_t payload_length,
                                  size_t rtp_header_length,
                                  int64_t capture_time_ms,
@@ skipping 39 matching lines @@
     }
     return 0;
   }
 
   PacketOptions options;
   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);

[danilchap, 2016/05/25 13:00:54]

AddPacket already take probe_cluster_id as last parameter, not bool.
may be change AddPacket signature so that old code wouldn't compile to help find
all places that should be changed.
(true look wrong here anyway: this is code path when pacer is absent)

[philipel, 2016/05/26 09:59:12]

The definition was already changed, but since bool is automatically casted to an
int it compiled fine. An ugly hack to find all the places where we call this
function still using a bool instead of an int is to declare the old function and
mark it with:

__attribute__((deprecated("Old Version!")))

:)

Also, changed from true to PacketInfo::kNotAProbe here.

     }
   }
   UpdateDelayStatistics(capture_time_ms, now_ms);
   UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc);
 
   bool sent = SendPacketToNetwork(buffer, length, options);
 
   // Mark the packet as sent in the history even if send failed. Dropping a
   // packet here should be treated as any other packet drop so we should be
   // ready for a retransmission.
@@ skipping 834 matching lines @@
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc