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 79 matching lines @@
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {
 }
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.HasReceivedInitialRoundTripTimeUs() &&
       config.ReceivedInitialRoundTripTimeUs() > 0) {
     rtt_stats_.set_initial_rtt_us(min(kMaxInitialRoundTripTimeUs,
                                       config.ReceivedInitialRoundTripTimeUs()));
+  } else if (config.HasInitialRoundTripTimeUsToSend()) {
+    rtt_stats_.set_initial_rtt_us(
+        min(kMaxInitialRoundTripTimeUs,
+            config.GetInitialRoundTripTimeUsToSend()));
   }
   // TODO(ianswett): BBR is currently a server only feature.
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kTBBR)) {
     if (FLAGS_quic_recent_min_rtt_window_s > 0) {
       rtt_stats_.set_recent_min_rtt_window(
           QuicTime::Delta::FromSeconds(FLAGS_quic_recent_min_rtt_window_s));
     }
     send_algorithm_.reset(
         SendAlgorithmInterface::Create(clock_, &rtt_stats_, kBBR, stats_));
@@ skipping 193 matching lines @@
     MarkPacketRevived(*revived_it, delta_largest_observed);
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   return unacked_packets_.HasRetransmittableFrames(sequence_number);
 }
 
 void QuicSentPacketManager::RetransmitUnackedPackets(
-    RetransmissionType retransmission_type) {
+    TransmissionType retransmission_type) {
+  DCHECK(retransmission_type == ALL_UNACKED_RETRANSMISSION ||
+         retransmission_type == ALL_INITIAL_RETRANSMISSION);
   QuicPacketSequenceNumber sequence_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it, ++sequence_number) {
     const RetransmittableFrames* frames = it->retransmittable_frames;
-    // TODO(ianswett): Consider adding a new retransmission type which removes
-    // all these old packets from unacked and retransmits them as new sequence
-    // numbers with no connection to the previous ones.
-    if (frames != NULL && (retransmission_type == ALL_PACKETS ||
+    if (frames != NULL && (retransmission_type == ALL_UNACKED_RETRANSMISSION ||
                            frames->encryption_level() == ENCRYPTION_INITIAL)) {
-      MarkForRetransmission(sequence_number, ALL_UNACKED_RETRANSMISSION);
+      MarkForRetransmission(sequence_number, retransmission_type);
     }
   }
 }
 
 void QuicSentPacketManager::NeuterUnencryptedPackets() {
   QuicPacketSequenceNumber sequence_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it, ++sequence_number) {
     const RetransmittableFrames* frames = it->retransmittable_frames;
     if (frames != NULL && frames->encryption_level() == ENCRYPTION_NONE) {
@@ skipping 376 matching lines @@
 bool QuicSentPacketManager::MaybeUpdateRTT(
     const QuicAckFrame& ack_frame,
     const QuicTime& ack_receive_time) {
   if (!unacked_packets_.IsUnacked(ack_frame.largest_observed)) {
     return false;
   }
   // We calculate the RTT based on the highest ACKed sequence number, the lower
   // sequence numbers will include the ACK aggregation delay.
   const TransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(ack_frame.largest_observed);
-  // Don't update the RTT if it hasn't been sent.
+  // Ensure the packet has a valid sent time.
   if (transmission_info.sent_time == QuicTime::Zero()) {
+    LOG(DFATAL) << "Acked packet has zero sent time, largest_observed:"
+                << ack_frame.largest_observed;
     return false;
   }
 
   QuicTime::Delta send_delta =
       ack_receive_time.Subtract(transmission_info.sent_time);
   rtt_stats_.UpdateRtt(
       send_delta, ack_frame.delta_time_largest_observed, ack_receive_time);
   return true;
 }
 
@@ skipping 140 matching lines @@
 
   // 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