Remove readLoop

Closes #93

Author: nhooyr

README.md

@@ -123,24 +123,18 @@ it has to reinvent hooks for TLS and proxies and prevents support of HTTP/2.
 Some more advantages of nhooyr/websocket are that it supports concurrent writes and
 makes it very easy to close the connection with a status code and reason.
 
-nhooyr/websocket also responds to pings, pongs and close frames in a separate goroutine so that
-your application doesn't always need to read from the connection unless it expects a data message.
-gorilla/websocket requires you to constantly read from the connection to respond to control frames
-even if you don't expect the peer to send any messages.
-
 The ping API is also much nicer. gorilla/websocket requires registering a pong handler on the Conn
 which results in awkward control flow. With nhooyr/websocket you use the Ping method on the Conn
 that sends a ping and also waits for the pong.
 
 In terms of performance, the differences depend on your application code. nhooyr/websocket
 reuses buffers efficiently out of the box if you use the wsjson and wspb subpackages whereas
-gorilla/websocket does not. As mentioned above, nhooyr/websocket also supports concurrent
+gorilla/websocket does not at all. As mentioned above, nhooyr/websocket also supports concurrent
 writers out of the box.
 
-The only performance con to nhooyr/websocket is that uses two extra goroutines. One for
-reading pings, pongs and close frames async to application code and another to support
-context.Context cancellation. This costs 4 KB of memory which is cheap compared
-to the benefits.
+The only performance con to nhooyr/websocket is that uses one extra goroutine to support
+cancellation with context.Context and the net/http client side body upgrade.
+This costs 2 KB of memory which is cheap compared to simplicity benefits.
 
 ### x/net/websocket
 

accept.go

@@ -81,9 +81,6 @@ func verifyClientRequest(w http.ResponseWriter, r *http.Request) error {
 // Accept will reject the handshake if the Origin domain is not the same as the Host unless
 // the InsecureSkipVerify option is set. In other words, by default it does not allow
 // cross origin requests.
-//
-// The returned connection will be bound by r.Context(). Use conn.Context() to change
-// the bounding context.
 func Accept(w http.ResponseWriter, r *http.Request, opts AcceptOptions) (*Conn, error) {
 	c, err := accept(w, r, opts)
 	if err != nil {
@@ -143,7 +140,6 @@ func accept(w http.ResponseWriter, r *http.Request, opts AcceptOptions) (*Conn,
 		closer:      netConn,
 	}
 	c.init()
-	c.Context(r.Context())
 
 	return c, nil
 }

limitedreader.go

@@ -1,7 +1,6 @@
 package websocket
 
 import (
-	"fmt"
 	"io"
 
 	"golang.org/x/xerrors"
@@ -20,9 +19,9 @@ func (lr *limitedReader) Read(p []byte) (int, error) {
 	}
 
 	if lr.left <= 0 {
-		msg := fmt.Sprintf("read limited at %v bytes", lr.limit)
-		lr.c.Close(StatusPolicyViolation, msg)
-		return 0, xerrors.Errorf(msg)
+		err := xerrors.Errorf("read limited at %v bytes", lr.limit)
+		lr.c.Close(StatusMessageTooBig, err.Error())
+		return 0, err
 	}
 
 	if int64(len(p)) > lr.left {