Cast: Avoid retransmit if we sent the same packet recently (less than RTT)

media/cast/audio_sender/audio_sender.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/audio_sender/audio_sender.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/audio_sender/audio_encoder.h"
@@ skipping 234 matching lines @@
     // TODO(miu): The values "2" and "3" should be derived from configuration.
     if (duplicate_ack_counter_ >= 2 && duplicate_ack_counter_ % 3 == 2) {
       VLOG(1) << "Received duplicate ACK for frame " << latest_acked_frame_id_;
       ResendForKickstart();
     }
   } else {
     // Only count duplicated ACKs if there is no NACK request in between.
     // This is to avoid aggresive resend.
     duplicate_ack_counter_ = 0;
 
+    base::TimeDelta rtt;
+    base::TimeDelta avg_rtt;
+    base::TimeDelta min_rtt;
+    base::TimeDelta max_rtt;
+    rtcp_.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt);
+
     // A NACK is also used to cancel pending re-transmissions.
     transport_sender_->ResendPackets(
-        true, cast_feedback.missing_frames_and_packets_, true);
+        true, cast_feedback.missing_frames_and_packets_, false, min_rtt);
   }
 
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   const RtpTimestamp rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_feedback.ack_frame_id_ & 0xff];
   cast_environment_->Logging()->InsertFrameEvent(now,
                                                  FRAME_ACK_RECEIVED,
                                                  AUDIO_EVENT,
                                                  rtp_timestamp,
                                                  cast_feedback.ack_frame_id_);
 
   const bool is_acked_out_of_order =
       static_cast<int32>(cast_feedback.ack_frame_id_ -
                              latest_acked_frame_id_) < 0;
   VLOG(2) << "Received ACK" << (is_acked_out_of_order ? " out-of-order" : "")
           << " for frame " << cast_feedback.ack_frame_id_;
   if (!is_acked_out_of_order) {
     // Cancel resends of acked frames.
     MissingFramesAndPacketsMap missing_frames_and_packets;
     PacketIdSet missing;
     while (latest_acked_frame_id_ != cast_feedback.ack_frame_id_) {
       latest_acked_frame_id_++;
       missing_frames_and_packets[latest_acked_frame_id_] = missing;
     }
-    transport_sender_->ResendPackets(true, missing_frames_and_packets, true);
+    transport_sender_->ResendPackets(
+        true, missing_frames_and_packets, true, base::TimeDelta());
     latest_acked_frame_id_ = cast_feedback.ack_frame_id_;
   }
 }
 
 bool AudioSender::AreTooManyFramesInFlight() const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   int frames_in_flight = 0;
   if (!last_send_time_.is_null()) {
     frames_in_flight +=
         static_cast<int32>(last_sent_frame_id_ - latest_acked_frame_id_);
@@ skipping 12 matching lines @@
   // Send the first packet of the last encoded frame to kick start
   // retransmission. This gives enough information to the receiver what
   // packets and frames are missing.
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing.insert(kRtcpCastLastPacket);
   missing_frames_and_packets.insert(
       std::make_pair(last_sent_frame_id_, missing));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 
+  base::TimeDelta rtt;
+  base::TimeDelta avg_rtt;
+  base::TimeDelta min_rtt;
+  base::TimeDelta max_rtt;
+  rtcp_.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt);
+
   // Sending this extra packet is to kick-start the session. There is
   // no need to optimize re-transmission for this case.
-  transport_sender_->ResendPackets(true, missing_frames_and_packets,
-                                   false);
+  transport_sender_->ResendPackets(
+      true, missing_frames_and_packets, false, min_rtt);
 }
 
 }  // namespace cast
 }  // namespace media