Remove dependency on golang.org/x/xerrors

See #182

Author: nhooyr

accept.go

@@ -6,14 +6,14 @@ import (
 	"bytes"
 	"crypto/sha1"
 	"encoding/base64"
+	"errors"
+	"fmt"
 	"io"
 	"net/http"
 	"net/textproto"
 	"net/url"
 	"strings"
 
-	"golang.org/x/xerrors"
-
 	"nhooyr.io/websocket/internal/errd"
 )
 
@@ -85,7 +85,7 @@ func accept(w http.ResponseWriter, r *http.Request, opts *AcceptOptions) (_ *Con
 
 	hj, ok := w.(http.Hijacker)
 	if !ok {
-		err = xerrors.New("http.ResponseWriter does not implement http.Hijacker")
+		err = errors.New("http.ResponseWriter does not implement http.Hijacker")
 		http.Error(w, http.StatusText(http.StatusNotImplemented), http.StatusNotImplemented)
 		return nil, err
 	}
@@ -110,7 +110,7 @@ func accept(w http.ResponseWriter, r *http.Request, opts *AcceptOptions) (_ *Con
 
 	netConn, brw, err := hj.Hijack()
 	if err != nil {
-		err = xerrors.Errorf("failed to hijack connection: %w", err)
+		err = fmt.Errorf("failed to hijack connection: %w", err)
 		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		return nil, err
 	}
@@ -133,32 +133,32 @@ func accept(w http.ResponseWriter, r *http.Request, opts *AcceptOptions) (_ *Con
 
 func verifyClientRequest(w http.ResponseWriter, r *http.Request) (errCode int, _ error) {
 	if !r.ProtoAtLeast(1, 1) {
-		return http.StatusUpgradeRequired, xerrors.Errorf("WebSocket protocol violation: handshake request must be at least HTTP/1.1: %q", r.Proto)
+		return http.StatusUpgradeRequired, fmt.Errorf("WebSocket protocol violation: handshake request must be at least HTTP/1.1: %q", r.Proto)
 	}
 
 	if !headerContainsToken(r.Header, "Connection", "Upgrade") {
 		w.Header().Set("Connection", "Upgrade")
 		w.Header().Set("Upgrade", "websocket")
-		return http.StatusUpgradeRequired, xerrors.Errorf("WebSocket protocol violation: Connection header %q does not contain Upgrade", r.Header.Get("Connection"))
+		return http.StatusUpgradeRequired, fmt.Errorf("WebSocket protocol violation: Connection header %q does not contain Upgrade", r.Header.Get("Connection"))
 	}
 
 	if !headerContainsToken(r.Header, "Upgrade", "websocket") {
 		w.Header().Set("Connection", "Upgrade")
 		w.Header().Set("Upgrade", "websocket")
-		return http.StatusUpgradeRequired, xerrors.Errorf("WebSocket protocol violation: Upgrade header %q does not contain websocket", r.Header.Get("Upgrade"))
+		return http.StatusUpgradeRequired, fmt.Errorf("WebSocket protocol violation: Upgrade header %q does not contain websocket", r.Header.Get("Upgrade"))
 	}
 
 	if r.Method != "GET" {
-		return http.StatusMethodNotAllowed, xerrors.Errorf("WebSocket protocol violation: handshake request method is not GET but %q", r.Method)
+		return http.StatusMethodNotAllowed, fmt.Errorf("WebSocket protocol violation: handshake request method is not GET but %q", r.Method)
 	}
 
 	if r.Header.Get("Sec-WebSocket-Version") != "13" {
 		w.Header().Set("Sec-WebSocket-Version", "13")
-		return http.StatusBadRequest, xerrors.Errorf("unsupported WebSocket protocol version (only 13 is supported): %q", r.Header.Get("Sec-WebSocket-Version"))
+		return http.StatusBadRequest, fmt.Errorf("unsupported WebSocket protocol version (only 13 is supported): %q", r.Header.Get("Sec-WebSocket-Version"))
 	}
 
 	if r.Header.Get("Sec-WebSocket-Key") == "" {
-		return http.StatusBadRequest, xerrors.New("WebSocket protocol violation: missing Sec-WebSocket-Key")
+		return http.StatusBadRequest, errors.New("WebSocket protocol violation: missing Sec-WebSocket-Key")
 	}
 
 	return 0, nil
@@ -169,10 +169,10 @@ func authenticateOrigin(r *http.Request) error {
 	if origin != "" {
 		u, err := url.Parse(origin)
 		if err != nil {
-			return xerrors.Errorf("failed to parse Origin header %q: %w", origin, err)
+			return fmt.Errorf("failed to parse Origin header %q: %w", origin, err)
 		}
 		if !strings.EqualFold(u.Host, r.Host) {
-			return xerrors.Errorf("request Origin %q is not authorized for Host %q", origin, r.Host)
+			return fmt.Errorf("request Origin %q is not authorized for Host %q", origin, r.Host)
 		}
 	}
 	return nil
@@ -223,7 +223,7 @@ func acceptDeflate(w http.ResponseWriter, ext websocketExtension, mode Compressi
 			continue
 		}
 
-		err := xerrors.Errorf("unsupported permessage-deflate parameter: %q", p)
+		err := fmt.Errorf("unsupported permessage-deflate parameter: %q", p)
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return nil, err
 	}
@@ -253,7 +253,7 @@ func acceptWebkitDeflate(w http.ResponseWriter, ext websocketExtension, mode Com
 		//
 		// Either way, we're only implementing this for webkit which never sends the max_window_bits
 		// parameter so we don't need to worry about it.
-		err := xerrors.Errorf("unsupported x-webkit-deflate-frame parameter: %q", p)
+		err := fmt.Errorf("unsupported x-webkit-deflate-frame parameter: %q", p)
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return nil, err
 	}

accept_js.go

@@ -1,9 +1,8 @@
 package websocket
 
 import (
+	"errors"
 	"net/http"
-
-	"golang.org/x/xerrors"
 )
 
 // AcceptOptions represents Accept's options.
@@ -16,5 +15,5 @@ type AcceptOptions struct {
 
 // Accept is stubbed out for Wasm.
 func Accept(w http.ResponseWriter, r *http.Request, opts *AcceptOptions) (*Conn, error) {
-	return nil, xerrors.New("unimplemented")
+	return nil, errors.New("unimplemented")
 }

accept_test.go

@@ -4,14 +4,13 @@ package websocket
 
 import (
 	"bufio"
+	"errors"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 
-	"golang.org/x/xerrors"
-
 	"nhooyr.io/websocket/internal/test/assert"
 )
 
@@ -80,7 +79,7 @@ func TestAccept(t *testing.T) {
 		w := mockHijacker{
 			ResponseWriter: httptest.NewRecorder(),
 			hijack: func() (conn net.Conn, writer *bufio.ReadWriter, err error) {
-				return nil, nil, xerrors.New("haha")
+				return nil, nil, errors.New("haha")
 			},
 		}
 

autobahn_test.go

@@ -15,8 +15,6 @@ import (
 	"testing"
 	"time"
 
-	"golang.org/x/xerrors"
-
 	"nhooyr.io/websocket"
 	"nhooyr.io/websocket/internal/errd"
 	"nhooyr.io/websocket/internal/test/assert"
@@ -108,7 +106,7 @@ func wstestClientServer(ctx context.Context) (url string, closeFn func(), err er
 		"exclude-cases": excludedAutobahnCases,
 	})
 	if err != nil {
-		return "", nil, xerrors.Errorf("failed to write spec: %w", err)
+		return "", nil, fmt.Errorf("failed to write spec: %w", err)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute*15)
@@ -126,7 +124,7 @@ func wstestClientServer(ctx context.Context) (url string, closeFn func(), err er
 	wstest := exec.CommandContext(ctx, "wstest", args...)
 	err = wstest.Start()
 	if err != nil {
-		return "", nil, xerrors.Errorf("failed to start wstest: %w", err)
+		return "", nil, fmt.Errorf("failed to start wstest: %w", err)
 	}
 
 	return url, func() {
@@ -209,20 +207,20 @@ func unusedListenAddr() (_ string, err error) {
 func tempJSONFile(v interface{}) (string, error) {
 	f, err := ioutil.TempFile("", "temp.json")
 	if err != nil {
-		return "", xerrors.Errorf("temp file: %w", err)
+		return "", fmt.Errorf("temp file: %w", err)
 	}
 	defer f.Close()
 
 	e := json.NewEncoder(f)
 	e.SetIndent("", "\t")
 	err = e.Encode(v)
 	if err != nil {
-		return "", xerrors.Errorf("json encode: %w", err)
+		return "", fmt.Errorf("json encode: %w", err)
 	}
 
 	err = f.Close()
 	if err != nil {
-		return "", xerrors.Errorf("close temp file: %w", err)
+		return "", fmt.Errorf("close temp file: %w", err)
 	}
 
 	return f.Name(), nil

close.go

@@ -1,9 +1,8 @@
 package websocket
 
 import (
+	"errors"
 	"fmt"
-
-	"golang.org/x/xerrors"
 )
 
 // StatusCode represents a WebSocket status code.
@@ -53,7 +52,7 @@ const (
 
 // CloseError is returned when the connection is closed with a status and reason.
 //
-// Use Go 1.13's xerrors.As to check for this error.
+// Use Go 1.13's errors.As to check for this error.
 // Also see the CloseStatus helper.
 type CloseError struct {
 	Code   StatusCode
@@ -64,13 +63,13 @@ func (ce CloseError) Error() string {
 	return fmt.Sprintf("status = %v and reason = %q", ce.Code, ce.Reason)
 }
 
-// CloseStatus is a convenience wrapper around Go 1.13's xerrors.As to grab
+// CloseStatus is a convenience wrapper around Go 1.13's errors.As to grab
 // the status code from a CloseError.
 //
 // -1 will be returned if the passed error is nil or not a CloseError.
 func CloseStatus(err error) StatusCode {
 	var ce CloseError
-	if xerrors.As(err, &ce) {
+	if errors.As(err, &ce) {
 		return ce.Code
 	}
 	return -1

close_notjs.go

@@ -5,11 +5,11 @@ package websocket
 import (
 	"context"
 	"encoding/binary"
+	"errors"
+	"fmt"
 	"log"
 	"time"
 
-	"golang.org/x/xerrors"
-
 	"nhooyr.io/websocket/internal/errd"
 )
 
@@ -46,7 +46,7 @@ func (c *Conn) closeHandshake(code StatusCode, reason string) (err error) {
 	return nil
 }
 
-var errAlreadyWroteClose = xerrors.New("already wrote close")
+var errAlreadyWroteClose = errors.New("already wrote close")
 
 func (c *Conn) writeClose(code StatusCode, reason string) error {
 	c.closeMu.Lock()
@@ -62,7 +62,7 @@ func (c *Conn) writeClose(code StatusCode, reason string) error {
 		Reason: reason,
 	}
 
-	c.setCloseErr(xerrors.Errorf("sent close frame: %w", ce))
+	c.setCloseErr(fmt.Errorf("sent close frame: %w", ce))
 
 	var p []byte
 	var err error
@@ -119,7 +119,7 @@ func parseClosePayload(p []byte) (CloseError, error) {
 	}
 
 	if len(p) < 2 {
-		return CloseError{}, xerrors.Errorf("close payload %q too small, cannot even contain the 2 byte status code", p)
+		return CloseError{}, fmt.Errorf("close payload %q too small, cannot even contain the 2 byte status code", p)
 	}
 
 	ce := CloseError{
@@ -128,7 +128,7 @@ func parseClosePayload(p []byte) (CloseError, error) {
 	}
 
 	if !validWireCloseCode(ce.Code) {
-		return CloseError{}, xerrors.Errorf("invalid status code %v", ce.Code)
+		return CloseError{}, fmt.Errorf("invalid status code %v", ce.Code)
 	}
 
 	return ce, nil
@@ -155,7 +155,7 @@ func validWireCloseCode(code StatusCode) bool {
 func (ce CloseError) bytes() ([]byte, error) {
 	p, err := ce.bytesErr()
 	if err != nil {
-		err = xerrors.Errorf("failed to marshal close frame: %w", err)
+		err = fmt.Errorf("failed to marshal close frame: %w", err)
 		ce = CloseError{
 			Code: StatusInternalError,
 		}
@@ -168,11 +168,11 @@ const maxCloseReason = maxControlPayload - 2
 
 func (ce CloseError) bytesErr() ([]byte, error) {
 	if len(ce.Reason) > maxCloseReason {
-		return nil, xerrors.Errorf("reason string max is %v but got %q with length %v", maxCloseReason, ce.Reason, len(ce.Reason))
+		return nil, fmt.Errorf("reason string max is %v but got %q with length %v", maxCloseReason, ce.Reason, len(ce.Reason))
 	}
 
 	if !validWireCloseCode(ce.Code) {
-		return nil, xerrors.Errorf("status code %v cannot be set", ce.Code)
+		return nil, fmt.Errorf("status code %v cannot be set", ce.Code)
 	}
 
 	buf := make([]byte, 2+len(ce.Reason))
@@ -189,7 +189,7 @@ func (c *Conn) setCloseErr(err error) {
 
 func (c *Conn) setCloseErrLocked(err error) {
 	if c.closeErr == nil {
-		c.closeErr = xerrors.Errorf("WebSocket closed: %w", err)
+		c.closeErr = fmt.Errorf("WebSocket closed: %w", err)
 	}
 }
 

conn_notjs.go

@@ -5,13 +5,13 @@ package websocket
 import (
 	"bufio"
 	"context"
+	"errors"
+	"fmt"
 	"io"
 	"runtime"
 	"strconv"
 	"sync"
 	"sync/atomic"
-
-	"golang.org/x/xerrors"
 )
 
 // Conn represents a WebSocket connection.
@@ -108,7 +108,7 @@ func newConn(cfg connConfig) *Conn {
 	}
 
 	runtime.SetFinalizer(c, func(c *Conn) {
-		c.close(xerrors.New("connection garbage collected"))
+		c.close(errors.New("connection garbage collected"))
 	})
 
 	go c.timeoutLoop()
@@ -165,10 +165,10 @@ func (c *Conn) timeoutLoop() {
 		case readCtx = <-c.readTimeout:
 
 		case <-readCtx.Done():
-			c.setCloseErr(xerrors.Errorf("read timed out: %w", readCtx.Err()))
-			go c.writeError(StatusPolicyViolation, xerrors.New("timed out"))
+			c.setCloseErr(fmt.Errorf("read timed out: %w", readCtx.Err()))
+			go c.writeError(StatusPolicyViolation, errors.New("timed out"))
 		case <-writeCtx.Done():
-			c.close(xerrors.Errorf("write timed out: %w", writeCtx.Err()))
+			c.close(fmt.Errorf("write timed out: %w", writeCtx.Err()))
 			return
 		}
 	}
@@ -190,7 +190,7 @@ func (c *Conn) Ping(ctx context.Context) error {
 
 	err := c.ping(ctx, strconv.Itoa(int(p)))
 	if err != nil {
-		return xerrors.Errorf("failed to ping: %w", err)
+		return fmt.Errorf("failed to ping: %w", err)
 	}
 	return nil
 }
@@ -217,7 +217,7 @@ func (c *Conn) ping(ctx context.Context, p string) error {
 	case <-c.closed:
 		return c.closeErr
 	case <-ctx.Done():
-		err := xerrors.Errorf("failed to wait for pong: %w", ctx.Err())
+		err := fmt.Errorf("failed to wait for pong: %w", ctx.Err())
 		c.close(err)
 		return err
 	case <-pong:
@@ -242,7 +242,7 @@ func (m *mu) Lock(ctx context.Context) error {
 	case <-m.c.closed:
 		return m.c.closeErr
 	case <-ctx.Done():
-		err := xerrors.Errorf("failed to acquire lock: %w", ctx.Err())
+		err := fmt.Errorf("failed to acquire lock: %w", ctx.Err())
 		m.c.close(err)
 		return err
 	case m.ch <- struct{}{}: