Land Recent QUIC Changes.

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 "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 49 matching lines @@
 }
 
 }  // namespace
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicSentPacketManager::QuicSentPacketManager(bool is_server,
                                              const QuicClock* clock,
                                              QuicConnectionStats* stats,
                                              CongestionFeedbackType type)
-    : unacked_packets_(is_server),
+    : unacked_packets_(),
       is_server_(is_server),
       clock_(clock),
       stats_(stats),
-      send_algorithm_(SendAlgorithmInterface::Create(clock, type, stats)),
+      send_algorithm_(
+          SendAlgorithmInterface::Create(clock, &rtt_stats_, type, stats)),
       loss_algorithm_(LossDetectionInterface::Create()),
-      rtt_sample_(QuicTime::Delta::Infinite()),
       largest_observed_(0),
-      pending_crypto_packet_count_(0),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
       consecutive_crypto_retransmission_count_(0),
       max_tail_loss_probes_(kDefaultMaxTailLossProbes),
       using_pacing_(false) {
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {
 }
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
-  if (config.initial_round_trip_time_us() > 0 &&
-      rtt_sample_.IsInfinite()) {
+  if (config.initial_round_trip_time_us() > 0) {
     // The initial rtt should already be set on the client side.
     DVLOG_IF(1, !is_server_)
         << "Client did not set an initial RTT, but did negotiate one.";
-    rtt_sample_ =
-        QuicTime::Delta::FromMicroseconds(config.initial_round_trip_time_us());
-    send_algorithm_->UpdateRtt(rtt_sample_);
+    rtt_stats_.set_initial_rtt_us(config.initial_round_trip_time_us());
   }
   if (config.congestion_control() == kPACE) {
     MaybeEnablePacing();
   }
   send_algorithm_->SetFromConfig(config, is_server_);
 }
 
 // TODO(ianswett): Combine this method with OnPacketSent once packets are always
 // sent in order and the connection tracks RetransmittableFrames for longer.
 void QuicSentPacketManager::OnSerializedPacket(
     const SerializedPacket& serialized_packet) {
   if (serialized_packet.retransmittable_frames) {
     ack_notifier_manager_.OnSerializedPacket(serialized_packet);
-
-    if (serialized_packet.retransmittable_frames->HasCryptoHandshake()
-            == IS_HANDSHAKE) {
-      ++pending_crypto_packet_count_;
-    }
   }
 
   unacked_packets_.AddPacket(serialized_packet);
 }
 
 void QuicSentPacketManager::OnRetransmittedPacket(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number) {
   DCHECK(ContainsKey(pending_retransmissions_, old_sequence_number));
 
@@ skipping 180 matching lines @@
   }
 
   SequenceNumberSet all_transmissions = *transmission_info.all_transmissions;
   SequenceNumberSet::reverse_iterator all_transmissions_it =
       all_transmissions.rbegin();
   QuicPacketSequenceNumber newest_transmission = *all_transmissions_it;
   if (newest_transmission != sequence_number) {
     ++stats_->packets_spuriously_retransmitted;
   }
 
-  bool has_cryto_handshake = HasCryptoHandshake(
+  bool has_crypto_handshake = HasCryptoHandshake(
       unacked_packets_.GetTransmissionInfo(newest_transmission));
-  if (has_cryto_handshake) {
-    --pending_crypto_packet_count_;
-  }
   while (all_transmissions_it != all_transmissions.rend()) {
     QuicPacketSequenceNumber previous_transmission = *all_transmissions_it;
     const QuicUnackedPacketMap::TransmissionInfo& transmission_info =
         unacked_packets_.GetTransmissionInfo(previous_transmission);
     if (ContainsKey(pending_retransmissions_, previous_transmission)) {
       // Don't bother retransmitting this packet, if it has been
       // marked for retransmission.
       pending_retransmissions_.erase(previous_transmission);
     }
-    if (has_cryto_handshake) {
+    if (has_crypto_handshake) {
       // If it's a crypto handshake packet, discard it and all retransmissions,
       // since they won't be acked now that one has been processed.
       if (transmission_info.pending) {
         OnPacketAbandoned(previous_transmission);
       }
       unacked_packets_.SetNotPending(previous_transmission);
     }
     if (!transmission_info.pending) {
       unacked_packets_.RemovePacket(previous_transmission);
     } else {
@@ skipping 151 matching lines @@
 
   send_algorithm_->OnRetransmissionTimeout(packets_retransmitted);
   if (packets_retransmitted) {
     ++consecutive_rto_count_;
   }
 }
 
 QuicSentPacketManager::RetransmissionTimeoutMode
     QuicSentPacketManager::GetRetransmissionMode() const {
   DCHECK(unacked_packets_.HasPendingPackets());
-  if (pending_crypto_packet_count_ > 0) {
+  if (unacked_packets_.HasPendingCryptoPackets()) {
     return HANDSHAKE_MODE;
   }
   if (loss_algorithm_->GetLossTimeout() != QuicTime::Zero()) {
     return LOSS_MODE;
   }
   if (consecutive_tlp_count_ < max_tail_loss_probes_) {
     if (unacked_packets_.HasUnackedRetransmittableFrames()) {
       return TLP_MODE;
     }
   }
@@ skipping 42 matching lines @@
   }
 
   InvokeLossDetection(ack_receive_time);
 }
 
 void QuicSentPacketManager::InvokeLossDetection(QuicTime time) {
   SequenceNumberSet lost_packets =
       loss_algorithm_->DetectLostPackets(unacked_packets_,
                                          time,
                                          largest_observed_,
-                                         send_algorithm_->SmoothedRtt(),
-                                         rtt_sample_);
+                                         rtt_stats_);
   for (SequenceNumberSet::const_iterator it = lost_packets.begin();
        it != lost_packets.end(); ++it) {
     QuicPacketSequenceNumber sequence_number = *it;
     // TODO(ianswett): If it's expected the FEC packet may repair the loss, it
     // should be recorded as a loss to the send algorithm, but not retransmitted
     // until it's known whether the FEC packet arrived.
     ++stats_->packets_lost;
     send_algorithm_->OnPacketLost(sequence_number, time);
     OnPacketAbandoned(sequence_number);
 
@@ skipping 19 matching lines @@
   // sequence numbers will include the ACK aggregation delay.
   const QuicUnackedPacketMap::TransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(received_info.largest_observed);
   // Don't update the RTT if it hasn't been sent.
   if (transmission_info.sent_time == QuicTime::Zero()) {
     return;
   }
 
   QuicTime::Delta send_delta =
       ack_receive_time.Subtract(transmission_info.sent_time);
-  if (send_delta > received_info.delta_time_largest_observed) {
-    rtt_sample_ = send_delta.Subtract(
-        received_info.delta_time_largest_observed);
-  } else if (rtt_sample_.IsInfinite()) {
-    // Even though we received information from the peer suggesting
-    // an invalid (negative) RTT, we can use the send delta as an
-    // approximation until we get a better estimate.
-    rtt_sample_ = send_delta;
-  }
-  send_algorithm_->UpdateRtt(rtt_sample_);
+  rtt_stats_.UpdateRtt(send_delta, received_info.delta_time_largest_observed);
+  send_algorithm_->UpdateRtt(rtt_stats_.latest_rtt());
 }
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(
     QuicTime now,
     TransmissionType transmission_type,
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
   return send_algorithm_->TimeUntilSend(now, transmission_type, retransmittable,
                                         handshake);
 }
@@ skipping 33 matching lines @@
       // of the last pending packet which still has retransmittable frames.
       const QuicTime sent_time = unacked_packets_.GetLastPacketSentTime();
       const QuicTime tlp_time = sent_time.Add(GetTailLossProbeDelay());
       // Ensure the tlp timer never gets set to a time in the past.
       return QuicTime::Max(clock_->ApproximateNow(), tlp_time);
     }
     case RTO_MODE: {
       // The RTO is based on the first pending packet.
       const QuicTime sent_time =
           unacked_packets_.GetFirstPendingPacketSentTime();
-      // Always wait at least 1.5 * RTT after the first sent packet.
+      QuicTime rto_timeout = sent_time.Add(GetRetransmissionDelay());
+      // Always wait at least 1.5 * RTT from now.
       QuicTime min_timeout = clock_->ApproximateNow().Add(
           SmoothedRtt().Multiply(1.5));
-      QuicTime rto_timeout = sent_time.Add(GetRetransmissionDelay());
 
       return QuicTime::Max(min_timeout, rto_timeout);
     }
   }
   DCHECK(false);
   return QuicTime::Zero();
 }
 
 const QuicTime::Delta QuicSentPacketManager::GetCryptoRetransmissionDelay()
     const {
@@ skipping 32 matching lines @@
   retransmission_delay = retransmission_delay.Multiply(
       1 << min<size_t>(consecutive_rto_count_, kMaxRetransmissions));
 
   if (retransmission_delay.ToMilliseconds() > kMaxRetransmissionTimeMs) {
     return QuicTime::Delta::FromMilliseconds(kMaxRetransmissionTimeMs);
   }
   return retransmission_delay;
 }
 
 const QuicTime::Delta QuicSentPacketManager::SmoothedRtt() const {
-  return send_algorithm_->SmoothedRtt();
+  return rtt_stats_.SmoothedRtt();
 }
 
 QuicBandwidth QuicSentPacketManager::BandwidthEstimate() const {
   return send_algorithm_->BandwidthEstimate();
 }
 
 QuicByteCount QuicSentPacketManager::GetCongestionWindow() const {
   return send_algorithm_->GetCongestionWindow();
 }
 
 void QuicSentPacketManager::MaybeEnablePacing() {
   if (!FLAGS_enable_quic_pacing) {
     return;
   }
 
   if (using_pacing_) {
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net