don't generate new packets when the send queue is full

send_queue.go

@@ -3,6 +3,8 @@ package quic
 type sender interface {
 	Send(p *packetBuffer)
 	Run() error
+	WouldBlock() bool
+	Available() <-chan struct{}
 	Close()
 }
 
@@ -10,28 +12,44 @@ type sendQueue struct {
 	queue       chan *packetBuffer
 	closeCalled chan struct{} // runStopped when Close() is called
 	runStopped  chan struct{} // runStopped when the run loop returns
+	available   chan struct{}
 	conn        sendConn
 }
 
 var _ sender = &sendQueue{}
 
+const sendQueueCapacity = 1
+
 func newSendQueue(conn sendConn) sender {
-	s := &sendQueue{
+	return &sendQueue{
 		conn:        conn,
 		runStopped:  make(chan struct{}),
 		closeCalled: make(chan struct{}),
-		queue:       make(chan *packetBuffer, 1),
+		available:   make(chan struct{}, 1),
+		queue:       make(chan *packetBuffer, sendQueueCapacity),
 	}
-	return s
 }
 
+// Send sends out a packet. It's guaranteed to not block.
+// Callers need to make sure that there's actually space in the send queue by calling WouldBlock.
+// Otherwise Send will panic.
 func (h *sendQueue) Send(p *packetBuffer) {
 	select {
 	case h.queue <- p:
 	case <-h.runStopped:
+	default:
+		panic("sendQueue.Send would have blocked")
 	}
 }
 
+func (h *sendQueue) WouldBlock() bool {
+	return len(h.queue) == sendQueueCapacity
+}
+
+func (h *sendQueue) Available() <-chan struct{} {
+	return h.available
+}
+
 func (h *sendQueue) Run() error {
 	defer close(h.runStopped)
 	var shouldClose bool
@@ -49,6 +67,10 @@ func (h *sendQueue) Run() error {
 				return err
 			}
 			p.Release()
+			select {
+			case h.available <- struct{}{}:
+			default:
+			}
 		}
 	}
 }