From f03f9c9a1c4dea5bba75a95a7e6cb9baf4854f62 Mon Sep 17 00:00:00 2001
From: Marten Seemann <martenseemann@gmail.com>
Date: Thu, 14 Jul 2016 00:02:36 +0800
Subject: [PATCH] handle ACKs sent for a belated packet in legacy
 SentPacketHandler

ref #219
---
 ackhandlerlegacy/sent_packet_handler.go      | 31 ++++++++++-----
 ackhandlerlegacy/sent_packet_handler_test.go | 40 +++++++++++++++++++-
 2 files changed, 60 insertions(+), 11 deletions(-)

diff --git a/ackhandlerlegacy/sent_packet_handler.go b/ackhandlerlegacy/sent_packet_handler.go
index 0cb7e6d1..4fd83419 100644
--- a/ackhandlerlegacy/sent_packet_handler.go
+++ b/ackhandlerlegacy/sent_packet_handler.go
@@ -143,11 +143,16 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error {
 }
 
 func (h *sentPacketHandler) calculateExpectedEntropy(ackFrame *frames.AckFrameLegacy) (EntropyAccumulator, error) {
-	packet, ok := h.packetHistory[ackFrame.LargestObserved]
-	if !ok {
-		return 0, ErrMapAccess
+	var expectedEntropy EntropyAccumulator
+	if ackFrame.LargestObserved == h.LargestObserved {
+		expectedEntropy = h.LargestObservedEntropy
+	} else {
+		packet, ok := h.packetHistory[ackFrame.LargestObserved]
+		if !ok {
+			return 0, ErrMapAccess
+		}
+		expectedEntropy = packet.Entropy
 	}
-	expectedEntropy := packet.Entropy
 
 	if ackFrame.HasNACK() { // if the packet has NACKs, the entropy value has to be calculated
 		nackRangeIndex := 0
@@ -168,6 +173,7 @@ func (h *sentPacketHandler) calculateExpectedEntropy(ackFrame *frames.AckFrameLe
 			}
 		}
 	}
+
 	return expectedEntropy, nil
 }
 
@@ -202,12 +208,17 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrameLegacy, withPac
 	h.LargestObserved = ackFrame.LargestObserved
 	highestInOrderAckedPacketNumber := ackFrame.GetHighestInOrderPacketNumber()
 
-	// Update the RTT
-	timeDelta := time.Now().Sub(h.packetHistory[h.LargestObserved].sendTime)
-	// TODO: Don't always update RTT
-	h.rttStats.UpdateRTT(timeDelta, ackFrame.DelayTime, time.Now())
-	if utils.Debug() {
-		utils.Debugf("\tEstimated RTT: %dms", h.rttStats.SmoothedRTT()/time.Millisecond)
+	packet, ok := h.packetHistory[h.LargestObserved]
+	if ok {
+		h.LargestObservedEntropy = packet.Entropy
+
+		// Update the RTT
+		timeDelta := time.Now().Sub(packet.sendTime)
+		// TODO: Don't always update RTT
+		h.rttStats.UpdateRTT(timeDelta, ackFrame.DelayTime, time.Now())
+		if utils.Debug() {
+			utils.Debugf("\tEstimated RTT: %dms", h.rttStats.SmoothedRTT()/time.Millisecond)
+		}
 	}
 
 	var ackedPackets congestion.PacketVector
diff --git a/ackhandlerlegacy/sent_packet_handler_test.go b/ackhandlerlegacy/sent_packet_handler_test.go
index 3d2f8752..21259078 100644
--- a/ackhandlerlegacy/sent_packet_handler_test.go
+++ b/ackhandlerlegacy/sent_packet_handler_test.go
@@ -294,15 +294,18 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(2)))
 			Expect(handler.LargestObserved).To(Equal(protocol.PacketNumber(largestObserved)))
+			Expect(handler.LargestObservedEntropy).To(Equal(entropy))
 			Expect(handler.highestInOrderAckedPacketNumber).To(Equal(protocol.PacketNumber(largestObserved)))
 			Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(largestObserved - 1)))
 			Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(largestObserved + 1)))
 		})
 
 		It("completely processes an ACK with a NACK range", func() {
-			entropy := EntropyAccumulator(0)
+			var entropy EntropyAccumulator
+			var largestObservedEntropy EntropyAccumulator
 			largestObserved := 6
 			for i := 0; i < largestObserved; i++ {
+				largestObservedEntropy.Add(packets[i].PacketNumber, packets[i].EntropyBit)
 				if i == 2 || i == 4 { // Packet Number 3 and 5 missing
 					continue
 				}
@@ -320,6 +323,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(2)))
 			Expect(handler.LargestObserved).To(Equal(protocol.PacketNumber(largestObserved)))
+			Expect(handler.LargestObservedEntropy).To(Equal(largestObservedEntropy))
 			Expect(handler.highestInOrderAckedPacketNumber).To(Equal(protocol.PacketNumber(2)))
 			Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(2)))
 			Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(3)))
@@ -327,6 +331,40 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(5)))
 			Expect(handler.packetHistory).ToNot(HaveKey(protocol.PacketNumber(6)))
 		})
+
+		It("processes an ACK frame that would be sent after a late arrival of a packet", func() {
+			entropy := EntropyAccumulator(0)
+			largestObserved := 6
+			for i := 0; i < largestObserved; i++ {
+				if i == 2 || i == 3 { // Packet Number 3 and 4
+					continue
+				}
+				entropy.Add(packets[i].PacketNumber, packets[i].EntropyBit)
+			}
+			ack1 := frames.AckFrameLegacy{
+				LargestObserved: protocol.PacketNumber(largestObserved),
+				Entropy:         byte(entropy),
+				NackRanges: []frames.NackRange{
+					{FirstPacketNumber: 3, LastPacketNumber: 4},
+				},
+			}
+			err := handler.ReceivedAck(&ack1, 1)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(2)))
+			entropy.Add(packets[2].PacketNumber, packets[2].EntropyBit)
+			Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(3)))
+			ack2 := frames.AckFrameLegacy{
+				LargestObserved: protocol.PacketNumber(largestObserved),
+				Entropy:         byte(entropy),
+				NackRanges: []frames.NackRange{
+					{FirstPacketNumber: 4, LastPacketNumber: 4},
+				},
+			}
+			err = handler.ReceivedAck(&ack2, 2)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(1)))
+			Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(4)))
+		})
 	})
 
 	Context("ACK processing", func() { // in all these tests, the EntropyBit of each Packet is set to false, so that the resulting EntropyByte will always be 0