perf(decoder): avoid unnecessary clone of decompression service (#828)

Author: 0x676e67

src/client/layer/decoder/layer.rs

@@ -3,9 +3,7 @@ use std::task::{Context, Poll};
 use http::{Request, Response};
 use http_body::Body;
 use tower::{Layer, Service};
-use tower_http::decompression::{
-    Decompression as TowerDecompression, DecompressionBody, ResponseFuture,
-};
+use tower_http::decompression::{self, DecompressionBody, ResponseFuture};
 
 use super::AcceptEncoding;
 use crate::{client::layer::config::RequestAcceptEncoding, core::ext::RequestConfig};
@@ -20,7 +18,7 @@ pub struct DecompressionLayer {
 }
 
 impl DecompressionLayer {
-    /// Creates a new `DecompressionLayer` with the specified `Accepts`.
+    /// Creates a new `DecompressionLayer` with the specified `AcceptEncoding`.
     pub const fn new(accept: AcceptEncoding) -> Self {
         Self { accept }
     }
@@ -30,9 +28,11 @@ impl<S> Layer<S> for DecompressionLayer {
     type Service = Decompression<S>;
 
     fn layer(&self, service: S) -> Self::Service {
-        let decoder = TowerDecompression::new(service);
-        let decoder = Decompression::<S>::accept(decoder, &self.accept);
-        Decompression { decoder }
+        let decoder = decompression::Decompression::new(service);
+        let decoder = Decompression::<S>::accept_in_place(decoder, &self.accept);
+        Decompression {
+            decoder: Some(decoder),
+        }
     }
 }
 
@@ -42,14 +42,15 @@ impl<S> Layer<S> for DecompressionLayer {
 /// bodies based on the `Content-Encoding` header.
 #[derive(Clone)]
 pub struct Decompression<S> {
-    decoder: TowerDecompression<S>,
+    decoder: Option<decompression::Decompression<S>>,
 }
 
 impl<S> Decompression<S> {
-    fn accept(
-        mut decoder: TowerDecompression<S>,
+    // replaces the current decoder with a new one based on the `AcceptEncoding`.
+    fn accept_in_place(
+        mut decoder: decompression::Decompression<S>,
         accept: &AcceptEncoding,
-    ) -> TowerDecompression<S> {
+    ) -> decompression::Decompression<S> {
         #[cfg(feature = "gzip")]
         {
             decoder = decoder.gzip(accept.gzip);
@@ -86,16 +87,33 @@ where
 
     #[inline(always)]
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.decoder.poll_ready(cx)
+        match self.decoder.as_mut() {
+            Some(decoder) => decoder.poll_ready(cx),
+            None => unreachable!("Decompression service is not initialized"),
+        }
     }
 
     fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
+        // If the accept encoding is set, we need to update the decoder
+        // to handle the specified encodings.
         if let Some(accept) = RequestConfig::<RequestAcceptEncoding>::get(req.extensions()) {
-            let mut decoder = self.decoder.clone();
-            decoder = Decompression::accept(decoder, accept);
-            std::mem::swap(&mut self.decoder, &mut decoder);
+            if let Some(mut decoder) = self.decoder.take() {
+                decoder = Decompression::accept_in_place(decoder, accept);
+                self.decoder = Some(decoder);
+            }
         }
 
-        self.decoder.call(req)
+        // Call the underlying service with the request
+        match self.decoder.as_mut() {
+            Some(decoder) => decoder.call(req),
+            None => {
+                // This branch should never be reached: decoder is always initialized in
+                // DecompressionLayer::layer(). If this panic occurs, it indicates a
+                // bug in the service setup or unexpected internal state.
+                unreachable!(
+                    "Decompression service was not initialized; this indicates a bug in service setup"
+                );
+            }
+        }
     }
 }

src/client/layer/decoder/mod.rs

@@ -4,37 +4,49 @@ mod layer;
 
 pub use layer::{Decompression, DecompressionLayer};
 
+/// Configuration for supported content-encoding algorithms.
+///
+/// `AcceptEncoding` controls which compression formats are enabled for decoding
+/// response bodies. Each field corresponds to a specific algorithm and is only
+/// available if the corresponding feature is enabled.
 #[derive(Clone, Debug)]
 pub(crate) struct AcceptEncoding {
     #[cfg(feature = "gzip")]
-    pub(super) gzip: bool,
+    gzip: bool,
+
     #[cfg(feature = "brotli")]
-    pub(super) brotli: bool,
+    brotli: bool,
+
     #[cfg(feature = "zstd")]
-    pub(super) zstd: bool,
+    zstd: bool,
+
     #[cfg(feature = "deflate")]
-    pub(super) deflate: bool,
+    deflate: bool,
 }
 
 impl AcceptEncoding {
+    /// Enable or disable gzip decoding.
     #[inline(always)]
     #[cfg(feature = "gzip")]
     pub fn gzip(&mut self, enabled: bool) {
         self.gzip = enabled;
     }
 
+    /// Enable or disable brotli decoding.
     #[inline(always)]
     #[cfg(feature = "brotli")]
     pub fn brotli(&mut self, enabled: bool) {
         self.brotli = enabled;
     }
 
+    /// Enable or disable zstd decoding.
     #[inline(always)]
     #[cfg(feature = "zstd")]
     pub fn zstd(&mut self, enabled: bool) {
         self.zstd = enabled;
     }
 
+    /// Enable or disable deflate decoding.
     #[inline(always)]
     #[cfg(feature = "deflate")]
     pub fn deflate(&mut self, enabled: bool) {