use flow controller for window update handling, remove windowUpdateMgr

session.go

@@ -56,7 +56,6 @@ type Session struct {
 	sentPacketHandler     ackhandlerlegacy.SentPacketHandler
 	receivedPacketHandler ackhandlerlegacy.ReceivedPacketHandler
 	stopWaitingManager    ackhandlerlegacy.StopWaitingManager
-	windowUpdateManager   *windowUpdateManager
 	streamFramer          *streamFramer
 
 	flowControlManager flowcontrol.FlowControlManager
@@ -108,7 +107,6 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol
 		receivedPacketHandler:       ackhandlerlegacy.NewReceivedPacketHandler(),
 		stopWaitingManager:          stopWaitingManager,
 		flowControlManager:          flowControlManager,
-		windowUpdateManager:         newWindowUpdateManager(),
 		receivedPackets:             make(chan receivedPacket, protocol.MaxSessionUnprocessedPackets),
 		closeChan:                   make(chan *qerr.QuicError, 1),
 		sendingScheduled:            make(chan struct{}, 1),
@@ -510,7 +508,10 @@ func (s *Session) sendPacket() error {
 		}
 	}
 
-	windowUpdateFrames := s.windowUpdateManager.GetWindowUpdateFrames()
+	windowUpdateFrames, err := s.getWindowUpdateFrames()
+	if err != nil {
+		return err
+	}
 
 	for _, wuf := range windowUpdateFrames {
 		controlFrames = append(controlFrames, wuf)
@@ -534,6 +535,10 @@ func (s *Session) sendPacket() error {
 		return nil
 	}
 
+	for _, f := range windowUpdateFrames {
+		s.packer.QueueControlFrameForNextPacket(f)
+	}
+
 	err = s.sentPacketHandler.SentPacket(&ackhandlerlegacy.Packet{
 		PacketNumber: packet.number,
 		Frames:       packet.frames,
@@ -585,12 +590,6 @@ func (s *Session) logPacket(packet *packedPacket) {
 	}
 }
 
-// updateReceiveFlowControlWindow updates the flow control window for a stream
-func (s *Session) updateReceiveFlowControlWindow(streamID protocol.StreamID, byteOffset protocol.ByteCount) error {
-	s.windowUpdateManager.SetStreamOffset(streamID, byteOffset)
-	return nil
-}
-
 // OpenStream creates a new stream open for reading and writing
 func (s *Session) OpenStream(id protocol.StreamID) (utils.Stream, error) {
 	s.streamsMutex.Lock()
@@ -644,9 +643,6 @@ func (s *Session) garbageCollectStreams() {
 		if v == nil {
 			continue
 		}
-		if v.finishedReading() {
-			s.windowUpdateManager.RemoveStream(k)
-		}
 		if v.finished() {
 			utils.Debugf("Garbage-collecting stream %d", k)
 			atomic.AddUint32(&s.openStreamsCount, ^uint32(0)) // decrement
@@ -682,3 +678,31 @@ func (s *Session) tryDecryptingQueuedPackets() {
 	}
 	s.undecryptablePackets = s.undecryptablePackets[:0]
 }
+
+func (s *Session) getWindowUpdateFrames() ([]*frames.WindowUpdateFrame, error) {
+	s.streamsMutex.RLock()
+	defer s.streamsMutex.RUnlock()
+
+	var res []*frames.WindowUpdateFrame
+
+	for id, str := range s.streams {
+		if str == nil {
+			continue
+		}
+
+		doUpdate, offset, err := s.flowControlManager.MaybeTriggerStreamWindowUpdate(id)
+		if err != nil {
+			return nil, err
+		}
+		if doUpdate {
+			res = append(res, &frames.WindowUpdateFrame{StreamID: id, ByteOffset: offset})
+		}
+	}
+
+	doUpdate, offset := s.flowControlManager.MaybeTriggerConnectionWindowUpdate()
+	if doUpdate {
+		res = append(res, &frames.WindowUpdateFrame{StreamID: 0, ByteOffset: offset})
+	}
+
+	return res, nil
+}