Optionally defer responding to a QUIC ACK until all ACK processing has completed for an EpollServer…

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>
@@ skipping 111 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RetransmissionAlarm);
 };
 
 // An alarm that is scheduled when the SentPacketManager requires a delay
 // before sending packets and fires when the packet may be sent.
 class SendAlarm : public QuicAlarm::Delegate {
  public:
   explicit SendAlarm(QuicConnection* connection) : connection_(connection) {}
 
   QuicTime OnAlarm() override {
-    connection_->WriteIfNotBlocked();
+    connection_->WriteAndBundleAcksIfNotBlocked();
     // Never reschedule the alarm, since CanWrite does that.
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(SendAlarm);
 };
 
@@ skipping 134 matching lines @@
       silent_close_enabled_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_retransmittable_packets_received_since_last_ack_sent_(0),
       last_ack_had_missing_packets_(false),
       num_packets_received_since_last_ack_sent_(0),
       stop_waiting_count_(0),
       ack_mode_(TCP_ACKING),
       delay_setting_retransmission_alarm_(false),
       pending_retransmission_alarm_(false),
+      defer_send_in_response_to_packets_(false),
       arena_(),
       ack_alarm_(helper->CreateAlarm(arena_.New<AckAlarm>(this), &arena_)),
       retransmission_alarm_(
           helper->CreateAlarm(arena_.New<RetransmissionAlarm>(this), &arena_)),
       send_alarm_(helper->CreateAlarm(arena_.New<SendAlarm>(this), &arena_)),
       resume_writes_alarm_(
           helper->CreateAlarm(arena_.New<SendAlarm>(this), &arena_)),
       timeout_alarm_(
           helper->CreateAlarm(arena_.New<TimeoutAlarm>(this), &arena_)),
       ping_alarm_(helper->CreateAlarm(arena_.New<PingAlarm>(this), &arena_)),
@@ skipping 831 matching lines @@
 }
 
 QuicPacketNumber QuicConnection::GetLeastUnacked() const {
   return sent_packet_manager_.GetLeastUnacked();
 }
 
 void QuicConnection::MaybeSendInResponseToPacket() {
   if (!connected_) {
     return;
   }
-  ScopedPacketBundler bundler(this, ack_queued_ ? SEND_ACK : NO_ACK);
-
   // Now that we have received an ack, we might be able to send packets which
   // are queued locally, or drain streams which are blocked.
-  WriteIfNotBlocked();
+  if (defer_send_in_response_to_packets_) {
+    send_alarm_->Cancel();
+    send_alarm_->Set(clock_->ApproximateNow());
+  } else {
+    WriteAndBundleAcksIfNotBlocked();
+  }
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
   // TODO(alyssar): implement zero server state negotiation.
   pending_version_negotiation_packet_ = true;
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return;
   }
   DVLOG(1) << ENDPOINT << "Sending version negotiation packet: {"
@@ skipping 240 matching lines @@
     resume_writes_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 void QuicConnection::WriteIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     OnCanWrite();
   }
 }
 
+void QuicConnection::WriteAndBundleAcksIfNotBlocked() {
+  if (!writer_->IsWriteBlocked()) {
+    ScopedPacketBundler bundler(this, ack_queued_ ? SEND_ACK : NO_ACK);
+    OnCanWrite();
+  }
+}
+
 bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) {
   if (FLAGS_check_peer_address_change_after_decryption) {
     if (perspective_ == Perspective::IS_SERVER &&
         IsInitializedIPEndPoint(self_address_) &&
         IsInitializedIPEndPoint(last_packet_destination_address_) &&
         (!(self_address_ == last_packet_destination_address_))) {
       SendConnectionCloseWithDetails(
           QUIC_ERROR_MIGRATING_ADDRESS,
           "Self address migration is not supported at the server.");
       return false;
@@ skipping 1094 matching lines @@
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net