remove StopWaitingManager from new AckHandler

ackhandler/sent_packet_handler.go

@@ -38,7 +38,6 @@ type sentPacketHandler struct {
 	packetHistory map[protocol.PacketNumber]*ackhandlerlegacy.Packet
 
 	retransmissionQueue []*ackhandlerlegacy.Packet
-	stopWaitingManager  StopWaitingManager
 
 	bytesInFlight protocol.ByteCount
 
@@ -47,7 +46,7 @@ type sentPacketHandler struct {
 }
 
 // NewSentPacketHandler creates a new sentPacketHandler
-func NewSentPacketHandler(stopWaitingManager StopWaitingManager) SentPacketHandler {
+func NewSentPacketHandler() SentPacketHandler {
 	rttStats := &congestion.RTTStats{}
 
 	congestion := congestion.NewCubicSender(
@@ -59,10 +58,9 @@ func NewSentPacketHandler(stopWaitingManager StopWaitingManager) SentPacketHandl
 	)
 
 	return &sentPacketHandler{
-		packetHistory:      make(map[protocol.PacketNumber]*ackhandlerlegacy.Packet),
+		packetHistory: make(map[protocol.PacketNumber]*ackhandlerlegacy.Packet),
-		stopWaitingManager: stopWaitingManager,
+		rttStats:      rttStats,
-		rttStats:           rttStats,
+		congestion:    congestion,
-		congestion:         congestion,
 	}
 }
 
@@ -78,8 +76,6 @@ func (h *sentPacketHandler) ackPacket(packetNumber protocol.PacketNumber) *ackha
 
 	delete(h.packetHistory, packetNumber)
 
-	h.stopWaitingManager.ReceivedAckForPacketNumber(packetNumber)
-
 	return packet
 }
 

ackhandler/sent_packet_handler_test.go

@@ -51,21 +51,6 @@ func (m *mockCongestion) SetNumEmulatedConnections(n int)         { panic("not i
 func (m *mockCongestion) OnConnectionMigration()                  { panic("not implemented") }
 func (m *mockCongestion) SetSlowStartLargeReduction(enabled bool) { panic("not implemented") }
 
-type mockStopWaiting struct {
-	receivedAckForPacketNumber protocol.PacketNumber
-}
-
-func (m *mockStopWaiting) RegisterPacketForRetransmission(packet *ackhandlerlegacy.Packet) {
-	panic("not implemented")
-}
-func (m *mockStopWaiting) GetStopWaitingFrame() *frames.StopWaitingFrame { panic("not implemented") }
-func (m *mockStopWaiting) SentStopWaitingWithPacket(packetNumber protocol.PacketNumber) {
-	panic("not implemented")
-}
-func (m *mockStopWaiting) ReceivedAckForPacketNumber(packetNumber protocol.PacketNumber) {
-	m.receivedAckForPacketNumber = packetNumber
-}
-
 var _ = Describe("SentPacketHandler", func() {
 	var (
 		handler     *sentPacketHandler
@@ -73,19 +58,13 @@ var _ = Describe("SentPacketHandler", func() {
 	)
 
 	BeforeEach(func() {
-		stopWaitingManager := &mockStopWaiting{}
+		handler = NewSentPacketHandler().(*sentPacketHandler)
-		handler = NewSentPacketHandler(stopWaitingManager).(*sentPacketHandler)
 		streamFrame = frames.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0x13, 0x37},
 		}
 	})
 
-	It("informs the StopWaitingManager about ACKs received", func() {
-		handler.ackPacket(2)
-		Expect(handler.stopWaitingManager.(*mockStopWaiting).receivedAckForPacketNumber).To(Equal(protocol.PacketNumber(2)))
-	})
-
 	It("gets the LargestAcked packet number", func() {
 		handler.LargestAcked = 0x1337
 		Expect(handler.GetLargestAcked()).To(Equal(protocol.PacketNumber(0x1337)))

ackhandler/stop_waiting_manager.go

@@ -1,58 +0,0 @@
-package ackhandler
-
-import (
-	"github.com/lucas-clemente/quic-go/ackhandlerlegacy"
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
-)
-
-// StopWaitingManager manages StopWaitingFrames
-type stopWaitingManager struct {
-	// sentStopWaitings            map[protocol.PacketNumber]protocol.PacketNumber // map[LeastUnacked]stopWaitingSentWithPacketNumber
-	lastNewStopWaitingFirstSentWithPacketNumber protocol.PacketNumber
-	maxRetransmittedPacketNumber                protocol.PacketNumber
-	currentStopWaitingFrame                     *frames.StopWaitingFrame
-	currentStopWaitingFrameSent                 bool
-}
-
-// NewStopWaitingManager creates a new StopWaitingManager
-func NewStopWaitingManager() StopWaitingManager {
-	return &stopWaitingManager{
-		currentStopWaitingFrame: nil,
-	}
-}
-
-// RegisterPacketForRetransmission prepares the StopWaitingFrame, if necessary
-func (h *stopWaitingManager) RegisterPacketForRetransmission(packet *ackhandlerlegacy.Packet) {
-	// out-of-order retransmission. A StopWaitingFrame with a higher LeastUnacked was already queued (or sent in the past), no need to send another one again
-	if packet.PacketNumber < h.maxRetransmittedPacketNumber {
-		return
-	}
-	if h.currentStopWaitingFrame == nil || h.currentStopWaitingFrame.LeastUnacked <= packet.PacketNumber { // <= because for StopWaitingFrames LeastUnacked = packet.PacketNumber + 1
-		h.currentStopWaitingFrame = &frames.StopWaitingFrame{
-			LeastUnacked: packet.PacketNumber + 1,
-		}
-		h.maxRetransmittedPacketNumber = packet.PacketNumber
-		h.currentStopWaitingFrameSent = false
-	}
-}
-
-// GetStopWaitingFrame gets the StopWaitingFrame that needs to be sent. It returns nil if no StopWaitingFrame needs to be sent
-func (h *stopWaitingManager) GetStopWaitingFrame() *frames.StopWaitingFrame {
-	return h.currentStopWaitingFrame
-}
-
-// SentStopWaitingWithPacket must be called after sending out a StopWaitingFrame with a packet
-func (h *stopWaitingManager) SentStopWaitingWithPacket(packetNumber protocol.PacketNumber) {
-	if !h.currentStopWaitingFrameSent {
-		h.lastNewStopWaitingFirstSentWithPacketNumber = packetNumber
-	}
-	h.currentStopWaitingFrameSent = true
-}
-
-// ReceivedAckForPacketNumber should be called after receiving an ACK
-func (h *stopWaitingManager) ReceivedAckForPacketNumber(packetNumber protocol.PacketNumber) {
-	if packetNumber >= h.lastNewStopWaitingFirstSentWithPacketNumber {
-		h.currentStopWaitingFrame = nil
-	}
-}

ackhandler/stop_waiting_manager_test.go

@@ -1,85 +0,0 @@
-package ackhandler
-
-import (
-	"github.com/lucas-clemente/quic-go/ackhandlerlegacy"
-	"github.com/lucas-clemente/quic-go/protocol"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("StopWaitingManager", func() {
-	var manager *stopWaitingManager
-	BeforeEach(func() {
-		manager = NewStopWaitingManager().(*stopWaitingManager)
-	})
-
-	It("returns nil in the beginning", func() {
-		Expect(manager.GetStopWaitingFrame()).To(BeNil())
-	})
-
-	It("gets a StopWaitingFrame after a packet has been registered for retransmission", func() {
-		leastUnacked := protocol.PacketNumber(10)
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
-		swf := manager.GetStopWaitingFrame()
-		Expect(swf).ToNot(BeNil())
-		Expect(swf.LeastUnacked).To(Equal(leastUnacked + 1))
-	})
-
-	It("always gets the StopWaitingFrame for the highest retransmitted packet number", func() {
-		leastUnacked := protocol.PacketNumber(10)
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked - 1})
-		swf := manager.GetStopWaitingFrame()
-		Expect(swf).ToNot(BeNil())
-		Expect(swf.LeastUnacked).To(Equal(leastUnacked + 1))
-	})
-
-	It("updates the StopWaitingFrame when a packet with a higher packet number is retransmitted", func() {
-		leastUnacked := protocol.PacketNumber(10)
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked - 1})
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
-		swf := manager.GetStopWaitingFrame()
-		Expect(swf).ToNot(BeNil())
-		Expect(swf.LeastUnacked).To(Equal(leastUnacked + 1))
-	})
-
-	It("does not create a new StopWaitingFrame for an out-of-order retransmission", func() {
-		leastUnacked := protocol.PacketNumber(10)
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
-		manager.SentStopWaitingWithPacket(12)
-		manager.ReceivedAckForPacketNumber(12)
-		manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked - 1})
-		swf := manager.GetStopWaitingFrame()
-		Expect(swf).To(BeNil())
-	})
-
-	Context("ACK handling", func() {
-		It("removes the current StopWaitingFrame when the first packet it was sent with is ACKed", func() {
-			manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: 10})
-			manager.SentStopWaitingWithPacket(13)
-			manager.SentStopWaitingWithPacket(14)
-			manager.SentStopWaitingWithPacket(15)
-			Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
-			manager.ReceivedAckForPacketNumber(13)
-			Expect(manager.GetStopWaitingFrame()).To(BeNil())
-		})
-
-		It("removes the current StopWaitingFrame when any packet it was sent with is ACKed", func() {
-			manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: 10})
-			manager.SentStopWaitingWithPacket(13)
-			manager.SentStopWaitingWithPacket(14)
-			manager.SentStopWaitingWithPacket(15)
-			Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
-			manager.ReceivedAckForPacketNumber(14)
-			Expect(manager.GetStopWaitingFrame()).To(BeNil())
-		})
-
-		It("does not remove the current StopWaitingFrame when a packet before the one containing the StopWaitingFrame is ACKed", func() {
-			manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: 10})
-			manager.SentStopWaitingWithPacket(13)
-			Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
-			manager.ReceivedAckForPacketNumber(12)
-			Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
-		})
-	})
-})

session.go

@@ -104,8 +104,7 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol
 		sentPacketHandler = ackhandlerlegacy.NewSentPacketHandler(stopWaitingManager).(ackhandler.SentPacketHandler)
 		receivedPacketHandler = ackhandlerlegacy.NewReceivedPacketHandler().(ackhandler.ReceivedPacketHandler)
 	} else {
-		stopWaitingManager = ackhandler.NewStopWaitingManager()
+		sentPacketHandler = ackhandler.NewSentPacketHandler()
-		sentPacketHandler = ackhandler.NewSentPacketHandler(stopWaitingManager)
 		receivedPacketHandler = ackhandler.NewReceivedPacketHandler()
 	}
 
@@ -480,7 +479,10 @@ func (s *Session) sendPacket() error {
 				break
 			}
 			utils.Debugf("\tDequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber)
-			s.stopWaitingManager.RegisterPacketForRetransmission(retransmitPacket)
+
+			if s.version <= protocol.Version33 {
+				s.stopWaitingManager.RegisterPacketForRetransmission(retransmitPacket)
+			}
 			// resend the frames that were in the packet
 			controlFrames = append(controlFrames, retransmitPacket.GetControlFramesForRetransmission()...)
 			for _, streamFrame := range retransmitPacket.GetStreamFramesForRetransmission() {
@@ -508,7 +510,10 @@ func (s *Session) sendPacket() error {
 		// Check whether we are allowed to send a packet containing only an ACK
 		maySendOnlyAck := time.Now().Sub(s.delayedAckOriginTime) > protocol.AckSendDelay
 
-		stopWaitingFrame := s.stopWaitingManager.GetStopWaitingFrame()
+		var stopWaitingFrame *frames.StopWaitingFrame
+		if s.version <= protocol.Version33 {
+			stopWaitingFrame = s.stopWaitingManager.GetStopWaitingFrame()
+		}
 		packet, err := s.packer.PackPacket(stopWaitingFrame, controlFrames, s.sentPacketHandler.GetLargestAcked(), maySendOnlyAck)
 		if err != nil {
 			return err
@@ -536,7 +541,10 @@ func (s *Session) sendPacket() error {
 		if err != nil {
 			return err
 		}
-		s.stopWaitingManager.SentStopWaitingWithPacket(packet.number)
+
+		if s.version <= protocol.Version33 {
+			s.stopWaitingManager.SentStopWaitingWithPacket(packet.number)
+		}
 		s.logPacket(packet)
 		s.delayedAckOriginTime = time.Time{}