queue stream-level window updates from the flow controller directly

internal/flowcontrol/interface.go

@@ -21,8 +21,8 @@ type StreamFlowController interface {
 	// UpdateHighestReceived should be called when a new highest offset is received
 	// final has to be to true if this is the final offset of the stream, as contained in a STREAM frame with FIN bit, and the RST_STREAM frame
 	UpdateHighestReceived(offset protocol.ByteCount, final bool) error
-	// HasWindowUpdate says if it is necessary to update the window
-	HasWindowUpdate() bool
+	// MaybeQueueWindowUpdate queues a window update, if necessary
+	MaybeQueueWindowUpdate()
 }
 
 // The ConnectionFlowController is the flow controller for the connection.

internal/flowcontrol/stream_flow_controller.go

@@ -14,6 +14,8 @@ type streamFlowController struct {
 
 	streamID protocol.StreamID
 
+	queueWindowUpdate func()
+
 	connection              connectionFlowControllerI
 	contributesToConnection bool // does the stream contribute to connection level flow control
 
@@ -30,6 +32,7 @@ func NewStreamFlowController(
 	receiveWindow protocol.ByteCount,
 	maxReceiveWindow protocol.ByteCount,
 	initialSendWindow protocol.ByteCount,
+	queueWindowUpdate func(protocol.StreamID),
 	rttStats *congestion.RTTStats,
 	logger utils.Logger,
 ) StreamFlowController {
@@ -37,6 +40,7 @@ func NewStreamFlowController(
 		streamID:                streamID,
 		contributesToConnection: contributesToConnection,
 		connection:              cfc.(connectionFlowControllerI),
+		queueWindowUpdate:       func() { queueWindowUpdate(streamID) },
 		baseFlowController: baseFlowController{
 			rttStats:             rttStats,
 			receiveWindow:        receiveWindow,
@@ -120,11 +124,13 @@ func (c *streamFlowController) IsBlocked() (bool, protocol.ByteCount) {
 	return true, c.sendWindow
 }
 
-func (c *streamFlowController) HasWindowUpdate() bool {
+func (c *streamFlowController) MaybeQueueWindowUpdate() {
 	c.mutex.Lock()
 	hasWindowUpdate := !c.receivedFinalOffset && c.hasWindowUpdate()
 	c.mutex.Unlock()
-	return hasWindowUpdate
+	if hasWindowUpdate {
+		c.queueWindowUpdate()
+	}
 }
 
 func (c *streamFlowController) GetWindowUpdate() protocol.ByteCount {

internal/flowcontrol/stream_flow_controller_test.go

@@ -12,9 +12,13 @@ import (
 )
 
 var _ = Describe("Stream Flow controller", func() {
-	var controller *streamFlowController
+	var (
+		controller         *streamFlowController
+		queuedWindowUpdate bool
+	)
 
 	BeforeEach(func() {
+		queuedWindowUpdate = false
 		rttStats := &congestion.RTTStats{}
 		controller = &streamFlowController{
 			streamID:   10,
@@ -23,24 +27,38 @@ var _ = Describe("Stream Flow controller", func() {
 		controller.maxReceiveWindowSize = 10000
 		controller.rttStats = rttStats
 		controller.logger = utils.DefaultLogger
+		controller.queueWindowUpdate = func() { queuedWindowUpdate = true }
 	})
 
 	Context("Constructor", func() {
 		rttStats := &congestion.RTTStats{}
+		receiveWindow := protocol.ByteCount(2000)
+		maxReceiveWindow := protocol.ByteCount(3000)
+		sendWindow := protocol.ByteCount(4000)
 
 		It("sets the send and receive windows", func() {
-			receiveWindow := protocol.ByteCount(2000)
-			maxReceiveWindow := protocol.ByteCount(3000)
-			sendWindow := protocol.ByteCount(4000)
-
 			cc := NewConnectionFlowController(0, 0, nil, utils.DefaultLogger)
-			fc := NewStreamFlowController(5, true, cc, receiveWindow, maxReceiveWindow, sendWindow, rttStats, utils.DefaultLogger).(*streamFlowController)
+			fc := NewStreamFlowController(5, true, cc, receiveWindow, maxReceiveWindow, sendWindow, nil, rttStats, utils.DefaultLogger).(*streamFlowController)
 			Expect(fc.streamID).To(Equal(protocol.StreamID(5)))
 			Expect(fc.receiveWindow).To(Equal(receiveWindow))
 			Expect(fc.maxReceiveWindowSize).To(Equal(maxReceiveWindow))
 			Expect(fc.sendWindow).To(Equal(sendWindow))
 			Expect(fc.contributesToConnection).To(BeTrue())
 		})
+
+		It("queues window updates with the correction stream ID", func() {
+			var queued bool
+			queueWindowUpdate := func(id protocol.StreamID) {
+				Expect(id).To(Equal(protocol.StreamID(5)))
+				queued = true
+			}
+
+			cc := NewConnectionFlowController(0, 0, nil, utils.DefaultLogger)
+			fc := NewStreamFlowController(5, true, cc, receiveWindow, maxReceiveWindow, sendWindow, queueWindowUpdate, rttStats, utils.DefaultLogger).(*streamFlowController)
+			fc.AddBytesRead(receiveWindow)
+			fc.MaybeQueueWindowUpdate()
+			Expect(queued).To(BeTrue())
+		})
 	})
 
 	Context("receiving data", func() {
@@ -175,12 +193,16 @@ var _ = Describe("Stream Flow controller", func() {
 				oldWindowSize = controller.receiveWindowSize
 			})
 
-			It("tells if it has window updates", func() {
-				Expect(controller.HasWindowUpdate()).To(BeFalse())
+			It("queues window updates", func() {
+				controller.MaybeQueueWindowUpdate()
+				Expect(queuedWindowUpdate).To(BeFalse())
 				controller.AddBytesRead(30)
-				Expect(controller.HasWindowUpdate()).To(BeTrue())
+				controller.MaybeQueueWindowUpdate()
+				Expect(queuedWindowUpdate).To(BeTrue())
 				Expect(controller.GetWindowUpdate()).ToNot(BeZero())
-				Expect(controller.HasWindowUpdate()).To(BeFalse())
+				queuedWindowUpdate = false
+				controller.MaybeQueueWindowUpdate()
+				Expect(queuedWindowUpdate).To(BeFalse())
 			})
 
 			It("tells the connection flow controller when the window was autotuned", func() {
@@ -213,7 +235,8 @@ var _ = Describe("Stream Flow controller", func() {
 				controller.AddBytesRead(30)
 				err := controller.UpdateHighestReceived(90, true)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(controller.HasWindowUpdate()).To(BeFalse())
+				controller.MaybeQueueWindowUpdate()
+				Expect(queuedWindowUpdate).To(BeFalse())
 				offset := controller.GetWindowUpdate()
 				Expect(offset).To(BeZero())
 			})