Add QUIC_VERSION_15 to add a revived_packets set to replace the

net/quic/quic_received_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_received_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/linked_hash_map.h"
 
@@ skipping 25 matching lines @@
       receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)) {
   received_info_.largest_observed = 0;
   received_info_.entropy_hash = 0;
 }
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
     QuicByteCount bytes,
     const QuicPacketHeader& header,
-    QuicTime receipt_time,
-    bool revived) {
+    QuicTime receipt_time) {
   QuicPacketSequenceNumber sequence_number = header.packet_sequence_number;
   DCHECK(IsAwaitingPacket(sequence_number));
 
   InsertMissingPacketsBetween(
       &received_info_,
       max(received_info_.largest_observed + 1, peer_least_packet_awaiting_ack_),
       header.packet_sequence_number);
 
   if (received_info_.largest_observed > header.packet_sequence_number) {
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing " << sequence_number << " from missing list";
     received_info_.missing_packets.erase(sequence_number);
   }
   if (header.packet_sequence_number > received_info_.largest_observed) {
     received_info_.largest_observed = header.packet_sequence_number;
     time_largest_observed_ = receipt_time;
   }
   RecordPacketEntropyHash(sequence_number, header.entropy_hash);
 
-  // Don't update the receive algorithm for revived packets.
-  if (!revived) {
-    receive_algorithm_->RecordIncomingPacket(
-        bytes, sequence_number, receipt_time);
-  }
+  receive_algorithm_->RecordIncomingPacket(
+      bytes, sequence_number, receipt_time);
+}
+
+void QuicReceivedPacketManager::RecordPacketRevived(
+    QuicPacketSequenceNumber sequence_number) {
+  LOG_IF(DFATAL, !IsAwaitingPacket(sequence_number));
+  received_info_.revived_packets.insert(sequence_number);
 }
 
 bool QuicReceivedPacketManager::IsMissing(
     QuicPacketSequenceNumber sequence_number) {
   return ContainsKey(received_info_.missing_packets, sequence_number);
 }
 
 bool QuicReceivedPacketManager::IsAwaitingPacket(
     QuicPacketSequenceNumber sequence_number) {
   return ::net::IsAwaitingPacket(received_info_, sequence_number);
@@ skipping 106 matching lines @@
   if (incoming_ack.received_info.missing_packets.empty()) {
     least_packet_awaited_by_peer_ = peer_largest_observed_packet_ + 1;
   } else {
     least_packet_awaited_by_peer_ =
         *(incoming_ack.received_info.missing_packets.begin());
   }
 }
 
 bool QuicReceivedPacketManager::DontWaitForPacketsBefore(
     QuicPacketSequenceNumber least_unacked) {
+  received_info_.revived_packets.erase(
+      received_info_.revived_packets.begin(),
+      received_info_.revived_packets.lower_bound(least_unacked));
   size_t missing_packets_count = received_info_.missing_packets.size();
   received_info_.missing_packets.erase(
       received_info_.missing_packets.begin(),
       received_info_.missing_packets.lower_bound(least_unacked));
   return missing_packets_count != received_info_.missing_packets.size();
 }
 
 void QuicReceivedPacketManager::UpdatePacketInformationSentByPeer(
     const QuicAckFrame& incoming_ack) {
   // ValidateAck() should fail if peer_least_packet_awaiting_ack_ shrinks.
@@ skipping 21 matching lines @@
   return !received_info_.missing_packets.empty();
 }
 
 bool QuicReceivedPacketManager::HasNewMissingPackets() {
   return HasMissingPackets() &&
       (received_info_.largest_observed -
        *received_info_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
 }
 
 }  // namespace net