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

net/quic/quic_connection.cc

 // Copyright (c) 2012 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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 641 matching lines @@
              << last_goaway_frames_.size() << " goaways, "
              << last_rst_frames_.size() << " rsts, "
              << last_close_frames_.size() << " closes, "
              << last_stream_frames_.size()
              << " stream frames for " << last_header_.public_header.guid;
 
   // Must called before ack processing, because processing acks removes entries
   // from unacket_packets_, increasing the least_unacked.
   const bool last_packet_should_instigate_ack = ShouldLastPacketInstigateAck();
 
-  // If we are missing any packets from the peer, then we want to ack
-  // immediately.  We need to check both before and after we process the
-  // current packet because we want to ack immediately when we discover
-  // a missing packet AND when we receive the last missing packet.
-  bool send_ack_immediately = received_packet_manager_.HasMissingPackets();
+  // If the incoming packet was missing, send an ack immediately.
+  bool send_ack_immediately = received_packet_manager_.IsMissing(
+      last_header_.packet_sequence_number);
 
   // Ensure the visitor can process the stream frames before recording and
   // processing the rest of the packet.
   if (last_stream_frames_.empty() ||
       visitor_->OnStreamFrames(last_stream_frames_)) {
     received_packet_manager_.RecordPacketReceived(last_size_,
                                                   last_header_,
                                                   time_of_last_received_packet_,
                                                   last_packet_revived_);
     for (size_t i = 0; i < last_stream_frames_.size(); ++i) {
@@ skipping 14 matching lines @@
   }
   for (size_t i = 0; i < last_congestion_frames_.size(); ++i) {
     sent_packet_manager_.OnIncomingQuicCongestionFeedbackFrame(
         last_congestion_frames_[i], time_of_last_received_packet_);
   }
   if (!last_close_frames_.empty()) {
     CloseConnection(last_close_frames_[0].error_code, true);
     DCHECK(!connected_);
   }
 
-  if (received_packet_manager_.HasMissingPackets()) {
+  // If there are new missing packets to report, send an ack immediately.
+  if (received_packet_manager_.HasNewMissingPackets()) {
     send_ack_immediately = true;
   }
 
   MaybeSendInResponseToPacket(send_ack_immediately,
                               last_packet_should_instigate_ack);
 
   ClearLastFrames();
 }
 
 void QuicConnection::ClearLastFrames() {
@@ skipping 977 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net