support github.com/gobwas/pool updates

client.go

@@ -247,7 +247,7 @@ func (d Dialer) handshake(req *request, resp Response) (protocol string, extensi
 type readerPool int
 
 func (n readerPool) Get(r io.Reader) *bufio.Reader { return pbufio.GetReader(r, int(n)) }
-func (n readerPool) Put(r *bufio.Reader)           { pbufio.PutReader(r, int(n)) }
+func (n readerPool) Put(r *bufio.Reader)           { pbufio.PutReader(r) }
 
 type writerPool int
 

server.go

@@ -329,9 +329,9 @@ func (u Upgrader) Upgrade(conn io.ReadWriter) (hs Handshake, err error) {
 		br = brw.Reader
 		bw = brw.Writer
 	} else {
-		readBufSize := nonZero(u.ReadBufferSize, DefaultReadBufferSize)
-		br = pbufio.GetReader(conn, readBufSize)
-		defer pbufio.PutReader(br, readBufSize)
+		n := nonZero(u.ReadBufferSize, DefaultReadBufferSize)
+		br = pbufio.GetReader(conn, n)
+		defer pbufio.PutReader(br)
 	}
 
 	// Read HTTP request line like "GET /ws HTTP/1.1".

server_test.go

@@ -308,9 +308,12 @@ func TestHTTPUpgrader(t *testing.T) {
 			}
 
 			// Need to emulate http server read request for truth test.
-			var rbuf bytes.Buffer
-			test.req.Write(&rbuf)
-			req, err := http.ReadRequest(bufio.NewReader(&rbuf))
+			//
+			// We use dumpRequest here because test.req.Write is always send
+			// http/1.1 proto version, that does not fits all our testing
+			// cases.
+			reqBytes := dumpRequest(test.req)
+			req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(reqBytes)))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -323,7 +326,10 @@ func TestHTTPUpgrader(t *testing.T) {
 			}
 			_, _, hs, err := u.Upgrade(req, res, nil)
 			if test.err != err {
-				t.Errorf("expected error to be '%v', got '%v'", test.err, err)
+				t.Errorf(
+					"expected error to be '%v', got '%v';\non request:\n====\n%s\n====",
+					test.err, err, dumpRequest(req),
+				)
 				return
 			}
 

wsutil/cipher.go

@@ -47,8 +47,8 @@ func (c *CipherWriter) Reset(w io.Writer, mask [4]byte) {
 }
 
 func (c *CipherWriter) Write(p []byte) (n int, err error) {
-	cp := pbytes.GetBufLen(len(p))
-	defer pbytes.PutBuf(cp)
+	cp := pbytes.GetLen(len(p))
+	defer pbytes.Put(cp)
 
 	copy(cp, p)
 	ws.Cipher(cp, c.mask, c.pos)

wsutil/handler.go

@@ -42,12 +42,12 @@ func PingHandler(w io.Writer, state ws.State) FrameHandler {
 		// In other way reply with Pong frame with copied payload.
 		// Note that int(h.Length) is safe here because control frame i
 		// could be <= 125 bytes length by RFC.
-		p := pbytes.GetBufLen(int(h.Length) + ws.HeaderSize(ws.Header{
+		p := pbytes.GetLen(int(h.Length) + ws.HeaderSize(ws.Header{
 			Length: h.Length,
 			OpCode: ws.OpPong,
 			Masked: state.Is(ws.StateClientSide),
 		}))
-		defer pbytes.PutBuf(p)
+		defer pbytes.Put(p)
 
 		w := NewControlWriterBuffer(w, state, ws.OpPong, p)
 		_, err = io.Copy(w, rd)
@@ -67,8 +67,8 @@ func PongHandler(w io.Writer, state ws.State) FrameHandler {
 
 		// int(h.Length) is safe here because control frame could be < 125
 		// bytes length by RFC.
-		buf := pbytes.GetBufLen(int(h.Length))
-		defer pbytes.PutBuf(buf)
+		buf := pbytes.GetLen(int(h.Length))
+		defer pbytes.Put(buf)
 
 		// Discard pong message according to the RFC6455:
 		// A Pong frame MAY be sent unsolicited. This serves as a
@@ -93,8 +93,8 @@ func CloseHandler(w io.Writer, state ws.State) FrameHandler {
 		} else {
 			// int(h.Length) is safe here because control frame could be < 125
 			// bytes length by RFC.
-			p := pbytes.GetBufLen(int(h.Length))
-			defer pbytes.PutBuf(p)
+			p := pbytes.GetLen(int(h.Length))
+			defer pbytes.Put(p)
 
 			_, err = io.ReadFull(rd, p)
 			if err != nil {

wsutil/writer.go

@@ -433,8 +433,8 @@ func writeFrame(w io.Writer, s ws.State, op ws.OpCode, fin bool, p []byte) error
 	var frame ws.Frame
 	if s.Is(ws.StateClientSide) {
 		// Should copy bytes to prevent corruption of caller data.
-		payload := pbytes.GetBufLen(len(p))
-		defer pbytes.PutBuf(payload)
+		payload := pbytes.GetLen(len(p))
+		defer pbytes.Put(payload)
 
 		copy(payload, p)