don't queue ACKs for non-retransmittable packets for QUIC >= 39

From QUIC 39 on, the peer is required to send a retransmittable packet
when it wishes to receive an ACK.

ackhandler/received_packet_handler.go

@@ -24,13 +24,16 @@ type receivedPacketHandler struct {
 	ackQueued                                  bool
 	ackAlarm                                   time.Time
 	lastAck                                    *frames.AckFrame
+
+	version protocol.VersionNumber
 }
 
 // NewReceivedPacketHandler creates a new receivedPacketHandler
-func NewReceivedPacketHandler() ReceivedPacketHandler {
+func NewReceivedPacketHandler(version protocol.VersionNumber) ReceivedPacketHandler {
 	return &receivedPacketHandler{
 		packetHistory: newReceivedPacketHistory(),
 		ackSendDelay:  protocol.AckSendDelay,
+		version:       version,
 	}
 }
 
@@ -74,10 +77,13 @@ func (h *receivedPacketHandler) maybeQueueAck(packetNumber protocol.PacketNumber
 		h.ackQueued = true
 	}
 
-	// Always send an ack every 20 packets in order to allow the peer to discard
+	if h.version < protocol.Version39 {
-	// information from the SentPacketManager and provide an RTT measurement.
+		// Always send an ack every 20 packets in order to allow the peer to discard
-	if h.packetsReceivedSinceLastAck >= protocol.MaxPacketsReceivedBeforeAckSend {
+		// information from the SentPacketManager and provide an RTT measurement.
-		h.ackQueued = true
+		// From QUIC 39, this is not needed anymore, since the peer will regularly send a retransmittable packet.
+		if h.packetsReceivedSinceLastAck >= protocol.MaxPacketsReceivedBeforeAckSend {
+			h.ackQueued = true
+		}
 	}
 
 	// if the packet number is smaller than the largest acked packet, it must have been reported missing with the last ACK

ackhandler/received_packet_handler_test.go

@@ -16,7 +16,7 @@ var _ = Describe("receivedPacketHandler", func() {
 	)
 
 	BeforeEach(func() {
-		handler = NewReceivedPacketHandler().(*receivedPacketHandler)
+		handler = NewReceivedPacketHandler(protocol.VersionWhatever).(*receivedPacketHandler)
 	})
 
 	Context("accepting packets", func() {
@@ -115,6 +115,16 @@ var _ = Describe("receivedPacketHandler", func() {
 				Expect(handler.GetAlarmTimeout()).To(BeZero())
 			})
 
+			It("doesn't queue an ACK for non-retransmittable packets, for QUIC >= 39", func() {
+				receiveAndAck10Packets()
+				handler.version = protocol.Version39
+				for i := 11; i < 10+10*protocol.MaxPacketsReceivedBeforeAckSend; i++ {
+					err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(handler.ackQueued).To(BeFalse())
+				}
+			})
+
 			It("queues an ACK for every second retransmittable packet, if they are arriving fast", func() {
 				receiveAndAck10Packets()
 				err := handler.ReceivedPacket(11, true)

session.go

@@ -185,7 +185,7 @@ func (s *session) setup(
 		s.config.MaxReceiveStreamFlowControlWindow, s.config.MaxReceiveConnectionFlowControlWindow)
 	s.sentPacketHandler = ackhandler.NewSentPacketHandler(s.rttStats)
 	s.flowControlManager = flowcontrol.NewFlowControlManager(s.connectionParameters, s.rttStats)
-	s.receivedPacketHandler = ackhandler.NewReceivedPacketHandler()
+	s.receivedPacketHandler = ackhandler.NewReceivedPacketHandler(s.version)
 	s.streamsMap = newStreamsMap(s.newStream, s.perspective, s.connectionParameters)
 	s.streamFramer = newStreamFramer(s.streamsMap, s.flowControlManager)