remove the flow control manager

internal/flowcontrol/base_flow_controller.go

@@ -1,7 +1,7 @@
 package flowcontrol
 
 import (
-	"errors"
+	"sync"
 	"time"
 
 	"github.com/lucas-clemente/quic-go/congestion"
@@ -10,6 +10,8 @@ import (
 )
 
 type baseFlowController struct {
+	mutex sync.RWMutex
+
 	rttStats *congestion.RTTStats
 
 	bytesSent  protocol.ByteCount
@@ -24,24 +26,25 @@ type baseFlowController struct {
 	maxReceiveWindowIncrement protocol.ByteCount
 }
 
-// ErrReceivedSmallerByteOffset occurs if the ByteOffset received is smaller than a ByteOffset that was set previously
-var ErrReceivedSmallerByteOffset = errors.New("Received a smaller byte offset")
-
 func (c *baseFlowController) AddBytesSent(n protocol.ByteCount) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
 	c.bytesSent += n
 }
 
 // UpdateSendWindow should be called after receiving a WindowUpdateFrame
 // it returns true if the window was actually updated
-func (c *baseFlowController) UpdateSendWindow(newOffset protocol.ByteCount) bool {
-	if newOffset > c.sendWindow {
-		c.sendWindow = newOffset
-		return true
+func (c *baseFlowController) UpdateSendWindow(offset protocol.ByteCount) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	if offset > c.sendWindow {
+		c.sendWindow = offset
 	}
-	return false
 }
 
-func (c *baseFlowController) SendWindowSize() protocol.ByteCount {
+func (c *baseFlowController) sendWindowSize() protocol.ByteCount {
 	// this only happens during connection establishment, when data is sent before we receive the peer's transport parameters
 	if c.bytesSent > c.sendWindow {
 		return 0
@@ -50,6 +53,9 @@ func (c *baseFlowController) SendWindowSize() protocol.ByteCount {
 }
 
 func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
 	// pretend we sent a WindowUpdate when reading the first byte
 	// this way auto-tuning of the window increment already works for the first WindowUpdate
 	if c.bytesRead == 0 {
@@ -58,28 +64,26 @@ func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) {
 	c.bytesRead += n
 }
 
-// MaybeUpdateWindow updates the receive window, if necessary
-// if the receive window increment is changed, the new value is returned, otherwise a 0
-// the last return value is the new offset of the receive window
-func (c *baseFlowController) MaybeUpdateWindow() (bool, protocol.ByteCount /* new increment */, protocol.ByteCount /* new offset */) {
+// getWindowUpdate updates the receive window, if necessary
+// it returns the new offset
+func (c *baseFlowController) getWindowUpdate() protocol.ByteCount {
 	diff := c.receiveWindow - c.bytesRead
-
-	// Chromium implements the same threshold
-	if diff < (c.receiveWindowIncrement / 2) {
-		var newWindowIncrement protocol.ByteCount
-		oldWindowIncrement := c.receiveWindowIncrement
-
-		c.maybeAdjustWindowIncrement()
-		if c.receiveWindowIncrement != oldWindowIncrement {
-			newWindowIncrement = c.receiveWindowIncrement
-		}
-
-		c.lastWindowUpdateTime = time.Now()
-		c.receiveWindow = c.bytesRead + c.receiveWindowIncrement
-		return true, newWindowIncrement, c.receiveWindow
+	// update the window when more than half of it was already consumed
+	if diff >= (c.receiveWindowIncrement / 2) {
+		return 0
 	}
 
-	return false, 0, 0
+	c.maybeAdjustWindowIncrement()
+	c.receiveWindow = c.bytesRead + c.receiveWindowIncrement
+	c.lastWindowUpdateTime = time.Now()
+	return c.receiveWindow
+}
+
+func (c *baseFlowController) IsBlocked() bool {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	return c.sendWindowSize() == 0
 }
 
 // maybeAdjustWindowIncrement increases the receiveWindowIncrement if we're sending WindowUpdates too often
@@ -94,7 +98,6 @@ func (c *baseFlowController) maybeAdjustWindowIncrement() {
 	}
 
 	timeSinceLastWindowUpdate := time.Since(c.lastWindowUpdateTime)
-
 	// interval between the window updates is sufficiently large, no need to increase the increment
 	if timeSinceLastWindowUpdate >= 2*rtt {
 		return
@@ -102,6 +105,6 @@ func (c *baseFlowController) maybeAdjustWindowIncrement() {
 	c.receiveWindowIncrement = utils.MinByteCount(2*c.receiveWindowIncrement, c.maxReceiveWindowIncrement)
 }
 
-func (c *baseFlowController) CheckFlowControlViolation() bool {
+func (c *baseFlowController) checkFlowControlViolation() bool {
 	return c.highestReceived > c.receiveWindow
 }