Change the wire format of the ack frame to include a compressed version

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"
+#include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_connection_stats.h"
 
 using std::make_pair;
 using std::max;
 using std::min;
+using std::numeric_limits;
 
 namespace net {
 
 namespace {
 
 // The maximum number of packets to ack immediately after a missing packet for
 // fast retransmission to kick in at the sender.  This limit is created to
 // reduce the number of acks sent that have no benefit for fast retransmission.
 // Set to the number of nacks needed for fast retransmit plus one for protection
 // against an ack loss
@@ skipping 96 matching lines @@
 
 void QuicReceivedPacketManager::EntropyTracker::
 AdvanceFirstGapAndGarbageCollectEntropyMap() {
   while (!packets_entropy_.empty() && packets_entropy_.front().second) {
     ++first_gap_;
     packets_entropy_.pop_front();
   }
 }
 
 QuicReceivedPacketManager::QuicReceivedPacketManager(
-    CongestionFeedbackType congestion_type,
     QuicConnectionStats* stats)
     : peer_least_packet_awaiting_ack_(0),
       time_largest_observed_(QuicTime::Zero()),
-      receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)),
+      receive_algorithm_(ReceiveAlgorithmInterface::Create(kTCP)),
       stats_(stats) {
   ack_frame_.largest_observed = 0;
   ack_frame_.entropy_hash = 0;
 }
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
     QuicByteCount bytes,
     const QuicPacketHeader& header,
@@ skipping 25 matching lines @@
   if (sequence_number > ack_frame_.largest_observed) {
     ack_frame_.largest_observed = sequence_number;
     time_largest_observed_ = receipt_time;
   }
   entropy_tracker_.RecordPacketEntropyHash(sequence_number,
                                            header.entropy_hash);
 
   receive_algorithm_->RecordIncomingPacket(
       bytes, sequence_number, receipt_time);
 
+  received_packet_times_.push_back(
+      std::make_pair(sequence_number, receipt_time));
+
   ack_frame_.revived_packets.erase(sequence_number);
 }
 
 void QuicReceivedPacketManager::RecordPacketRevived(
     QuicPacketSequenceNumber sequence_number) {
   LOG_IF(DFATAL, !IsAwaitingPacket(sequence_number));
   ack_frame_.revived_packets.insert(sequence_number);
 }
 
 bool QuicReceivedPacketManager::IsMissing(
@@ skipping 18 matching lines @@
   }
 
   if (approximate_now < time_largest_observed_) {
     // Approximate now may well be "in the past".
     ack_frame->delta_time_largest_observed = QuicTime::Delta::Zero();
     return;
   }
 
   ack_frame->delta_time_largest_observed =
       approximate_now.Subtract(time_largest_observed_);
+
+  // Remove all packets that are too far from largest_observed to express.
+  received_packet_times_.remove_if(
+      [this] (std::pair<QuicPacketSequenceNumber, QuicTime> p)
+      { return ack_frame_.largest_observed - p.first >=
+        numeric_limits<uint8>::max();});
+
+  ack_frame->received_packet_times = received_packet_times_;
+  received_packet_times_.clear();
 }
 
 bool QuicReceivedPacketManager::GenerateCongestionFeedback(
     QuicCongestionFeedbackFrame* feedback) {
   return receive_algorithm_->GenerateCongestionFeedback(feedback);
 }
 
 QuicPacketEntropyHash QuicReceivedPacketManager::EntropyHash(
     QuicPacketSequenceNumber sequence_number) const {
   return entropy_tracker_.EntropyHash(sequence_number);
@@ skipping 31 matching lines @@
              peer_least_packet_awaiting_ack_);
 }
 
 bool QuicReceivedPacketManager::HasNewMissingPackets() {
   return !ack_frame_.missing_packets.empty() &&
       (ack_frame_.largest_observed -
        *ack_frame_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
 }
 
 }  // namespace net