Landing Recent QUIC changes until 5/14/2016 02:25:25 UTC

net/quic/quic_sent_packet_manager.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 "net/quic/quic_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 81 matching lines @@
       least_packet_awaited_by_peer_(1),
       first_rto_transmission_(0),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
       consecutive_crypto_retransmission_count_(0),
       pending_timer_transmission_count_(0),
       max_tail_loss_probes_(kDefaultMaxTailLossProbes),
       enable_half_rtt_tail_loss_probe_(false),
       using_pacing_(false),
       use_new_rto_(false),
+      undo_pending_retransmits_(false),
       largest_newly_acked_(0),
       handshake_confirmed_(false) {}
 
 QuicSentPacketManager::~QuicSentPacketManager() {}
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.HasReceivedInitialRoundTripTimeUs() &&
       config.ReceivedInitialRoundTripTimeUs() > 0) {
     rtt_stats_.set_initial_rtt_us(
         max(kMinInitialRoundTripTimeUs,
@@ skipping 51 matching lines @@
   }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kTIME)) {
     loss_algorithm_.reset(new GeneralLossAlgorithm(kTime));
   }
   if (FLAGS_quic_adaptive_loss_recovery &&
       config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kATIM)) {
     loss_algorithm_.reset(new GeneralLossAlgorithm(kAdaptiveTime));
   }
+  if (FLAGS_quic_loss_recovery_use_largest_acked &&
+      config.HasClientSentConnectionOption(kUNDO, perspective_)) {
+    undo_pending_retransmits_ = true;
+  }
   if (config.HasReceivedSocketReceiveBuffer()) {
     receive_buffer_bytes_ =
         max(kMinSocketReceiveBuffer,
             static_cast<QuicByteCount>(config.ReceivedSocketReceiveBuffer()));
     QuicByteCount max_cwnd_bytes = static_cast<QuicByteCount>(
         receive_buffer_bytes_ * kConservativeReceiveBufferFraction);
     send_algorithm_->SetMaxCongestionWindow(max_cwnd_bytes);
   }
   send_algorithm_->SetFromConfig(config, perspective_);
 
@@ skipping 68 matching lines @@
         if (!use_new_rto_) {
           send_algorithm_->OnRetransmissionTimeout(true);
         }
       }
     }
     // Reset all retransmit counters any time a new packet is acked.
     consecutive_rto_count_ = 0;
     consecutive_tlp_count_ = 0;
     consecutive_crypto_retransmission_count_ = 0;
   }
+  // TODO(ianswett): Consider replacing the pending_retransmissions_ with a
+  // fast way to retrieve the next pending retransmission, if there are any.
+  // A single packet number indicating all packets below that are lost should
+  // be all the state that is necessary.
+  while (undo_pending_retransmits_ && !pending_retransmissions_.empty() &&
+         pending_retransmissions_.front().first > largest_newly_acked_ &&
+         pending_retransmissions_.front().second == LOSS_RETRANSMISSION) {
+    // Cancel any pending retransmissions larger than largest_newly_acked_.
+    unacked_packets_.RestoreToInFlight(pending_retransmissions_.front().first);
+    pending_retransmissions_.erase(pending_retransmissions_.begin());
+  }
 
   if (debug_delegate_ != nullptr) {
     debug_delegate_->OnIncomingAck(ack_frame, ack_receive_time,
                                    unacked_packets_.largest_observed(),
                                    rtt_updated, GetLeastUnacked());
   }
 }
 
 void QuicSentPacketManager::UpdatePacketInformationReceivedByPeer(
     const QuicAckFrame& ack_frame) {
@@ skipping 50 matching lines @@
       }
       unacked_packets_.NackPacket(packet_number, min_nacks);
       continue;
     }
     // Packet was acked, so remove it from our unacked packet list.
     DVLOG(1) << ENDPOINT << "Got an ack for packet " << packet_number;
     // If data is associated with the most recent transmission of this
     // packet, then inform the caller.
     if (it->in_flight) {
       packets_acked_.push_back(std::make_pair(packet_number, it->bytes_sent));
+    } else if (FLAGS_quic_loss_recovery_use_largest_acked &&
+               !it->is_unackable) {
+      largest_newly_acked_ = packet_number;
     }
     MarkPacketHandled(packet_number, &(*it), ack_delay_time);
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
     QuicPacketNumber packet_number) const {
   return unacked_packets_.HasRetransmittableFrames(packet_number);
 }
 
@@ skipping 187 matching lines @@
     // only handle nullptr encrypted packets in a special way.
     const TransmissionInfo& newest_transmission_info =
         unacked_packets_.GetTransmissionInfo(newest_transmission);
     if (HasCryptoHandshake(newest_transmission_info)) {
       unacked_packets_.RemoveFromInFlight(newest_transmission);
     }
   }
 
   unacked_packets_.RemoveFromInFlight(info);
   unacked_packets_.RemoveRetransmittability(info);
+  if (FLAGS_quic_loss_recovery_use_largest_acked) {
+    info->is_unackable = true;
+  }
 }
 
 bool QuicSentPacketManager::IsUnacked(QuicPacketNumber packet_number) const {
   return unacked_packets_.IsUnacked(packet_number);
 }
 
 bool QuicSentPacketManager::HasUnackedPackets() const {
   return unacked_packets_.HasUnackedPackets();
 }
 
@@ skipping 427 matching lines @@
 TransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
   return unacked_packets_.GetMutableTransmissionInfo(packet_number);
 }
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 }  // namespace net