Landing Recent QUIC Changes.

net/quic/quic_unacked_packet_map.cc

 // Copyright 2014 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_unacked_packet_map.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_utils_chromium.h"
@@ skipping 34 matching lines @@
                        serialized_packet.sequence_number_length));
   if (serialized_packet.retransmittable_frames != NULL &&
       serialized_packet.retransmittable_frames->HasCryptoHandshake()
           == IS_HANDSHAKE) {
     ++pending_crypto_packet_count_;
   }
 }
 
 void QuicUnackedPacketMap::RemoveObsoletePackets() {
   while (!unacked_packets_.empty()) {
-    if (!IsPacketUseless(least_unacked_, unacked_packets_.front())) {
+    if (!IsPacketRemovable(least_unacked_, unacked_packets_.front())) {
       break;
     }
     delete unacked_packets_.front().all_transmissions;
     unacked_packets_.pop_front();
     ++least_unacked_;
   }
 }
 
 void QuicUnackedPacketMap::OnRetransmittedPacket(
     QuicPacketSequenceNumber old_sequence_number,
@@ skipping 34 matching lines @@
     transmission_info->all_transmissions->push_back(old_sequence_number);
   }
   transmission_info->all_transmissions->push_back(new_sequence_number);
   unacked_packets_.push_back(
       TransmissionInfo(frames,
                        transmission_info->sequence_number_length,
                        transmission_type,
                        transmission_info->all_transmissions));
 }
 
-void QuicUnackedPacketMap::ClearPreviousRetransmissions(size_t num_to_clear) {
-  while (!unacked_packets_.empty() && num_to_clear > 0) {
+void QuicUnackedPacketMap::ClearAllPreviousRetransmissions() {
+  while (!unacked_packets_.empty() && least_unacked_ < largest_observed_) {
     // If this packet is in flight, or has retransmittable data, then there is
     // no point in clearing out any further packets, because they would not
     // affect the high water mark.
     TransmissionInfo* info = &unacked_packets_.front();
     if (info->in_flight || info->retransmittable_frames != NULL) {
       break;
     }
 
-    info->all_transmissions->pop_front();
-    LOG_IF(DFATAL, info->all_transmissions->empty())
-        << "Previous retransmissions must have a newer transmission.";
+    if (info->all_transmissions != NULL) {
+      if (info->all_transmissions->size() < 2) {
+        LOG(DFATAL) << "all_transmissions must be NULL or have multiple "
+                    << "elements.  size:" << info->all_transmissions->size();
+        delete info->all_transmissions;
+      } else {
+        info->all_transmissions->pop_front();
+        if (info->all_transmissions->size() == 1) {
+          // Set the newer transmission's 'all_transmissions' entry to NULL.
+          QuicPacketSequenceNumber new_transmission =
+              info->all_transmissions->front();
+          TransmissionInfo* new_info =
+              &unacked_packets_.at(new_transmission - least_unacked_);
+          delete new_info->all_transmissions;
+          new_info->all_transmissions = NULL;
+        }
+      }
+    }
     unacked_packets_.pop_front();
     ++least_unacked_;
-    --num_to_clear;
   }
 }
 
 bool QuicUnackedPacketMap::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK_GE(sequence_number, least_unacked_);
   DCHECK_LT(sequence_number, least_unacked_ + unacked_packets_.size());
   return unacked_packets_[
       sequence_number - least_unacked_].retransmittable_frames != NULL;
 }
@@ skipping 49 matching lines @@
 
 bool QuicUnackedPacketMap::IsPacketUseless(
     QuicPacketSequenceNumber sequence_number,
     const TransmissionInfo& info) const {
   return sequence_number <= largest_observed_ &&
       !info.in_flight &&
       info.retransmittable_frames == NULL &&
       info.all_transmissions == NULL;
 }
 
+bool QuicUnackedPacketMap::IsPacketRemovable(
+    QuicPacketSequenceNumber sequence_number,
+    const TransmissionInfo& info) const {
+  return (sequence_number <= largest_observed_ ||
+          unacked_packets_.size() > kMaxTcpCongestionWindow) &&
+      !info.in_flight &&
+      info.retransmittable_frames == NULL &&
+      info.all_transmissions == NULL;
+}
+
 bool QuicUnackedPacketMap::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   if (sequence_number < least_unacked_ ||
       sequence_number >= least_unacked_ + unacked_packets_.size()) {
     return false;
   }
   return !IsPacketUseless(sequence_number,
                           unacked_packets_[sequence_number - least_unacked_]);
 }
 
@@ skipping 119 matching lines @@
   TransmissionInfo* info = &unacked_packets_[sequence_number - least_unacked_];
   DCHECK(!info->in_flight);
   DCHECK_NE(0u, info->bytes_sent);
   DCHECK(info->sent_time.IsInitialized());
 
   bytes_in_flight_ += info->bytes_sent;
   info->in_flight = true;
 }
 
 }  // namespace net