Call QuicSentPacketManager's OnPacketSerialized or OnRetransmittedPacket

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 20 matching lines @@
         index == *it->all_transmissions->rbegin()) {
       delete it->all_transmissions;
     }
   }
 }
 
 // TODO(ianswett): Combine this method with OnPacketSent once packets are always
 // sent in order and the connection tracks RetransmittableFrames for longer.
 void QuicUnackedPacketMap::AddPacket(
     const SerializedPacket& serialized_packet) {
-  DCHECK_EQ(least_unacked_ + unacked_packets_.size(),
-            serialized_packet.sequence_number);
+  DCHECK_GE(serialized_packet.sequence_number,
+            least_unacked_ + unacked_packets_.size());
+  while (least_unacked_ + unacked_packets_.size() <
+         serialized_packet.sequence_number) {
+    unacked_packets_.push_back(TransmissionInfo());
+    unacked_packets_.back().is_unackable = true;
+  }
   unacked_packets_.push_back(
       TransmissionInfo(serialized_packet.retransmittable_frames,
                        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 (!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,
     QuicPacketSequenceNumber new_sequence_number,
     TransmissionType transmission_type) {
   DCHECK_GE(old_sequence_number, least_unacked_);
   DCHECK_LT(old_sequence_number, least_unacked_ + unacked_packets_.size());
-  DCHECK_EQ(least_unacked_ + unacked_packets_.size(), new_sequence_number);
+  DCHECK_GE(new_sequence_number, least_unacked_ + unacked_packets_.size());
+  while (least_unacked_ + unacked_packets_.size() < new_sequence_number) {
+    unacked_packets_.push_back(TransmissionInfo());
+    unacked_packets_.back().is_unackable = true;
+  }
 
   // TODO(ianswett): Discard and lose the packet lazily instead of immediately.
   TransmissionInfo* transmission_info =
       &unacked_packets_.at(old_sequence_number - least_unacked_);
   RetransmittableFrames* frames = transmission_info->retransmittable_frames;
   LOG_IF(DFATAL, frames == NULL) << "Attempt to retransmit packet with no "
                                  << "retransmittable frames: "
                                  << old_sequence_number;
 
   // We keep the old packet in the unacked packet list until it, or one of
@@ skipping 137 matching lines @@
 
 void QuicUnackedPacketMap::IncreaseLargestObserved(
     QuicPacketSequenceNumber largest_observed) {
   DCHECK_LE(largest_observed_, largest_observed);
   largest_observed_ = largest_observed;
 }
 
 bool QuicUnackedPacketMap::IsPacketUseless(
     QuicPacketSequenceNumber sequence_number,
     const TransmissionInfo& info) const {
-  return sequence_number <= largest_observed_ &&
+  return (info.is_unackable || 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 (info.is_unackable ||
           sequence_number <= largest_observed_ ||
@@ skipping 135 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