Simplify QuicUnackedPacketMap to expose AddSentPacket, instead of

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 16 matching lines @@
        it != unacked_packets_.end(); ++it, ++index) {
     delete it->retransmittable_frames;
     // Only delete all_transmissions once, for the newest packet.
     if (it->all_transmissions != nullptr &&
         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_GE(serialized_packet.sequence_number,
-            least_unacked_ + unacked_packets_.size());
-  while (least_unacked_ + unacked_packets_.size() <
-         serialized_packet.sequence_number) {
+void QuicUnackedPacketMap::AddSentPacket(
+    const SerializedPacket& packet,
+    QuicPacketSequenceNumber old_sequence_number,
+    TransmissionType transmission_type,
+    QuicTime sent_time,
+    QuicByteCount bytes_sent,
+    bool set_in_flight) {
+  QuicPacketSequenceNumber sequence_number = packet.sequence_number;
+  DCHECK_LT(largest_sent_packet_, sequence_number);
+  DCHECK_GE(sequence_number, least_unacked_ + unacked_packets_.size());
+  while (least_unacked_ + unacked_packets_.size() < 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 != nullptr &&
-      serialized_packet.retransmittable_frames->HasCryptoHandshake() ==
-          IS_HANDSHAKE) {
-    ++pending_crypto_packet_count_;
+
+  TransmissionInfo info;
+  if (old_sequence_number == 0) {
+    if (packet.retransmittable_frames != nullptr &&
+        packet.retransmittable_frames->HasCryptoHandshake() == IS_HANDSHAKE) {
+      ++pending_crypto_packet_count_;
+    }
+    info = TransmissionInfo(packet.retransmittable_frames,
+                            packet.sequence_number_length);
+  } else {
+    info = OnRetransmittedPacket(
+        old_sequence_number, sequence_number, transmission_type);
   }
+  info.sent_time = sent_time;
+
+  largest_sent_packet_ = max(sequence_number, largest_sent_packet_);
+  if (set_in_flight) {
+    bytes_in_flight_ += bytes_sent;
+    info.bytes_sent = bytes_sent;
+    info.in_flight = true;
+  }
+  unacked_packets_.push_back(info);
 }
 
 void QuicUnackedPacketMap::RemoveObsoletePackets() {
   while (!unacked_packets_.empty()) {
     if (!IsPacketRemovable(least_unacked_, unacked_packets_.front())) {
       break;
     }
     unacked_packets_.pop_front();
     ++least_unacked_;
   }
 }
 
-void QuicUnackedPacketMap::OnRetransmittedPacket(
+TransmissionInfo 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_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;
-  }
+  DCHECK_NE(NOT_RETRANSMISSION, transmission_type);
 
   // 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;
+  transmission_info->retransmittable_frames = nullptr;
   LOG_IF(DFATAL, frames == nullptr)
       << "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
-  // the retransmissions of it are acked.
-  transmission_info->retransmittable_frames = nullptr;
   // Only keep one transmission older than largest observed, because only the
   // most recent is expected to possibly be a spurious retransmission.
   while (transmission_info->all_transmissions != nullptr &&
          transmission_info->all_transmissions->size() > 1 &&
          *(++transmission_info->all_transmissions->begin()) <
              largest_observed_) {
     QuicPacketSequenceNumber old_transmission =
         *transmission_info->all_transmissions->begin();
     TransmissionInfo* old_info =
         &unacked_packets_[old_transmission - least_unacked_];
@@ skipping 10 matching lines @@
   if (transmission_type == ALL_INITIAL_RETRANSMISSION ||
       transmission_type == ALL_UNACKED_RETRANSMISSION) {
     RemoveAckability(transmission_info);
   } else {
     if (transmission_info->all_transmissions == nullptr) {
       transmission_info->all_transmissions = new SequenceNumberList();
       transmission_info->all_transmissions->push_back(old_sequence_number);
     }
     transmission_info->all_transmissions->push_back(new_sequence_number);
   }
-  unacked_packets_.push_back(
+  TransmissionInfo info =
       TransmissionInfo(frames,
                        transmission_info->sequence_number_length,
                        transmission_type,
-                       transmission_info->all_transmissions));
+                       transmission_info->all_transmissions);
+  // Proactively remove obsolete packets so the least unacked can be raised.
   RemoveObsoletePackets();
+  return info;
 }
 
 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 != nullptr) {
       break;
@@ skipping 212 matching lines @@
     }
   }
   return false;
 }
 
 QuicPacketSequenceNumber
 QuicUnackedPacketMap::GetLeastUnacked() const {
   return least_unacked_;
 }
 
-void QuicUnackedPacketMap::SetSent(QuicPacketSequenceNumber sequence_number,
-                                   QuicTime sent_time,
-                                   QuicByteCount bytes_sent,
-                                   bool set_in_flight) {
-  DCHECK_GE(sequence_number, least_unacked_);
-  DCHECK_LT(sequence_number, least_unacked_ + unacked_packets_.size());
-  TransmissionInfo* info = &unacked_packets_[sequence_number - least_unacked_];
-  DCHECK(!info->in_flight);
-
-  DCHECK_LT(largest_sent_packet_, sequence_number);
-  largest_sent_packet_ = max(sequence_number, largest_sent_packet_);
-  info->sent_time = sent_time;
-  if (set_in_flight) {
-    bytes_in_flight_ += bytes_sent;
-    info->bytes_sent = bytes_sent;
-    info->in_flight = true;
-  }
-}
-
 void QuicUnackedPacketMap::RestoreInFlight(
     QuicPacketSequenceNumber sequence_number) {
   DCHECK_GE(sequence_number, least_unacked_);
   DCHECK_LT(sequence_number, least_unacked_ + unacked_packets_.size());
   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