Update from chromium https://crrev.com/302282

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 24 matching lines @@
 }
 
 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);
+  LOG_IF(DFATAL, 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;
   }
 
-  TransmissionInfo info;
+  TransmissionInfo info(packet.retransmittable_frames,
+                        packet.sequence_number_length,
+                        transmission_type,
+                        sent_time);
   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);
+    TransferRetransmissionInfo(
+        old_sequence_number, sequence_number, transmission_type, &info);
   }
-  info.sent_time = sent_time;
 
-  largest_sent_packet_ = max(sequence_number, largest_sent_packet_);
+  largest_sent_packet_ = sequence_number;
   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_;
   }
 }
 
-TransmissionInfo QuicUnackedPacketMap::OnRetransmittedPacket(
+void QuicUnackedPacketMap::TransferRetransmissionInfo(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number,
-    TransmissionType transmission_type) {
+    TransmissionType transmission_type,
+    TransmissionInfo* info) {
   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());
   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;
@@ skipping 24 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);
   }
-  TransmissionInfo info =
-      TransmissionInfo(frames,
-                       transmission_info->sequence_number_length,
-                       transmission_type,
-                       transmission_info->all_transmissions);
+  info->retransmittable_frames = frames;
+  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 226 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