Add TransportFeedback adapter, adapting remote feedback to bwe estiamtor

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 86 matching lines @@
   uint32_t ssrc_;
 };
 
 RTPSender::RTPSender(int32_t id,
                      bool audio,
                      Clock* clock,
                      Transport* transport,
                      RtpAudioFeedback* audio_feedback,
                      PacedSender* paced_sender,
                      PacketRouter* packet_router,
-                     SendTimeObserver* send_time_observer,
+                     TransportFeedbackObserver* transport_feedback_observer,
                      BitrateStatisticsObserver* bitrate_callback,
                      FrameCountObserver* frame_count_observer,
                      SendSideDelayObserver* send_side_delay_observer)
     : clock_(clock),
       // TODO(holmer): Remove this conversion when we remove the use of
       // TickTime.
       clock_delta_ms_(clock_->TimeInMilliseconds() -
                       TickTime::MillisecondTimestamp()),
       bitrates_(new BitrateAggregator(bitrate_callback)),
       total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()),
       id_(id),
       audio_configured_(audio),
       audio_(audio ? new RTPSenderAudio(id, clock, this, audio_feedback)
                    : nullptr),
       video_(audio ? nullptr : new RTPSenderVideo(clock, this)),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
-      send_time_observer_(send_time_observer),
+      transport_feedback_observer_(transport_feedback_observer),
       last_capture_time_ms_sent_(0),
       send_critsect_(CriticalSectionWrapper::CreateCriticalSection()),
       transport_(transport),
       sending_media_(true),                      // Default to sending media.
       max_payload_length_(IP_PACKET_SIZE - 28),  // Default is IP-v4/UDP.
       packet_over_head_(28),
       payload_type_(-1),
       payload_type_map_(),
       rtp_header_extension_map_(),
       transmission_time_offset_(0),
@@ skipping 533 matching lines @@
 
     uint16_t transport_seq = 0;
     if (using_transport_seq) {
       transport_seq =
           UpdateTransportSequenceNumber(padding_packet, length, rtp_header);
     }
 
     if (!SendPacketToNetwork(padding_packet, length))
       break;
 
-    if (using_transport_seq)
-      send_time_observer_->OnPacketSent(transport_seq, now_ms);
+    if (using_transport_seq && transport_feedback_observer_) {
+      transport_feedback_observer_->OnPacketSent(
+          PacketInfo(0, now_ms, transport_seq, length, true));
+    }
 
     bytes_sent += padding_bytes_in_packet;
     UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false);
   }
 
   return bytes_sent;
 }
 
 void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
   packet_history_.SetStorePacketsStatus(enable, number_to_store);
@@ skipping 221 matching lines @@
     buffer_to_send_ptr = data_buffer_rtx;
   }
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   int64_t diff_ms = now_ms - capture_time_ms;
   UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header,
                                diff_ms);
   UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
 
   uint16_t transport_seq = 0;
+  // TODO(sprang): Potentially too much overhead in IsRegistered()?
   bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
                                  kRtpExtensionTransportSequenceNumber) &&
-                             packet_router_;
+                             packet_router_ && !is_retransmit;
   if (using_transport_seq) {
     transport_seq =
         UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
   }
 
   bool ret = SendPacketToNetwork(buffer_to_send_ptr, length);
   if (ret) {
     CriticalSectionScoped lock(send_critsect_.get());
     media_has_been_sent_ = true;
   }
-  if (using_transport_seq)
-    send_time_observer_->OnPacketSent(transport_seq, now_ms);
+  if (using_transport_seq && transport_feedback_observer_) {
+    transport_feedback_observer_->OnPacketSent(
+        PacketInfo(0, now_ms, transport_seq, length, true));
+  }
   UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
                  is_retransmit);
   return ret;
 }
 
 void RTPSender::UpdateRtpStats(const uint8_t* buffer,
                                size_t packet_length,
                                const RTPHeader& header,
                                bool is_rtx,
                                bool is_retransmit) {
@@ skipping 950 matching lines @@
   CriticalSectionScoped lock(send_critsect_.get());
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc