Change QUIC to only ack every other packet when there are no losses

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"
 
 using std::make_pair;
 using std::max;
 using std::min;
 
 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
+const size_t kMaxPacketsAfterNewMissing = 4;
+
+}
+
 QuicReceivedPacketManager::QuicReceivedPacketManager(
     CongestionFeedbackType congestion_type)
     : packets_entropy_hash_(0),
       largest_sequence_number_(0),
       peer_largest_observed_packet_(0),
       least_packet_awaited_by_peer_(1),
       peer_least_packet_awaiting_ack_(0),
       time_largest_observed_(QuicTime::Zero()),
       receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)) {
   received_info_.largest_observed = 0;
@@ skipping 27 matching lines @@
   }
   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, revived);
   }
 }
 
+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);
 }
 
 void QuicReceivedPacketManager::UpdateReceivedPacketInfo(
     ReceivedPacketInfo* received_info,
     QuicTime approximate_now) {
   *received_info = received_info_;
   received_info->entropy_hash = EntropyHash(received_info_.largest_observed);
@@ skipping 133 matching lines @@
   }
   DCHECK(received_info_.missing_packets.empty() ||
          *received_info_.missing_packets.begin() >=
              peer_least_packet_awaiting_ack_);
 }
 
 bool QuicReceivedPacketManager::HasMissingPackets() {
   return !received_info_.missing_packets.empty();
 }
 
+bool QuicReceivedPacketManager::HasNewMissingPackets() {
+  return HasMissingPackets() &&
+      (received_info_.largest_observed -
+       *received_info_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
+}
+
 }  // namespace net