Class WsFrameClient

java/org/apache/tomcat/websocket/WsFrameClient.java:34–238

WebSocket frame handler for client connections.

 * WebSocket frame handler for client connections.
 */
public class WsFrameClient extends WsFrameBase {

    private final Log log = LogFactory.getLog(WsFrameClient.class); // must not be static
    private static final StringManager sm = StringManager.getManager(WsFrameClient.class);

    private final AsyncChannelWrapper channel;
    private final CompletionHandler<Integer,Void> handler;
    // Not final as it may need to be re-sized
    private volatile ByteBuffer response;

    /**
     * Constructs a new WsFrameClient.
     *
     * @param response         The response buffer
     * @param channel          The async channel wrapper
     * @param wsSession        The WebSocket session
     * @param transformation   The transformation to apply
     */
    public WsFrameClient(ByteBuffer response, AsyncChannelWrapper channel, WsSession wsSession,
            Transformation transformation) {
        super(wsSession, transformation);
        this.response = response;
        this.channel = channel;
        this.handler = new WsFrameClientCompletionHandler();
    }


    void startInputProcessing() {
        try {
            processSocketRead();
        } catch (IOException ioe) {
            close(ioe);
        }
    }


    private void processSocketRead() throws IOException {
        while (true) {
            switch (getReadState()) {
                case WAITING:
                    if (!changeReadState(ReadState.WAITING, ReadState.PROCESSING)) {
                        continue;
                    }
                    while (response.hasRemaining()) {
                        if (isSuspended()) {
                            if (!changeReadState(ReadState.SUSPENDING_PROCESS, ReadState.SUSPENDED)) {
                                continue;
                            }
                            // There is still data available in the response buffer
                            // Return here so that the response buffer will not be
                            // cleared and there will be no data read from the
                            // socket. Thus, when the read operation is resumed first
                            // the data left in the response buffer will be consumed
                            // and then a new socket read will be performed
                            return;
                        }
                        inputBuffer.mark();
                        inputBuffer.position(inputBuffer.limit()).limit(inputBuffer.capacity());