Http2Decompressor Class — netty Architecture

Source Code

codec-http2/src/main/java/io/netty/handler/codec/http2/DelegatingDecompressorFrameListener.java lines 365–493

    private static final class Http2Decompressor {
        private final EmbeddedChannel decompressor;

        private int compressed;
        private int decompressed;
        private Http2Stream stream;
        private int padding;
        private boolean dataDecompressed;
        private ChannelHandlerContext targetCtx;

        Http2Decompressor(EmbeddedChannel decompressor,  Http2Connection connection, Http2FrameListener listener) {
            this.decompressor = decompressor;
            this.decompressor.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                @Override
                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                    ByteBuf buf = (ByteBuf) msg;
                    if (!buf.isReadable()) {
                        buf.release();
                        return;
                    }
                    incrementDecompressedBytes(buf.readableBytes());
                    // Immediately return the bytes back to the flow controller. ConsumedBytesConverter will convert
                    // from the decompressed amount which the user knows about to the compressed amount which flow
                    // control knows about.
                    connection.local().flowController().consumeBytes(stream,
                            listener.onDataRead(targetCtx, stream.id(), buf, padding, false));
                    padding = 0; // Padding is only communicated once on the first iteration.
                    buf.release();

                    dataDecompressed = true;
                }

                @Override
                public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                    listener.onDataRead(targetCtx, stream.id(), Unpooled.EMPTY_BUFFER, padding, true);
                }
            });
        }

        /**
         * Release remaining content from the {@link EmbeddedChannel}.
         */
        void cleanup() {
            decompressor.finishAndReleaseAll();
        }

        int decompress(ChannelHandlerContext ctx, Http2Stream stream, ByteBuf data, int padding, boolean endOfStream)
                throws Http2Exception {
            final int compressedBytes = data.readableBytes() + padding;
            incrementCompressedBytes(compressedBytes);
            try {
                this.stream = stream;
                this.padding = padding;
                this.dataDecompressed = false;
                this.targetCtx = ctx;

                // call retain here as it will call release after its written to the channel
                decompressor.writeInbound(data.retain());
                if (endOfStream) {
                    decompressor.finish();

                    if (!dataDecompressed) {
                        // No new decompressed data was extracted from the compressed data. This means the application
                        // could not be provided with data and thus could not return how many bytes were processed.
                        // We will assume there is more data coming which will complete the decompression block.
                        // To allow for more data we return all bytes to the flow control window (so the peer can
                        // send more data).
                        incrementDecompressedBytes(compressedBytes);
                        return compressedBytes;
                    }
                }
                // We consume bytes each time we call the listener to ensure if multiple frames are decompressed
                // that the bytes are accounted for immediately. Otherwise the user may see an inconsistent state of
                // flow control.
                return 0;
            } catch (Throwable t) {
                // Http2Exception might be thrown by writeInbound(...) or finish().
                if (t instanceof Http2Exception) {
                    throw (Http2Exception) t;
                }
                throw streamError(stream.id(), INTERNAL_ERROR, t,