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

net/quic/quic_connection.h

 // 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 396 matching lines @@
   // writes to happen.
   void OnCanWrite() override;
 
   // Called when an error occurs while attempting to write a packet to the
   // network.
   void OnWriteError(int error_code);
 
   // If the socket is not blocked, writes queued packets.
   void WriteIfNotBlocked();
 
+  // If the socket is not blocked, writes queued packets and bundles any pending
+  // ACKs.
+  void WriteAndBundleAcksIfNotBlocked();
+
   // Set the packet writer.
   void SetQuicPacketWriter(QuicPacketWriter* writer, bool owns_writer) {
     DCHECK(writer != nullptr);
     if (writer_ != nullptr && owns_writer_) {
       delete writer_;
     }
     writer_ = writer;
     owns_writer_ = owns_writer;
   }
 
@@ skipping 279 matching lines @@
 
   // Returns the current per-packet options for the connection.
   PerPacketOptions* per_packet_options() { return per_packet_options_; }
   // Sets the current per-packet options for the connection. The QuicConnection
   // does not take ownership of |options|; |options| must live for as long as
   // the QuicConnection is in use.
   void set_per_packet_options(PerPacketOptions* options) {
     per_packet_options_ = options;
   }
 
+  // If |defer| is true, configures the connection to defer sending packets in
+  // response to an ACK to the SendAlarm. If |defer| is false, packets may be
+  // sent immediately after receiving an ACK.
+  void set_defer_send_in_response_to_packets(bool defer) {
+    defer_send_in_response_to_packets_ = defer;
+  }
+
  private:
   friend class test::QuicConnectionPeer;
   friend class test::PacketSavingConnection;
 
   typedef std::list<SerializedPacket> QueuedPacketList;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
 
   // Writes the given packet to socket, encrypted with packet's
   // encryption_level. Returns true on successful write, and false if the writer
   // was blocked and the write needs to be tried again. Notifies the
@@ skipping 204 matching lines @@
   int stop_waiting_count_;
   // Indicates the current ack mode, defaults to acking every 2 packets.
   AckMode ack_mode_;
 
   // Indicates the retransmit alarm is going to be set by the
   // ScopedRetransmitAlarmDelayer
   bool delay_setting_retransmission_alarm_;
   // Indicates the retransmission alarm needs to be set.
   bool pending_retransmission_alarm_;
 
+  // If true, defer sending data in response to received packets to the
+  // SendAlarm.
+  bool defer_send_in_response_to_packets_;
+
   // Arena to store class implementations within the QuicConnection.
   QuicConnectionArena arena_;
 
   // An alarm that fires when an ACK should be sent to the peer.
   QuicArenaScopedPtr<QuicAlarm> ack_alarm_;
   // An alarm that fires when a packet needs to be retransmitted.
   QuicArenaScopedPtr<QuicAlarm> retransmission_alarm_;
   // An alarm that is scheduled when the SentPacketManager requires a delay
   // before sending packets and fires when the packet may be sent.
   QuicArenaScopedPtr<QuicAlarm> send_alarm_;
@@ skipping 107 matching lines @@
 
   // If true, multipath is enabled for this connection.
   bool multipath_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_