Implement lazy response decompression with ResponseDecoder interface

This commit addresses vlsi's architectural feedback on PR apache#6389 by
implementing a ResponseDecoder interface pattern to decouple decompression
logic from SampleResult.

Key Changes:
- Created ResponseDecoder interface in core module for pluggable decoders
- Implemented PlainResponseDecoder for uncompressed responses
- Created ResponseDecoderFactory in HTTP module with support for:
  * gzip/x-gzip compression (with relax mode support)
  * deflate compression (with relax mode support)
  * Brotli compression
- Modified SampleResult to:
  * Store raw (possibly compressed) response data
  * Track content encoding via new responseContentEncoding field
  * Lazily decompress on getResponseData() using registered decoders
  * Cache decompressed data to avoid repeated decompression
  * Use a registry pattern to avoid circular dependencies
- Updated HTTPHC4Impl to:
  * Disable automatic decompression (removed RESPONSE_CONTENT_ENCODING interceptor)
  * Extract and store Content-Encoding header value
  * Store raw compressed response data
- Updated HTTPJavaImpl to:
  * Remove inline gzip decompression
  * Extract and store Content-Encoding header value
  * Store raw compressed response data

Benefits:
- Decoupled architecture as suggested by vlsi
- Memory efficiency: only decompress when data is actually accessed
- CPU efficiency: avoid unnecessary decompression for responses that aren't read
- Maintains backward compatibility
- Supports all existing compression formats (gzip, deflate, brotli)

The implementation uses a registry pattern where the HTTP module registers
its decoders with SampleResult, avoiding circular dependencies between
core and protocol modules.

Author: claude

src/core/src/main/java/org/apache/jmeter/samplers/PlainResponseDecoder.java

@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jmeter.samplers;
+
+/**
+ * Decoder for uncompressed response data.
+ * Simply returns the data as-is without any transformation.
+ *
+ * @since 6.0
+ */
+public class PlainResponseDecoder implements ResponseDecoder {
+
+    /** Singleton instance */
+    public static final PlainResponseDecoder INSTANCE = new PlainResponseDecoder();
+
+    private PlainResponseDecoder() {
+        // Singleton
+    }
+
+    @Override
+    public byte[] decode(byte[] compressedData) {
+        return compressedData;
+    }
+
+    @Override
+    public String getContentEncoding() {
+        return null;
+    }
+
+    @Override
+    public boolean isCompressed() {
+        return false;
+    }
+}

src/core/src/main/java/org/apache/jmeter/samplers/ResponseDecoder.java

@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jmeter.samplers;
+
+import java.io.IOException;
+
+/**
+ * Interface for decoding response data that may be compressed.
+ * This allows for lazy decompression of HTTP response bodies,
+ * improving memory and CPU efficiency by only decompressing when needed.
+ *
+ * @since 6.0
+ */
+public interface ResponseDecoder {
+
+    /**
+     * Decode (decompress if necessary) the provided response data.
+     *
+     * @param compressedData the raw response data, which may be compressed
+     * @return the decompressed response data
+     * @throws IOException if decompression fails
+     */
+    byte[] decode(byte[] compressedData) throws IOException;
+
+    /**
+     * Get the content encoding type handled by this decoder.
+     *
+     * @return the content encoding name (e.g., "gzip", "deflate", "br", or null for no encoding)
+     */
+    String getContentEncoding();
+
+    /**
+     * Check if this decoder actually performs decompression.
+     *
+     * @return true if the decoder decompresses data, false if it returns data as-is
+     */
+    default boolean isCompressed() {
+        return getContentEncoding() != null && !getContentEncoding().isEmpty();
+    }
+}

src/core/src/main/java/org/apache/jmeter/samplers/SampleResult.java

@@ -25,9 +25,12 @@
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 
 import org.apache.jmeter.assertions.AssertionResult;
 import org.apache.jmeter.gui.Searchable;
@@ -95,6 +98,13 @@ public class SampleResult implements Serializable, Cloneable, Searchable {
 
     private static final boolean DISABLE_SUBRESULTS_RENAMING = JMeterUtils.getPropDefault("subresults.disable_renaming", false);
 
+    /**
+     * Registry of response decoders by content-encoding type.
+     * Allows HTTP module to register decompression handlers without creating circular dependencies.
+     * @since 6.0
+     */
+    private static final Map<String, Function<byte[], byte[]>> RESPONSE_DECODERS = new ConcurrentHashMap<>();
+
     // List of types that are known to be binary
     private static final String[] BINARY_TYPES = {
         "image/",       //$NON-NLS-1$
@@ -276,6 +286,20 @@ public class SampleResult implements Serializable, Cloneable, Searchable {
      */
     private transient volatile String responseDataAsString;
 
+    /**
+     * The Content-Encoding header value from the response (e.g., "gzip", "deflate", "br").
+     * If null or empty, the response is not compressed.
+     * @since 6.0
+     */
+    private String responseContentEncoding;
+
+    /**
+     * Cache for decompressed response data to avoid repeated decompression.
+     * Only used when responseContentEncoding is not null/empty.
+     * @since 6.0
+     */
+    private transient volatile byte[] decompressedResponseData;
+
     public SampleResult() {
         this(USE_NANO_TIME, NANOTHREAD_SLEEP);
     }
@@ -322,6 +346,8 @@ public SampleResult(SampleResult res) {
         responseCode = res.responseCode;//OK
         responseData = res.responseData;//OK
         responseDataAsString = null;
+        responseContentEncoding = res.responseContentEncoding;//OK
+        decompressedResponseData = null;
         responseHeaders = res.responseHeaders;//OK
         responseMessage = res.responseMessage;//OK
 
@@ -736,6 +762,7 @@ public SampleResult[] getSubResults() {
      */
     public void setResponseData(byte[] response) {
         responseDataAsString = null;
+        decompressedResponseData = null;
         responseData = response == null ? EMPTY_BA : response;
     }
 
@@ -783,17 +810,92 @@ public void setResponseData(final String response, final String encoding) {
     /**
      * Gets the responseData attribute of the SampleResult object.
      * <p>
+     * If the response data is compressed (indicated by {@link #getResponseContentEncoding()}),
+     * this method will lazily decompress it using the registered decoder for that encoding.
+     * The decompressed result is cached to avoid repeated decompression.
+     * </p>
+     * <p>
      * Note that some samplers may not store all the data, in which case
      * getResponseData().length will be incorrect.
      *
      * Instead, always use {@link #getBytes()} to obtain the sample result byte count.
      * </p>
-     * @return the responseData value (cannot be null)
+     * @return the responseData value (cannot be null), decompressed if necessary
      */
     public byte[] getResponseData() {
+        // If no content encoding, return raw data
+        if (responseContentEncoding == null || responseContentEncoding.isEmpty()) {
+            return responseData;
+        }
+
+        // Check if we've already decompressed
+        if (decompressedResponseData != null) {
+            return decompressedResponseData;
+        }
+
+        // Attempt to decompress
+        String encoding = responseContentEncoding.toLowerCase(Locale.ENGLISH).trim();
+        Function<byte[], byte[]> decoder = RESPONSE_DECODERS.get(encoding);
+
+        if (decoder != null) {
+            try {
+                decompressedResponseData = decoder.apply(responseData);
+                return decompressedResponseData;
+            } catch (Exception e) {
+                log.warn("Failed to decompress response data with encoding '{}': {}",
+                        responseContentEncoding, e.getMessage(), e);
+                // Fall through to return raw data
+            }
+        } else {
+            log.warn("No decoder registered for content encoding: {}", responseContentEncoding);
+        }
+
+        // If decompression failed or no decoder available, return raw data
         return responseData;
     }
 
+    /**
+     * Register a decoder function for a specific content-encoding type.
+     * This allows the HTTP module to provide decompression capabilities without
+     * creating circular dependencies with the core module.
+     *
+     * @param contentEncoding the content-encoding name (e.g., "gzip", "deflate", "br")
+     * @param decoder the function that decompresses byte[] to byte[]
+     * @since 6.0
+     */
+    public static void registerResponseDecoder(String contentEncoding, Function<byte[], byte[]> decoder) {
+        if (contentEncoding != null && decoder != null) {
+            String key = contentEncoding.toLowerCase(Locale.ENGLISH).trim();
+            RESPONSE_DECODERS.put(key, decoder);
+            log.debug("Registered response decoder for content-encoding: {}", contentEncoding);
+        }
+    }
+
+    /**
+     * Get the response content encoding (e.g., "gzip", "deflate", "br").
+     * When set, indicates that the response data stored via {@link #setResponseData(byte[])}
+     * is in compressed format and will be lazily decompressed when {@link #getResponseData()} is called.
+     *
+     * @return the content encoding, or null if the response is not compressed
+     * @since 6.0
+     */
+    public String getResponseContentEncoding() {
+        return responseContentEncoding;
+    }
+
+    /**
+     * Set the response content encoding (e.g., "gzip", "deflate", "br").
+     * This should be set when storing compressed response data to enable lazy decompression.
+     * Clear the decompressed data cache when changing the encoding.
+     *
+     * @param contentEncoding the content encoding value from the Content-Encoding header
+     * @since 6.0
+     */
+    public void setResponseContentEncoding(String contentEncoding) {
+        this.responseContentEncoding = contentEncoding;
+        this.decompressedResponseData = null;
+    }
+
     /**
      * Gets the responseData of the SampleResult object as a String
      *
@@ -1598,6 +1700,7 @@ public void setStartNextThreadLoop(boolean startNextThreadLoop) {
      */
     public void cleanAfterSample() {
         this.responseDataAsString = null;
+        this.decompressedResponseData = null;
     }
 
     @Override

src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/sampler/HTTPHC4Impl.java

@@ -673,8 +673,16 @@ protected HTTPSampleResult sample(URL url, String method,
                 res.setContentType(ct);
                 res.setEncodingAndType(ct);
             }
+
+            // Extract Content-Encoding for lazy decompression
+            Header contentEncoding = httpResponse.getLastHeader(HTTPConstants.HEADER_CONTENT_ENCODING);
+            if (contentEncoding != null) {
+                res.setResponseContentEncoding(contentEncoding.getValue());
+            }
+
             HttpEntity entity = httpResponse.getEntity();
             if (entity != null) {
+                // Read raw (possibly compressed) data for lazy decompression
                 res.setResponseData(readResponse(res, entity.getContent(), entity.getContentLength()));
             }
 
@@ -1157,7 +1165,8 @@ private MutableTriple<CloseableHttpClient, AuthState, PoolingHttpClientConnectio
                 }
                 builder.setDefaultCredentialsProvider(credsProvider);
             }
-            builder.disableContentCompression().addInterceptorLast(RESPONSE_CONTENT_ENCODING);
+            // Disable content compression to store raw compressed data for lazy decompression
+            builder.disableContentCompression();
             if(BASIC_AUTH_PREEMPTIVE) {
                 builder.addInterceptorFirst(PREEMPTIVE_AUTH_INTERCEPTOR);
             } else {

src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/sampler/HTTPJavaImpl.java

@@ -31,7 +31,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.Predicate;
-import java.util.zip.GZIPInputStream;
 
 import org.apache.commons.io.input.CountingInputStream;
 import org.apache.jmeter.protocol.http.control.AuthManager;
@@ -239,16 +238,17 @@ protected byte[] readResponse(HttpURLConnection conn, SampleResult res) throws I
             return NULL_BA;
         }
 
-        // works OK even if ContentEncoding is null
-        boolean gzipped = HTTPConstants.ENCODING_GZIP.equals(conn.getContentEncoding());
+        // Store content encoding for lazy decompression
+        String contentEncoding = conn.getContentEncoding();
+        if (contentEncoding != null && !contentEncoding.isEmpty()) {
+            res.setResponseContentEncoding(contentEncoding);
+        }
+
         CountingInputStream instream = null;
         try {
+            // Read raw (possibly compressed) data for lazy decompression
             instream = new CountingInputStream(conn.getInputStream());
-            if (gzipped) {
-                in = new GZIPInputStream(instream);
-            } else {
-                in = instream;
-            }
+            in = instream;
         } catch (IOException e) {
             if (! (e.getCause() instanceof FileNotFoundException))
             {
@@ -276,11 +276,8 @@ protected byte[] readResponse(HttpURLConnection conn, SampleResult res) throws I
                 log.info("Error Response Code: {}", conn.getResponseCode());
             }
 
-            if (gzipped) {
-                in = new GZIPInputStream(errorStream);
-            } else {
-                in = errorStream;
-            }
+            // Read raw error stream for lazy decompression
+            in = errorStream;
         } catch (Exception e) {
             log.error("readResponse: {}", e.toString());
             Throwable cause = e.getCause();