Implement more of the API for WASM

Realized I can at least make the Reader/Writer/SetReadLimit methods
work as expected even if they're not perfect.

Author: nhooyr

conn.go

@@ -59,7 +59,7 @@ type Conn struct {
 	msgReadLimit int64
 
 	// Used to ensure a previous writer is not used after being closed.
-	activeWriter *messageWriter
+	activeWriter atomic.Value
 	// messageWriter state.
 	writeMsgOpcode opcode
 	writeMsgCtx    context.Context
@@ -575,7 +575,7 @@ func (c *Conn) writer(ctx context.Context, typ MessageType) (io.WriteCloser, err
 	w := &messageWriter{
 		c: c,
 	}
-	c.activeWriter = w
+	c.activeWriter.Store(w)
 	return w, nil
 }
 
@@ -607,7 +607,7 @@ type messageWriter struct {
 }
 
 func (w *messageWriter) closed() bool {
-	return w != w.c.activeWriter
+	return w != w.c.activeWriter.Load()
 }
 
 // Write writes the given bytes to the WebSocket connection.
@@ -645,7 +645,7 @@ func (w *messageWriter) close() error {
 	if w.closed() {
 		return fmt.Errorf("cannot use closed writer")
 	}
-	w.c.activeWriter = nil
+	w.c.activeWriter.Store((*messageWriter)(nil))
 
 	_, err := w.c.writeFrame(w.c.writeMsgCtx, true, w.c.writeMsgOpcode, nil)
 	if err != nil {
@@ -925,7 +925,3 @@ func (c *Conn) extractBufioWriterBuf(w io.Writer) {
 
 	c.bw.Reset(w)
 }
-
-func (c *netConn) netConnReader(ctx context.Context) (MessageType, io.Reader, error) {
-	return c.c.Reader(c.readContext)
-}

doc.go

@@ -26,13 +26,20 @@
 // See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
 //
 // Thus the unsupported features (not compiled in) for WASM are:
+//
 //  - Accept and AcceptOptions
-//  - Conn's Reader, Writer, SetReadLimit and Ping methods
+//  - Conn.Ping
 //  - HTTPClient and HTTPHeader fields in DialOptions
 //
 // The *http.Response returned by Dial will always either be nil or &http.Response{} as
 // we do not have access to the handshake response in the browser.
 //
+// The Writer method on the Conn buffers everything in memory and then sends it as a message
+// when the writer is closed.
+//
+// The Reader method also reads the entire response and then returns a reader that
+// reads from the byte slice.
+//
 // Writes are also always async so the passed context is no-op.
 //
 // Everything else is fully supported. This includes the wsjson and wspb helper packages.

netconn.go

@@ -99,7 +99,7 @@ func (c *netConn) Read(p []byte) (int, error) {
 	}
 
 	if c.reader == nil {
-		typ, r, err := c.netConnReader(c.readContext)
+		typ, r, err := c.c.Reader(c.readContext)
 		if err != nil {
 			var ce CloseError
 			if errors.As(err, &ce) && (ce.Code == StatusNormalClosure) || (ce.Code == StatusGoingAway) {

websocket_js.go

@@ -13,6 +13,7 @@ import (
 	"sync/atomic"
 	"syscall/js"
 
+	"nhooyr.io/websocket/internal/bpool"
 	"nhooyr.io/websocket/internal/wsjs"
 )
 
@@ -106,6 +107,11 @@ func (c *Conn) read(ctx context.Context) (MessageType, []byte, error) {
 func (c *Conn) Write(ctx context.Context, typ MessageType, p []byte) error {
 	err := c.write(ctx, typ, p)
 	if err != nil {
+		// Have to ensure the WebSocket is closed after a write error
+		// to match the Go API. It can only error if the message type
+		// is unexpected or the passed bytes contain invalid UTF-8 for
+		// MessageText.
+		c.Close(StatusInternalError, "something went wrong")
 		return fmt.Errorf("failed to write: %w", err)
 	}
 	return nil
@@ -216,8 +222,10 @@ func dial(ctx context.Context, url string, opts *DialOptions) (*Conn, *http.Resp
 	return c, &http.Response{}, nil
 }
 
-func (c *netConn) netConnReader(ctx context.Context) (MessageType, io.Reader, error) {
-	typ, p, err := c.c.Read(ctx)
+// Reader attempts to read a message from the connection.
+// The maximum time spent waiting is bounded by the context.
+func (c *Conn) Reader(ctx context.Context) (MessageType, io.Reader, error) {
+	typ, p, err := c.Read(ctx)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -228,3 +236,50 @@ func (c *netConn) netConnReader(ctx context.Context) (MessageType, io.Reader, er
 func (c *Conn) reader(ctx context.Context) {
 	c.read(ctx)
 }
+
+// Writer returns a writer to write a WebSocket data message to the connection.
+// It buffers the entire message in memory and then sends it when the writer
+// is closed.
+func (c *Conn) Writer(ctx context.Context, typ MessageType) (io.WriteCloser, error) {
+	return writer{
+		c:   c,
+		ctx: ctx,
+		typ: typ,
+		b:   bpool.Get(),
+	}, nil
+}
+
+type writer struct {
+	closed bool
+
+	c   *Conn
+	ctx context.Context
+	typ MessageType
+
+	b *bytes.Buffer
+}
+
+func (w writer) Write(p []byte) (int, error) {
+	if w.closed {
+		return 0, errors.New("cannot write to closed writer")
+	}
+	n, err := w.b.Write(p)
+	if err != nil {
+		return n, fmt.Errorf("failed to write message: %w", err)
+	}
+	return n, nil
+}
+
+func (w writer) Close() error {
+	if w.closed {
+		return errors.New("cannot close closed writer")
+	}
+	w.closed = true
+	defer bpool.Put(w.b)
+
+	err := w.c.Write(w.ctx, w.typ, w.b.Bytes())
+	if err != nil {
+		return fmt.Errorf("failed to close writer: %w", err)
+	}
+	return nil
+}

wsjson/wsjson.go

@@ -1,5 +1,3 @@
-// +build !js
-
 // Package wsjson provides websocket helpers for JSON messages.
 package wsjson // import "nhooyr.io/websocket/wsjson"
 
@@ -34,9 +32,7 @@ func read(ctx context.Context, c *websocket.Conn, v interface{}) error {
 	}
 
 	b := bpool.Get()
-	defer func() {
-		bpool.Put(b)
-	}()
+	defer bpool.Put(b)
 
 	_, err = b.ReadFrom(r)
 	if err != nil {

wsjson/wsjson_js.go

@@ -1,5 +1,3 @@
-// +build !js
-
 // Package wspb provides websocket helpers for protobuf messages.
 package wspb // import "nhooyr.io/websocket/wspb"
 
@@ -36,9 +34,7 @@ func read(ctx context.Context, c *websocket.Conn, v proto.Message) error {
 	}
 
 	b := bpool.Get()
-	defer func() {
-		bpool.Put(b)
-	}()
+	defer bpool.Put(b)
 
 	_, err = b.ReadFrom(r)
 	if err != nil {