@@ -103,7 +103,7 @@ require (

 	go.opentelemetry.io/otel/sdk v1.35.0

 	go.opentelemetry.io/otel/trace v1.35.0

 	golang.org/x/mod v0.28.0

-	golang.org/x/net v0.44.0

+	golang.org/x/net v0.45.0

 	golang.org/x/sync v0.17.0

 	golang.org/x/sys v0.36.0

 	golang.org/x/text v0.29.0

@@ -698,8 +698,8 @@ golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLL

 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=

 golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=

-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=

-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=

+golang.org/x/net v0.45.0 h1:RLBg5JKixCy82FtLJpeNlVM0nrSqpCRYzVU1n8kj0tM=

+golang.org/x/net v0.45.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=

 golang.org/x/oauth2 v0.0.0-20170912212905-13449ad91cb2/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=

 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=

 golang.org/x/oauth2 v0.29.0 h1:WdYw2tdTK1S8olAzWHdgeqfy+Mtm9XNhv/xJsY65d98=

@@ -27,6 +27,7 @@ import (

 //   - If the resulting value is zero or out of range, use a default.

 type http2Config struct {

 	MaxConcurrentStreams         uint32

+	StrictMaxConcurrentRequests  bool

 	MaxDecoderHeaderTableSize    uint32

 	MaxEncoderHeaderTableSize    uint32

 	MaxReadFrameSize             uint32

@@ -64,12 +65,13 @@ func configFromServer(h1 *http.Server, h2 *Server) http2Config {

 // (the net/http Transport).

 func configFromTransport(h2 *Transport) http2Config {

 	conf := http2Config{

-		MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize,

-		MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize,

-		MaxReadFrameSize:          h2.MaxReadFrameSize,

-		SendPingTimeout:           h2.ReadIdleTimeout,

-		PingTimeout:               h2.PingTimeout,

-		WriteByteTimeout:          h2.WriteByteTimeout,

+		StrictMaxConcurrentRequests: h2.StrictMaxConcurrentStreams,

+		MaxEncoderHeaderTableSize:   h2.MaxEncoderHeaderTableSize,

+		MaxDecoderHeaderTableSize:   h2.MaxDecoderHeaderTableSize,

+		MaxReadFrameSize:            h2.MaxReadFrameSize,

+		SendPingTimeout:             h2.ReadIdleTimeout,

+		PingTimeout:                 h2.PingTimeout,

+		WriteByteTimeout:            h2.WriteByteTimeout,

 	}

 	// Unlike most config fields, where out-of-range values revert to the default,

@@ -128,6 +130,9 @@ func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) {

 	if h2.MaxConcurrentStreams != 0 {

 		conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams)

 	}

+	if http2ConfigStrictMaxConcurrentRequests(h2) {

+		conf.StrictMaxConcurrentRequests = true

+	}

 	if h2.MaxEncoderHeaderTableSize != 0 {

 		conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize)

 	}

new file mode 100644

@@ -0,0 +1,15 @@

+// Copyright 2025 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+//go:build !go1.26

+

+package http2

+

+import (

+	"net/http"

+)

+

+func http2ConfigStrictMaxConcurrentRequests(h2 *http.HTTP2Config) bool {

+	return false

+}

new file mode 100644

@@ -0,0 +1,15 @@

+// Copyright 2025 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+//go:build go1.26

+

+package http2

+

+import (

+	"net/http"

+)

+

+func http2ConfigStrictMaxConcurrentRequests(h2 *http.HTTP2Config) bool {

+	return h2.StrictMaxConcurrentRequests

+}

@@ -347,7 +347,7 @@ func (fr *Framer) maxHeaderListSize() uint32 {

 func (f *Framer) startWrite(ftype FrameType, flags Flags, streamID uint32) {

 	// Write the FrameHeader.

 	f.wbuf = append(f.wbuf[:0],

-		0, // 3 bytes of length, filled in in endWrite

+		0, // 3 bytes of length, filled in endWrite

 		0,

 		0,

 		byte(ftype),

@@ -1152,6 +1152,15 @@ type PriorityFrame struct {

 	PriorityParam

 }

+var defaultRFC9218Priority = PriorityParam{

+	incremental: 0,

+	urgency:     3,

+}

+

+// Note that HTTP/2 has had two different prioritization schemes, and

+// PriorityParam struct below is a superset of both schemes. The exported

+// symbols are from RFC 7540 and the non-exported ones are from RFC 9218.

+

 // PriorityParam are the stream prioritzation parameters.

 type PriorityParam struct {

 	// StreamDep is a 31-bit stream identifier for the

@@ -1167,6 +1176,20 @@ type PriorityParam struct {

 	// the spec, "Add one to the value to obtain a weight between

 	// 1 and 256."

 	Weight uint8

+

+	// "The urgency (u) parameter value is Integer (see Section 3.3.1 of

+	// [STRUCTURED-FIELDS]), between 0 and 7 inclusive, in descending order of

+	// priority. The default is 3."

+	urgency uint8

+

+	// "The incremental (i) parameter value is Boolean (see Section 3.3.6 of

+	// [STRUCTURED-FIELDS]). It indicates if an HTTP response can be processed

+	// incrementally, i.e., provide some meaningful output as chunks of the

+	// response arrive."

+	//

+	// We use uint8 (i.e. 0 is false, 1 is true) instead of bool so we can

+	// avoid unnecessary type conversions and because either type takes 1 byte.

+	incremental uint8

 }

 func (p PriorityParam) IsZero() bool {

@@ -34,7 +34,6 @@ var (

 	VerboseLogs    bool

 	logFrameWrites bool

 	logFrameReads  bool

-	inTests        bool

 	// Enabling extended CONNECT by causes browsers to attempt to use

 	// WebSockets-over-HTTP/2. This results in problems when the server's websocket

@@ -181,6 +181,10 @@ type Server struct {

 type serverInternalState struct {

 	mu          sync.Mutex

 	activeConns map[*serverConn]struct{}

+

+	// Pool of error channels. This is per-Server rather than global

+	// because channels can't be reused across synctest bubbles.

+	errChanPool sync.Pool

 }

 func (s *serverInternalState) registerConn(sc *serverConn) {

@@ -212,6 +216,27 @@ func (s *serverInternalState) startGracefulShutdown() {

 	s.mu.Unlock()

 }

+// Global error channel pool used for uninitialized Servers.

+// We use a per-Server pool when possible to avoid using channels across synctest bubbles.

+var errChanPool = sync.Pool{

+	New: func() any { return make(chan error, 1) },

+}

+

+func (s *serverInternalState) getErrChan() chan error {

+	if s == nil {

+		return errChanPool.Get().(chan error) // Server used without calling ConfigureServer

+	}

+	return s.errChanPool.Get().(chan error)

+}

+

+func (s *serverInternalState) putErrChan(ch chan error) {

+	if s == nil {

+		errChanPool.Put(ch) // Server used without calling ConfigureServer

+		return

+	}

+	s.errChanPool.Put(ch)

+}

+

 // ConfigureServer adds HTTP/2 support to a net/http Server.

 //

 // The configuration conf may be nil.

@@ -224,7 +249,10 @@ func ConfigureServer(s *http.Server, conf *Server) error {

 	if conf == nil {

 		conf = new(Server)

 	}

-	conf.state = &serverInternalState{activeConns: make(map[*serverConn]struct{})}

+	conf.state = &serverInternalState{

+		activeConns: make(map[*serverConn]struct{}),

+		errChanPool: sync.Pool{New: func() any { return make(chan error, 1) }},

+	}

 	if h1, h2 := s, conf; h2.IdleTimeout == 0 {

 		if h1.IdleTimeout != 0 {

 			h2.IdleTimeout = h1.IdleTimeout

@@ -1124,25 +1152,6 @@ func (sc *serverConn) readPreface() error {

 	}

 }

-var errChanPool = sync.Pool{

-	New: func() interface{} { return make(chan error, 1) },

-}

-

-func getErrChan() chan error {

-	if inTests {

-		// Channels cannot be reused across synctest tests.

-		return make(chan error, 1)

-	} else {

-		return errChanPool.Get().(chan error)

-	}

-}

-

-func putErrChan(ch chan error) {

-	if !inTests {

-		errChanPool.Put(ch)

-	}

-}

-

 var writeDataPool = sync.Pool{

 	New: func() interface{} { return new(writeData) },

 }

@@ -1150,7 +1159,7 @@ var writeDataPool = sync.Pool{

 // writeDataFromHandler writes DATA response frames from a handler on

 // the given stream.

 func (sc *serverConn) writeDataFromHandler(stream *stream, data []byte, endStream bool) error {

-	ch := getErrChan()

+	ch := sc.srv.state.getErrChan()

 	writeArg := writeDataPool.Get().(*writeData)

 	*writeArg = writeData{stream.id, data, endStream}

 	err := sc.writeFrameFromHandler(FrameWriteRequest{

@@ -1182,7 +1191,7 @@ func (sc *serverConn) writeDataFromHandler(stream *stream, data []byte, endStrea

 			return errStreamClosed

 		}

 	}

-	putErrChan(ch)

+	sc.srv.state.putErrChan(ch)

 	if frameWriteDone {

 		writeDataPool.Put(writeArg)

 	}

@@ -2436,7 +2445,7 @@ func (sc *serverConn) writeHeaders(st *stream, headerData *writeResHeaders) erro

 		// waiting for this frame to be written, so an http.Flush mid-handler

 		// writes out the correct value of keys, before a handler later potentially

 		// mutates it.

-		errc = getErrChan()

+		errc = sc.srv.state.getErrChan()

 	}

 	if err := sc.writeFrameFromHandler(FrameWriteRequest{

 		write:  headerData,

@@ -2448,7 +2457,7 @@ func (sc *serverConn) writeHeaders(st *stream, headerData *writeResHeaders) erro

 	if errc != nil {

 		select {

 		case err := <-errc:

-			putErrChan(errc)

+			sc.srv.state.putErrChan(errc)

 			return err

 		case <-sc.doneServing:

 			return errClientDisconnected

@@ -3129,7 +3138,7 @@ func (w *responseWriter) Push(target string, opts *http.PushOptions) error {

 		method: opts.Method,

 		url:    u,

 		header: cloneHeader(opts.Header),

-		done:   getErrChan(),

+		done:   sc.srv.state.getErrChan(),

 	}

 	select {

@@ -3146,7 +3155,7 @@ func (w *responseWriter) Push(target string, opts *http.PushOptions) error {

 	case <-st.cw:

 		return errStreamClosed

 	case err := <-msg.done:

-		putErrChan(msg.done)

+		sc.srv.state.putErrChan(msg.done)

 		return err

 	}

 }

@@ -355,6 +355,7 @@ type ClientConn struct {

 	readIdleTimeout             time.Duration

 	pingTimeout                 time.Duration

 	extendedConnectAllowed      bool

+	strictMaxConcurrentStreams  bool

 	// rstStreamPingsBlocked works around an unfortunate gRPC behavior.

 	// gRPC strictly limits the number of PING frames that it will receive.

@@ -784,7 +785,8 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro

 		initialWindowSize:           65535,    // spec default

 		initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream,

 		maxConcurrentStreams:        initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings.

-		peerMaxHeaderListSize:       0xffffffffffffffff,          // "infinite", per spec. Use 2^64-1 instead.

+		strictMaxConcurrentStreams:  conf.StrictMaxConcurrentRequests,

+		peerMaxHeaderListSize:       0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead.

 		streams:                     make(map[uint32]*clientStream),

 		singleUse:                   singleUse,

 		seenSettingsChan:            make(chan struct{}),

@@ -1018,7 +1020,7 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) {

 		return

 	}

 	var maxConcurrentOkay bool

-	if cc.t.StrictMaxConcurrentStreams {

+	if cc.strictMaxConcurrentStreams {

 		// We'll tell the caller we can take a new request to

 		// prevent the caller from dialing a new TCP

 		// connection, but then we'll block later before

@@ -42,6 +42,8 @@ type OpenStreamOptions struct {

 	// PusherID is zero if the stream was initiated by the client. Otherwise,

 	// PusherID names the stream that pushed the newly opened stream.

 	PusherID uint32

+	// priority is used to set the priority of the newly opened stream.

+	priority PriorityParam

 }

 // FrameWriteRequest is a request to write a frame.

deleted file mode 100644

@@ -1,451 +0,0 @@

-// Copyright 2016 The Go Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style

-// license that can be found in the LICENSE file.

-

-package http2

-

-import (

-	"fmt"

-	"math"

-	"sort"

-)

-

-// RFC 7540, Section 5.3.5: the default weight is 16.

-const priorityDefaultWeight = 15 // 16 = 15 + 1

-

-// PriorityWriteSchedulerConfig configures a priorityWriteScheduler.

-type PriorityWriteSchedulerConfig struct {

-	// MaxClosedNodesInTree controls the maximum number of closed streams to

-	// retain in the priority tree. Setting this to zero saves a small amount

-	// of memory at the cost of performance.

-	//

-	// See RFC 7540, Section 5.3.4:

-	//   "It is possible for a stream to become closed while prioritization

-	//   information ... is in transit. ... This potentially creates suboptimal

-	//   prioritization, since the stream could be given a priority that is

-	//   different from what is intended. To avoid these problems, an endpoint

-	//   SHOULD retain stream prioritization state for a period after streams

-	//   become closed. The longer state is retained, the lower the chance that

-	//   streams are assigned incorrect or default priority values."

-	MaxClosedNodesInTree int

-

-	// MaxIdleNodesInTree controls the maximum number of idle streams to

-	// retain in the priority tree. Setting this to zero saves a small amount

-	// of memory at the cost of performance.

-	//

-	// See RFC 7540, Section 5.3.4:

-	//   Similarly, streams that are in the "idle" state can be assigned

-	//   priority or become a parent of other streams. This allows for the

-	//   creation of a grouping node in the dependency tree, which enables

-	//   more flexible expressions of priority. Idle streams begin with a

-	//   default priority (Section 5.3.5).

-	MaxIdleNodesInTree int

-

-	// ThrottleOutOfOrderWrites enables write throttling to help ensure that

-	// data is delivered in priority order. This works around a race where

-	// stream B depends on stream A and both streams are about to call Write

-	// to queue DATA frames. If B wins the race, a naive scheduler would eagerly

-	// write as much data from B as possible, but this is suboptimal because A

-	// is a higher-priority stream. With throttling enabled, we write a small

-	// amount of data from B to minimize the amount of bandwidth that B can

-	// steal from A.

-	ThrottleOutOfOrderWrites bool

-}

-

-// NewPriorityWriteScheduler constructs a WriteScheduler that schedules

-// frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3.

-// If cfg is nil, default options are used.

-func NewPriorityWriteScheduler(cfg *PriorityWriteSchedulerConfig) WriteScheduler {

-	if cfg == nil {

-		// For justification of these defaults, see:

-		// https://docs.google.com/document/d/1oLhNg1skaWD4_DtaoCxdSRN5erEXrH-KnLrMwEpOtFY

-		cfg = &PriorityWriteSchedulerConfig{

-			MaxClosedNodesInTree:     10,

-			MaxIdleNodesInTree:       10,

-			ThrottleOutOfOrderWrites: false,

-		}

-	}

-

-	ws := &priorityWriteScheduler{

-		nodes:                make(map[uint32]*priorityNode),

-		maxClosedNodesInTree: cfg.MaxClosedNodesInTree,

-		maxIdleNodesInTree:   cfg.MaxIdleNodesInTree,

-		enableWriteThrottle:  cfg.ThrottleOutOfOrderWrites,

-	}

-	ws.nodes[0] = &ws.root

-	if cfg.ThrottleOutOfOrderWrites {

-		ws.writeThrottleLimit = 1024

-	} else {

-		ws.writeThrottleLimit = math.MaxInt32

-	}

-	return ws

-}

-

-type priorityNodeState int

-

-const (

-	priorityNodeOpen priorityNodeState = iota

-	priorityNodeClosed

-	priorityNodeIdle

-)

-

-// priorityNode is a node in an HTTP/2 priority tree.

-// Each node is associated with a single stream ID.

-// See RFC 7540, Section 5.3.

-type priorityNode struct {

-	q            writeQueue        // queue of pending frames to write

-	id           uint32            // id of the stream, or 0 for the root of the tree

-	weight       uint8             // the actual weight is weight+1, so the value is in [1,256]

-	state        priorityNodeState // open | closed | idle

-	bytes        int64             // number of bytes written by this node, or 0 if closed

-	subtreeBytes int64             // sum(node.bytes) of all nodes in this subtree

-

-	// These links form the priority tree.

-	parent     *priorityNode

-	kids       *priorityNode // start of the kids list

-	prev, next *priorityNode // doubly-linked list of siblings

-}

-

-func (n *priorityNode) setParent(parent *priorityNode) {

-	if n == parent {

-		panic("setParent to self")

-	}

-	if n.parent == parent {

-		return

-	}

-	// Unlink from current parent.

-	if parent := n.parent; parent != nil {

-		if n.prev == nil {

-			parent.kids = n.next

-		} else {

-			n.prev.next = n.next

-		}

-		if n.next != nil {

-			n.next.prev = n.prev

-		}

-	}

-	// Link to new parent.

-	// If parent=nil, remove n from the tree.

-	// Always insert at the head of parent.kids (this is assumed by walkReadyInOrder).

-	n.parent = parent

-	if parent == nil {

-		n.next = nil

-		n.prev = nil

-	} else {

-		n.next = parent.kids

-		n.prev = nil

-		if n.next != nil {

-			n.next.prev = n

-		}

-		parent.kids = n

-	}

-}

-

-func (n *priorityNode) addBytes(b int64) {

-	n.bytes += b

-	for ; n != nil; n = n.parent {

-		n.subtreeBytes += b

-	}

-}

-

-// walkReadyInOrder iterates over the tree in priority order, calling f for each node

-// with a non-empty write queue. When f returns true, this function returns true and the

-// walk halts. tmp is used as scratch space for sorting.

-//

-// f(n, openParent) takes two arguments: the node to visit, n, and a bool that is true

-// if any ancestor p of n is still open (ignoring the root node).

-func (n *priorityNode) walkReadyInOrder(openParent bool, tmp *[]*priorityNode, f func(*priorityNode, bool) bool) bool {

-	if !n.q.empty() && f(n, openParent) {

-		return true

-	}

-	if n.kids == nil {

-		return false

-	}

-

-	// Don't consider the root "open" when updating openParent since

-	// we can't send data frames on the root stream (only control frames).

-	if n.id != 0 {

-		openParent = openParent || (n.state == priorityNodeOpen)

-	}

-

-	// Common case: only one kid or all kids have the same weight.

-	// Some clients don't use weights; other clients (like web browsers)

-	// use mostly-linear priority trees.

-	w := n.kids.weight

-	needSort := false

-	for k := n.kids.next; k != nil; k = k.next {

-		if k.weight != w {

-			needSort = true

-			break

-		}

-	}

-	if !needSort {

-		for k := n.kids; k != nil; k = k.next {

-			if k.walkReadyInOrder(openParent, tmp, f) {

-				return true

-			}

-		}

-		return false

-	}

-

-	// Uncommon case: sort the child nodes. We remove the kids from the parent,

-	// then re-insert after sorting so we can reuse tmp for future sort calls.

-	*tmp = (*tmp)[:0]

-	for n.kids != nil {

-		*tmp = append(*tmp, n.kids)

-		n.kids.setParent(nil)

-	}

-	sort.Sort(sortPriorityNodeSiblings(*tmp))

-	for i := len(*tmp) - 1; i >= 0; i-- {

-		(*tmp)[i].setParent(n) // setParent inserts at the head of n.kids

-	}

-	for k := n.kids; k != nil; k = k.next {

-		if k.walkReadyInOrder(openParent, tmp, f) {

-			return true

-		}

-	}

-	return false

-}

-

-type sortPriorityNodeSiblings []*priorityNode

-

-func (z sortPriorityNodeSiblings) Len() int      { return len(z) }

-func (z sortPriorityNodeSiblings) Swap(i, k int) { z[i], z[k] = z[k], z[i] }

-func (z sortPriorityNodeSiblings) Less(i, k int) bool {

-	// Prefer the subtree that has sent fewer bytes relative to its weight.

-	// See sections 5.3.2 and 5.3.4.

-	wi, bi := float64(z[i].weight+1), float64(z[i].subtreeBytes)

-	wk, bk := float64(z[k].weight+1), float64(z[k].subtreeBytes)

-	if bi == 0 && bk == 0 {

-		return wi >= wk

-	}

-	if bk == 0 {

-		return false

-	}

-	return bi/bk <= wi/wk

-}

-

-type priorityWriteScheduler struct {

-	// root is the root of the priority tree, where root.id = 0.

-	// The root queues control frames that are not associated with any stream.

-	root priorityNode

-

-	// nodes maps stream ids to priority tree nodes.

-	nodes map[uint32]*priorityNode

-

-	// maxID is the maximum stream id in nodes.

-	maxID uint32

-

-	// lists of nodes that have been closed or are idle, but are kept in

-	// the tree for improved prioritization. When the lengths exceed either

-	// maxClosedNodesInTree or maxIdleNodesInTree, old nodes are discarded.

-	closedNodes, idleNodes []*priorityNode

-

-	// From the config.

-	maxClosedNodesInTree int

-	maxIdleNodesInTree   int

-	writeThrottleLimit   int32

-	enableWriteThrottle  bool

-

-	// tmp is scratch space for priorityNode.walkReadyInOrder to reduce allocations.

-	tmp []*priorityNode

-

-	// pool of empty queues for reuse.

-	queuePool writeQueuePool

-}

-

-func (ws *priorityWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) {

-	// The stream may be currently idle but cannot be opened or closed.

-	if curr := ws.nodes[streamID]; curr != nil {

-		if curr.state != priorityNodeIdle {

-			panic(fmt.Sprintf("stream %d already opened", streamID))

-		}

-		curr.state = priorityNodeOpen

-		return

-	}

-

-	// RFC 7540, Section 5.3.5:

-	//  "All streams are initially assigned a non-exclusive dependency on stream 0x0.

-	//  Pushed streams initially depend on their associated stream. In both cases,

-	//  streams are assigned a default weight of 16."

-	parent := ws.nodes[options.PusherID]

-	if parent == nil {

-		parent = &ws.root

-	}

-	n := &priorityNode{

-		q:      *ws.queuePool.get(),

-		id:     streamID,

-		weight: priorityDefaultWeight,

-		state:  priorityNodeOpen,

-	}

-	n.setParent(parent)

-	ws.nodes[streamID] = n

-	if streamID > ws.maxID {

-		ws.maxID = streamID

-	}

-}

-

-func (ws *priorityWriteScheduler) CloseStream(streamID uint32) {

-	if streamID == 0 {

-		panic("violation of WriteScheduler interface: cannot close stream 0")

-	}

-	if ws.nodes[streamID] == nil {

-		panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))

-	}

-	if ws.nodes[streamID].state != priorityNodeOpen {

-		panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))

-	}

-

-	n := ws.nodes[streamID]

-	n.state = priorityNodeClosed

-	n.addBytes(-n.bytes)

-

-	q := n.q

-	ws.queuePool.put(&q)

-	n.q.s = nil

-	if ws.maxClosedNodesInTree > 0 {

-		ws.addClosedOrIdleNode(&ws.closedNodes, ws.maxClosedNodesInTree, n)

-	} else {

-		ws.removeNode(n)

-	}

-}

-

-func (ws *priorityWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) {

-	if streamID == 0 {

-		panic("adjustPriority on root")

-	}

-

-	// If streamID does not exist, there are two cases:

-	// - A closed stream that has been removed (this will have ID <= maxID)

-	// - An idle stream that is being used for "grouping" (this will have ID > maxID)

-	n := ws.nodes[streamID]

-	if n == nil {

-		if streamID <= ws.maxID || ws.maxIdleNodesInTree == 0 {

-			return

-		}

-		ws.maxID = streamID

-		n = &priorityNode{

-			q:      *ws.queuePool.get(),

-			id:     streamID,

-			weight: priorityDefaultWeight,

-			state:  priorityNodeIdle,

-		}

-		n.setParent(&ws.root)

-		ws.nodes[streamID] = n

-		ws.addClosedOrIdleNode(&ws.idleNodes, ws.maxIdleNodesInTree, n)

-	}

-

-	// Section 5.3.1: A dependency on a stream that is not currently in the tree

-	// results in that stream being given a default priority (Section 5.3.5).

-	parent := ws.nodes[priority.StreamDep]

-	if parent == nil {

-		n.setParent(&ws.root)

-		n.weight = priorityDefaultWeight

-		return

-	}

-

-	// Ignore if the client tries to make a node its own parent.

-	if n == parent {

-		return

-	}

-

-	// Section 5.3.3:

-	//   "If a stream is made dependent on one of its own dependencies, the

-	//   formerly dependent stream is first moved to be dependent on the

-	//   reprioritized stream's previous parent. The moved dependency retains

-	//   its weight."

-	//

-	// That is: if parent depends on n, move parent to depend on n.parent.

-	for x := parent.parent; x != nil; x = x.parent {

-		if x == n {

-			parent.setParent(n.parent)

-			break

-		}

-	}

-

-	// Section 5.3.3: The exclusive flag causes the stream to become the sole

-	// dependency of its parent stream, causing other dependencies to become

-	// dependent on the exclusive stream.

-	if priority.Exclusive {

-		k := parent.kids

-		for k != nil {

-			next := k.next

-			if k != n {

-				k.setParent(n)

-			}

-			k = next

-		}

-	}

-

-	n.setParent(parent)

-	n.weight = priority.Weight

-}

-

-func (ws *priorityWriteScheduler) Push(wr FrameWriteRequest) {

-	var n *priorityNode

-	if wr.isControl() {

-		n = &ws.root

-	} else {

-		id := wr.StreamID()

-		n = ws.nodes[id]

-		if n == nil {

-			// id is an idle or closed stream. wr should not be a HEADERS or

-			// DATA frame. In other case, we push wr onto the root, rather

-			// than creating a new priorityNode.

-			if wr.DataSize() > 0 {

-				panic("add DATA on non-open stream")

-			}

-			n = &ws.root

-		}

-	}

-	n.q.push(wr)

-}

-

-func (ws *priorityWriteScheduler) Pop() (wr FrameWriteRequest, ok bool) {

-	ws.root.walkReadyInOrder(false, &ws.tmp, func(n *priorityNode, openParent bool) bool {

-		limit := int32(math.MaxInt32)

-		if openParent {

-			limit = ws.writeThrottleLimit

-		}

-		wr, ok = n.q.consume(limit)

-		if !ok {

-			return false

-		}

-		n.addBytes(int64(wr.DataSize()))

-		// If B depends on A and B continuously has data available but A

-		// does not, gradually increase the throttling limit to allow B to

-		// steal more and more bandwidth from A.

-		if openParent {

-			ws.writeThrottleLimit += 1024

-			if ws.writeThrottleLimit < 0 {

-				ws.writeThrottleLimit = math.MaxInt32

-			}

-		} else if ws.enableWriteThrottle {

-			ws.writeThrottleLimit = 1024

-		}

-		return true

-	})

-	return wr, ok

-}

-

-func (ws *priorityWriteScheduler) addClosedOrIdleNode(list *[]*priorityNode, maxSize int, n *priorityNode) {

-	if maxSize == 0 {

-		return

-	}

-	if len(*list) == maxSize {

-		// Remove the oldest node, then shift left.

-		ws.removeNode((*list)[0])

-		x := (*list)[1:]

-		copy(*list, x)

-		*list = (*list)[:len(x)]

-	}

-	*list = append(*list, n)

-}

-

-func (ws *priorityWriteScheduler) removeNode(n *priorityNode) {

-	for n.kids != nil {

-		n.kids.setParent(n.parent)

-	}

-	n.setParent(nil)

-	delete(ws.nodes, n.id)

-}

new file mode 100644

@@ -0,0 +1,451 @@

+// Copyright 2016 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+package http2

+

+import (

+	"fmt"

+	"math"

+	"sort"

+)

+

+// RFC 7540, Section 5.3.5: the default weight is 16.

+const priorityDefaultWeightRFC7540 = 15 // 16 = 15 + 1

+

+// PriorityWriteSchedulerConfig configures a priorityWriteScheduler.

+type PriorityWriteSchedulerConfig struct {

+	// MaxClosedNodesInTree controls the maximum number of closed streams to

+	// retain in the priority tree. Setting this to zero saves a small amount

+	// of memory at the cost of performance.

+	//

+	// See RFC 7540, Section 5.3.4:

+	//   "It is possible for a stream to become closed while prioritization

+	//   information ... is in transit. ... This potentially creates suboptimal

+	//   prioritization, since the stream could be given a priority that is

+	//   different from what is intended. To avoid these problems, an endpoint

+	//   SHOULD retain stream prioritization state for a period after streams

+	//   become closed. The longer state is retained, the lower the chance that

+	//   streams are assigned incorrect or default priority values."

+	MaxClosedNodesInTree int

+

+	// MaxIdleNodesInTree controls the maximum number of idle streams to

+	// retain in the priority tree. Setting this to zero saves a small amount

+	// of memory at the cost of performance.

+	//

+	// See RFC 7540, Section 5.3.4:

+	//   Similarly, streams that are in the "idle" state can be assigned

+	//   priority or become a parent of other streams. This allows for the

+	//   creation of a grouping node in the dependency tree, which enables

+	//   more flexible expressions of priority. Idle streams begin with a

+	//   default priority (Section 5.3.5).

+	MaxIdleNodesInTree int

+

+	// ThrottleOutOfOrderWrites enables write throttling to help ensure that

+	// data is delivered in priority order. This works around a race where

+	// stream B depends on stream A and both streams are about to call Write

+	// to queue DATA frames. If B wins the race, a naive scheduler would eagerly

+	// write as much data from B as possible, but this is suboptimal because A

+	// is a higher-priority stream. With throttling enabled, we write a small

+	// amount of data from B to minimize the amount of bandwidth that B can

+	// steal from A.

+	ThrottleOutOfOrderWrites bool

+}

+

+// NewPriorityWriteScheduler constructs a WriteScheduler that schedules

+// frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3.

+// If cfg is nil, default options are used.

+func NewPriorityWriteScheduler(cfg *PriorityWriteSchedulerConfig) WriteScheduler {

+	if cfg == nil {

+		// For justification of these defaults, see:

+		// https://docs.google.com/document/d/1oLhNg1skaWD4_DtaoCxdSRN5erEXrH-KnLrMwEpOtFY

+		cfg = &PriorityWriteSchedulerConfig{

+			MaxClosedNodesInTree:     10,

+			MaxIdleNodesInTree:       10,

+			ThrottleOutOfOrderWrites: false,

+		}

+	}

+

+	ws := &priorityWriteSchedulerRFC7540{

+		nodes:                make(map[uint32]*priorityNodeRFC7540),

+		maxClosedNodesInTree: cfg.MaxClosedNodesInTree,

+		maxIdleNodesInTree:   cfg.MaxIdleNodesInTree,

+		enableWriteThrottle:  cfg.ThrottleOutOfOrderWrites,

+	}

+	ws.nodes[0] = &ws.root

+	if cfg.ThrottleOutOfOrderWrites {

+		ws.writeThrottleLimit = 1024

+	} else {

+		ws.writeThrottleLimit = math.MaxInt32

+	}

+	return ws

+}

+

+type priorityNodeStateRFC7540 int

+

+const (

+	priorityNodeOpenRFC7540 priorityNodeStateRFC7540 = iota

+	priorityNodeClosedRFC7540

+	priorityNodeIdleRFC7540

+)

+

+// priorityNodeRFC7540 is a node in an HTTP/2 priority tree.

+// Each node is associated with a single stream ID.

+// See RFC 7540, Section 5.3.

+type priorityNodeRFC7540 struct {

+	q            writeQueue               // queue of pending frames to write

+	id           uint32                   // id of the stream, or 0 for the root of the tree

+	weight       uint8                    // the actual weight is weight+1, so the value is in [1,256]

+	state        priorityNodeStateRFC7540 // open | closed | idle