Method take_bytes

modules/llrt_fetch/src/response.rs:868–958

(&self, ctx: &Ctx<'js>)

    #[allow(clippy::await_holding_lock)]
    #[allow(clippy::readonly_write_lock)]
    async fn take_bytes(&self, ctx: &Ctx<'js>) -> Result<Option<Vec<u8>>> {
        // Fast path: if no stream was ever created, skip all stream checks
        // and take the incoming body directly without cloning Arc/String.
        let body_stream_exists = self.body_stream.read().unwrap().is_some();

        if !body_stream_exists {
            let mut body_guard = self.body.write().unwrap();
            match &mut *body_guard {
                BodyVariant::Incoming(incoming, enc) => {
                    let body = incoming
                        .write()
                        .unwrap()
                        .take()
                        .ok_or(Exception::throw_type(ctx, "Body is already read"))?;
                    let encoding = enc.take();
                    drop(body_guard);

                    let has_decoder = encoding
                        .as_deref()
                        .is_some_and(|e| !matches!(e, "" | "identity"));

                    if !has_decoder {
                        let collected = body
                            .collect()
                            .await
                            .map_err(|e| Exception::throw_message(ctx, &e.to_string()))?;
                        return Ok(Some(collected.to_bytes().into()));
                    }

                    let collected = body
                        .collect()
                        .await
                        .map_err(|e| Exception::throw_message(ctx, &e.to_string()))?;
                    let raw = collected.to_bytes();
                    if let Some(mut dec) = encoding
                        .as_deref()
                        .and_then(|enc| StreamingDecoder::new(enc).ok())
                    {
                        let mut decompressed = dec
                            .decompress_chunk(&raw)
                            .map_err(|e| Exception::throw_message(ctx, &e.to_string()))?;
                        let remaining = dec
                            .finish()
                            .map_err(|e| Exception::throw_message(ctx, &e.to_string()))?;
                        if !remaining.is_empty() {
                            decompressed.extend_from_slice(&remaining);
                        }
                        return Ok(Some(decompressed));
                    }
                    return Ok(Some(raw.into()));
                },
                BodyVariant::Empty => return Ok(None),
                BodyVariant::Provided(None) => {
                    return Err(Exception::throw_type(ctx, "Body is already read"))
                },
                BodyVariant::Provided(Some(_)) => {
                    // Fall through to take_provided
                    drop(body_guard);