Why ws.outQueue is need to check if the Channel is closed?

[AndrewYEEE]

Sorry I dont understand why ws.outQueue is need to check that Channel is closed ? This will cause writePump closed but server.connections still retains the ws object (ws.connection still work).

And Why doesn't ws.pingMessage need to check if the Channel closed unexpectedly?

 func (server *Server) writePump(ws *WebSocket) {
    conn := ws.connection

    for {
        select {
        case data, ok := <-ws.outQueue:
            _ = conn.SetWriteDeadline(time.Now().Add(server.timeoutConfig.WriteWait))
            if !ok {
                // Unexpected closed queue, should never happen
                server.error(fmt.Errorf("output queue for socket %v was closed, forcefully closing", ws.id))
                // Don't invoke cleanup

                return      **//<===== will exit writePump(), but server.connections still retains the WS object  !!!**
            }
            // Send data
            err := conn.WriteMessage(websocket.TextMessage, data)
            if err != nil {
                server.error(fmt.Errorf("write failed for %s: %w", ws.ID(), err))
                // Invoking cleanup, as socket was forcefully closed
                server.cleanupConnection(ws)
                return
            }
            log.Debugf("written %d bytes to %s", len(data), ws.ID())
        case ping := <-ws.pingMessage:

                       **// why don't need check channel closed unexpectedly?**

            _ = conn.SetWriteDeadline(time.Now().Add(server.timeoutConfig.WriteWait))
            err := conn.WriteMessage(websocket.PongMessage, ping)
            if err != nil {
                server.error(fmt.Errorf("write failed for %s: %w", ws.ID(), err))
                // Invoking cleanup, as socket was forcefully closed
                server.cleanupConnection(ws)
                return
            }
            log.Debugf("pong sent to %s", ws.ID())
            ...

[AndrewYEEE]

I have the idea to remove ws object, but I couldn't prove whether the ws object obtained by server.connections[] is the same as the one to be removed.

func (server *Server) writePump(ws *WebSocket) {
   conn := ws.connection
   for {
    select {
          case data, ok := <-ws.outQueue:

                    if !ok {
                        // Unexpected closed queue, should never happen
                        server.error(fmt.Errorf("output queue for socket %v was closed, forcefully closing", ws.id))
                        // Don't invoke cleanup

                        //delete chargepoint ws
                        server.connMutex.Lock()
                        if _, ok := server.connections[ws.id]; ok {
                            delete(server.connections, ws.id)                   // is same?
                            log.Infof("closed connection to %s", ws.ID())
                            if server.disconnectedHandler != nil {
                                server.disconnectedHandler(ws) 
                            }
                            }
                        server.connMutex.Unlock()

                        return
                    }