Http3FrameCodec Class — netty Architecture

Source Code

codec-http3/src/main/java/io/netty/handler/codec/http3/Http3FrameCodec.java lines 58–822

final class Http3FrameCodec extends ByteToMessageDecoder implements ChannelOutboundHandler {
    private final Http3FrameTypeValidator validator;
    private final long maxHeaderListSize;
    private final QpackDecoder qpackDecoder;
    private final QpackEncoder qpackEncoder;
    private final Http3RequestStreamCodecState encodeState;
    private final Http3RequestStreamCodecState decodeState;
    private final Http3Settings.NonStandardHttp3SettingsValidator nonStandardSettingsValidator;
    private boolean firstFrame = true;
    private boolean error;
    private long type = -1;
    private int payLoadLength = -1;
    private QpackAttributes qpackAttributes;
    private ReadResumptionListener readResumptionListener;
    private WriteResumptionListener writeResumptionListener;

    static Http3FrameCodecFactory newFactory(QpackDecoder qpackDecoder,
                                             long maxHeaderListSize, QpackEncoder qpackEncoder) {
        checkNotNull(qpackEncoder, "qpackEncoder");
        checkNotNull(qpackDecoder, "qpackDecoder");

        // QPACK decoder and encoder are shared between streams in a connection.
        return (validator, encodeState, decodeState,
                nonStandardSettingsValidator) -> new Http3FrameCodec(validator, qpackDecoder,
                maxHeaderListSize, qpackEncoder, encodeState, decodeState, nonStandardSettingsValidator);
    }

    Http3FrameCodec(Http3FrameTypeValidator validator, QpackDecoder qpackDecoder,
                    long maxHeaderListSize, QpackEncoder qpackEncoder, Http3RequestStreamCodecState encodeState,
                    Http3RequestStreamCodecState decodeState,
                    Http3Settings.NonStandardHttp3SettingsValidator nonStandardSettingsValidator) {
        this.validator = checkNotNull(validator, "validator");
        this.qpackDecoder = checkNotNull(qpackDecoder, "qpackDecoder");
        this.maxHeaderListSize = checkPositive(maxHeaderListSize, "maxHeaderListSize");
        this.qpackEncoder = checkNotNull(qpackEncoder, "qpackEncoder");
        this.encodeState = checkNotNull(encodeState, "encodeState");
        this.decodeState = checkNotNull(decodeState, "decodeState");
        this.nonStandardSettingsValidator = nonStandardSettingsValidator;
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        qpackAttributes = Http3.getQpackAttributes(ctx.channel().parent());
        assert qpackAttributes != null;

        initReadResumptionListenerIfRequired(ctx);
        super.handlerAdded(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        if (writeResumptionListener != null) {
            writeResumptionListener.drain();
        }
        super.channelInactive(ctx);
    }

    @Override
    protected void handlerRemoved0(ChannelHandlerContext ctx) throws Exception {
        if (writeResumptionListener != null) {
            // drain everything so we are sure we never leak anything.
            writeResumptionListener.drain();
        }
        super.handlerRemoved0(ctx);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buffer;
        if (msg instanceof QuicStreamFrame) {
            QuicStreamFrame streamFrame = (QuicStreamFrame) msg;
            buffer = streamFrame.content().retain();
            streamFrame.release();
        } else {
            buffer = (ByteBuf) msg;
        }
        super.channelRead(ctx, buffer);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {