Simplify RPH ack alarm to be in line with the SPH alarm

ackhandler/interfaces.go

@@ -27,5 +27,6 @@ type ReceivedPacketHandler interface {
 	ReceivedPacket(packetNumber protocol.PacketNumber, shouldInstigateAck bool) error
 	ReceivedStopWaiting(*frames.StopWaitingFrame) error
 
+	GetAlarmTimeout() time.Time
 	GetAckFrame() *frames.AckFrame
 }

ackhandler/received_packet_handler.go

@@ -23,16 +23,14 @@ type receivedPacketHandler struct {
 	retransmittablePacketsReceivedSinceLastAck int
 	ackQueued                                  bool
 	ackAlarm                                   time.Time
-	ackAlarmResetCallback                      func(time.Time)
 	lastAck                                    *frames.AckFrame
 }
 
 // NewReceivedPacketHandler creates a new receivedPacketHandler
-func NewReceivedPacketHandler(ackAlarmResetCallback func(time.Time)) ReceivedPacketHandler {
+func NewReceivedPacketHandler() ReceivedPacketHandler {
 	return &receivedPacketHandler{
-		packetHistory:         newReceivedPacketHistory(),
-		ackAlarmResetCallback: ackAlarmResetCallback,
-		ackSendDelay:          protocol.AckSendDelay,
+		packetHistory: newReceivedPacketHistory(),
+		ackSendDelay:  protocol.AckSendDelay,
 	}
 }
 
@@ -69,7 +67,6 @@ func (h *receivedPacketHandler) ReceivedStopWaiting(f *frames.StopWaitingFrame)
 }
 
 func (h *receivedPacketHandler) maybeQueueAck(packetNumber protocol.PacketNumber, shouldInstigateAck bool) {
-	var ackAlarmSet bool
 	h.packetsReceivedSinceLastAck++
 
 	if shouldInstigateAck {
@@ -104,7 +101,6 @@ func (h *receivedPacketHandler) maybeQueueAck(packetNumber protocol.PacketNumber
 		} else {
 			if h.ackAlarm.IsZero() {
 				h.ackAlarm = time.Now().Add(h.ackSendDelay)
-				ackAlarmSet = true
 			}
 		}
 	}
@@ -112,11 +108,6 @@ func (h *receivedPacketHandler) maybeQueueAck(packetNumber protocol.PacketNumber
 	if h.ackQueued {
 		// cancel the ack alarm
 		h.ackAlarm = time.Time{}
-		ackAlarmSet = false
-	}
-
-	if ackAlarmSet {
-		h.ackAlarmResetCallback(h.ackAlarm)
 	}
 }
 
@@ -144,3 +135,5 @@ func (h *receivedPacketHandler) GetAckFrame() *frames.AckFrame {
 
 	return ack
 }
+
+func (h *receivedPacketHandler) GetAlarmTimeout() time.Time { return h.ackAlarm }

ackhandler/received_packet_handler_test.go

@@ -12,17 +12,11 @@ import (
 
 var _ = Describe("receivedPacketHandler", func() {
 	var (
-		handler                *receivedPacketHandler
-		ackAlarmCallbackCalled bool
+		handler *receivedPacketHandler
 	)
 
-	ackAlarmCallback := func(time.Time) {
-		ackAlarmCallbackCalled = true
-	}
-
 	BeforeEach(func() {
-		ackAlarmCallbackCalled = false
-		handler = NewReceivedPacketHandler(ackAlarmCallback).(*receivedPacketHandler)
+		handler = NewReceivedPacketHandler().(*receivedPacketHandler)
 	})
 
 	Context("accepting packets", func() {
@@ -135,14 +129,13 @@ var _ = Describe("receivedPacketHandler", func() {
 				}
 				Expect(handler.GetAckFrame()).ToNot(BeNil())
 				Expect(handler.ackQueued).To(BeFalse())
-				ackAlarmCallbackCalled = false
 			}
 
 			It("always queues an ACK for the first packet", func() {
 				err := handler.ReceivedPacket(1, false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.ackQueued).To(BeTrue())
-				Expect(ackAlarmCallbackCalled).To(BeFalse())
+				Expect(handler.GetAlarmTimeout()).To(BeZero())
 			})
 
 			It("only queues one ACK for many non-retransmittable packets", func() {
@@ -155,7 +148,7 @@ var _ = Describe("receivedPacketHandler", func() {
 				err := handler.ReceivedPacket(10+protocol.MaxPacketsReceivedBeforeAckSend, false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.ackQueued).To(BeTrue())
-				Expect(ackAlarmCallbackCalled).To(BeFalse())
+				Expect(handler.GetAlarmTimeout()).To(BeZero())
 			})
 
 			It("queues an ACK for every second retransmittable packet, if they are arriving fast", func() {
@@ -163,12 +156,11 @@ var _ = Describe("receivedPacketHandler", func() {
 				err := handler.ReceivedPacket(11, true)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.ackQueued).To(BeFalse())
-				Expect(ackAlarmCallbackCalled).To(BeTrue())
-				ackAlarmCallbackCalled = false
+				Expect(handler.GetAlarmTimeout()).NotTo(BeZero())
 				err = handler.ReceivedPacket(12, true)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.ackQueued).To(BeTrue())
-				Expect(ackAlarmCallbackCalled).To(BeFalse())
+				Expect(handler.GetAlarmTimeout()).To(BeZero())
 			})
 
 			It("only sets the timer when receiving a retransmittable packets", func() {
@@ -181,7 +173,7 @@ var _ = Describe("receivedPacketHandler", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.ackQueued).To(BeFalse())
 				Expect(handler.ackAlarm).ToNot(BeZero())
-				Expect(ackAlarmCallbackCalled).To(BeTrue())
+				Expect(handler.GetAlarmTimeout()).NotTo(BeZero())
 			})
 
 			It("queues an ACK if it was reported missing before", func() {