Landing 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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 60 matching lines @@
       is_server_(is_server),
       clock_(clock),
       stats_(stats),
       debug_delegate_(NULL),
       network_change_visitor_(NULL),
       send_algorithm_(SendAlgorithmInterface::Create(clock,
                                                      &rtt_stats_,
                                                      congestion_control_type,
                                                      stats)),
       loss_algorithm_(LossDetectionInterface::Create(loss_type)),
-      largest_observed_(0),
+      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),
       using_pacing_(false),
       handshake_confirmed_(false) {
 }
 
@@ skipping 14 matching lines @@
           QuicTime::Delta::FromSeconds(FLAGS_quic_recent_min_rtt_window_s));
     }
     send_algorithm_.reset(
         SendAlgorithmInterface::Create(clock_, &rtt_stats_, kBBR, stats_));
   }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kRENO)) {
     send_algorithm_.reset(
         SendAlgorithmInterface::Create(clock_, &rtt_stats_, kReno, stats_));
   }
-  if (config.HasReceivedConnectionOptions() &&
-      ContainsQuicTag(config.ReceivedConnectionOptions(), kPACE)) {
+  if (is_server_) {
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kPACE)) {
+      EnablePacing();
+    }
+  } else if (config.HasSendConnectionOptions() &&
+             ContainsQuicTag(config.SendConnectionOptions(), kPACE)) {
     EnablePacing();
   }
   // TODO(ianswett): Remove the "HasReceivedLossDetection" branch once
   // the ConnectionOptions code is live everywhere.
   if ((config.HasReceivedLossDetection() &&
        config.ReceivedLossDetection() == kTIME) ||
       (config.HasReceivedConnectionOptions() &&
        ContainsQuicTag(config.ReceivedConnectionOptions(), kTIME))) {
     loss_algorithm_.reset(LossDetectionInterface::Create(kTime));
   }
@@ skipping 44 matching lines @@
         new_sequence_number,
         transmission_type,
         clock_->ApproximateNow());
   }
 }
 
 void QuicSentPacketManager::OnIncomingAck(const QuicAckFrame& ack_frame,
                                           QuicTime ack_receive_time) {
   QuicByteCount bytes_in_flight = unacked_packets_.bytes_in_flight();
 
+  UpdatePacketInformationReceivedByPeer(ack_frame);
   // We rely on delta_time_largest_observed to compute an RTT estimate, so
   // we only update rtt when the largest observed gets acked.
   bool largest_observed_acked = MaybeUpdateRTT(ack_frame, ack_receive_time);
-  if (largest_observed_ < ack_frame.largest_observed) {
-    largest_observed_ = ack_frame.largest_observed;
-    unacked_packets_.IncreaseLargestObserved(largest_observed_);
-  }
+  DCHECK_GE(ack_frame.largest_observed, unacked_packets_.largest_observed());
+  unacked_packets_.IncreaseLargestObserved(ack_frame.largest_observed);
+
   HandleAckForSentPackets(ack_frame);
   InvokeLossDetection(ack_receive_time);
   MaybeInvokeCongestionEvent(largest_observed_acked, bytes_in_flight);
 
+  sustained_bandwidth_recorder_.RecordEstimate(
+      send_algorithm_->InRecovery(),
+      send_algorithm_->InSlowStart(),
+      send_algorithm_->BandwidthEstimate(),
+      ack_receive_time,
+      clock_->WallNow(),
+      rtt_stats_.SmoothedRtt());
+
   // If we have received a truncated ack, then we need to clear out some
   // previous transmissions to allow the peer to actually ACK new packets.
   if (ack_frame.is_truncated) {
     unacked_packets_.ClearPreviousRetransmissions(
         ack_frame.missing_packets.size() / 2);
   }
 
   // Anytime we are making forward progress and have a new RTT estimate, reset
   // the backoff counters.
   if (largest_observed_acked) {
     // Reset all retransmit counters any time a new packet is acked.
     consecutive_rto_count_ = 0;
     consecutive_tlp_count_ = 0;
     consecutive_crypto_retransmission_count_ = 0;
   }
 
   if (debug_delegate_ != NULL) {
     debug_delegate_->OnIncomingAck(ack_frame,
                                    ack_receive_time,
-                                   largest_observed_,
+                                   unacked_packets_.largest_observed(),
                                    largest_observed_acked,
                                    GetLeastUnackedSentPacket());
   }
 }
 
+void QuicSentPacketManager::UpdatePacketInformationReceivedByPeer(
+    const QuicAckFrame& ack_frame) {
+  if (ack_frame.missing_packets.empty()) {
+    least_packet_awaited_by_peer_ = ack_frame.largest_observed + 1;
+  } else {
+    least_packet_awaited_by_peer_ = *(ack_frame.missing_packets.begin());
+  }
+}
+
 void QuicSentPacketManager::MaybeInvokeCongestionEvent(
     bool rtt_updated, QuicByteCount bytes_in_flight) {
   if (!rtt_updated && packets_acked_.empty() && packets_lost_.empty()) {
     return;
   }
   send_algorithm_->OnCongestionEvent(rtt_updated, bytes_in_flight,
                                      packets_acked_, packets_lost_);
   packets_acked_.clear();
   packets_lost_.clear();
   if (network_change_visitor_ != NULL) {
@@ skipping 266 matching lines @@
   return unacked_packets_.GetLeastUnackedSentPacket();
 }
 
 bool QuicSentPacketManager::OnPacketSent(
     QuicPacketSequenceNumber sequence_number,
     QuicTime sent_time,
     QuicByteCount bytes,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   DCHECK_LT(0u, sequence_number);
+  DCHECK(unacked_packets_.IsUnacked(sequence_number));
   LOG_IF(DFATAL, bytes == 0) << "Cannot send empty packets.";
   if (pending_timer_transmission_count_ > 0) {
     --pending_timer_transmission_count_;
   }
-  // In rare circumstances, the packet could be serialized, sent, and then acked
-  // before OnPacketSent is called.
-  if (!unacked_packets_.IsUnacked(sequence_number)) {
-    return false;
-  }
 
   if (unacked_packets_.bytes_in_flight() == 0) {
     // TODO(ianswett): Consider being less aggressive to force a new
     // recent_min_rtt, likely by not discarding a relatively new sample.
     DVLOG(1) << "Sampling a new recent min rtt within 2 samples. currently:"
              << rtt_stats_.recent_min_rtt().ToMilliseconds() << "ms";
     rtt_stats_.SampleNewRecentMinRtt(kNumMinRttSamplesAfterQuiescence);
   }
 
   // Only track packets as in flight that the send algorithm wants us to track.
@@ skipping 150 matching lines @@
     const QuicCongestionFeedbackFrame& frame,
     const QuicTime& feedback_receive_time) {
   send_algorithm_->OnIncomingQuicCongestionFeedbackFrame(
       frame, feedback_receive_time);
 }
 
 void QuicSentPacketManager::InvokeLossDetection(QuicTime time) {
   SequenceNumberSet lost_packets =
       loss_algorithm_->DetectLostPackets(unacked_packets_,
                                          time,
-                                         largest_observed_,
+                                         unacked_packets_.largest_observed(),
                                          rtt_stats_);
   for (SequenceNumberSet::const_iterator it = lost_packets.begin();
        it != lost_packets.end(); ++it) {
     QuicPacketSequenceNumber sequence_number = *it;
     const TransmissionInfo& transmission_info =
         unacked_packets_.GetTransmissionInfo(sequence_number);
     // 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;
@@ skipping 150 matching lines @@
 }
 
 QuicBandwidth QuicSentPacketManager::BandwidthEstimate() const {
   return send_algorithm_->BandwidthEstimate();
 }
 
 bool QuicSentPacketManager::HasReliableBandwidthEstimate() const {
   return send_algorithm_->HasReliableBandwidthEstimate();
 }
 
+const QuicSustainedBandwidthRecorder&
+QuicSentPacketManager::SustainedBandwidthRecorder() const {
+  return sustained_bandwidth_recorder_;
+}
+
 QuicByteCount QuicSentPacketManager::GetCongestionWindow() const {
   return send_algorithm_->GetCongestionWindow();
 }
 
 QuicByteCount QuicSentPacketManager::GetSlowStartThreshold() const {
   return send_algorithm_->GetSlowStartThreshold();
 }
 
 void QuicSentPacketManager::EnablePacing() {
   if (using_pacing_) {
     return;
   }
 
   // Set up a pacing sender with a 5 millisecond alarm granularity.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(5),
                        kInitialUnpacedBurst));
 }
 
 }  // namespace net