remote_server: Remove dependency on libssl and libcrypto (#15446)

Fixes: #15599
Release Notes:

- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
Co-authored-by: Conrad <conrad@zed.dev>

crates/http_client/src/async_body.rs

@@ -0,0 +1,109 @@
+use std::{borrow::Cow, io::Read, pin::Pin, task::Poll};
+
+use futures::{AsyncRead, AsyncReadExt};
+
+/// Based on the implementation of AsyncBody in
+/// https://github.com/sagebind/isahc/blob/5c533f1ef4d6bdf1fd291b5103c22110f41d0bf0/src/body/mod.rs
+pub struct AsyncBody(pub Inner);
+
+pub enum Inner {
+    /// An empty body.
+    Empty,
+
+    /// A body stored in memory.
+    SyncReader(std::io::Cursor<Cow<'static, [u8]>>),
+
+    /// An asynchronous reader.
+    AsyncReader(Pin<Box<dyn futures::AsyncRead + Send + Sync>>),
+}
+
+impl AsyncBody {
+    /// Create a new empty body.
+    ///
+    /// An empty body represents the *absence* of a body, which is semantically
+    /// different than the presence of a body of zero length.
+    pub fn empty() -> Self {
+        Self(Inner::Empty)
+    }
+    /// Create a streaming body that reads from the given reader.
+    pub fn from_reader<R>(read: R) -> Self
+    where
+        R: AsyncRead + Send + Sync + 'static,
+    {
+        Self(Inner::AsyncReader(Box::pin(read)))
+    }
+}
+
+impl Default for AsyncBody {
+    fn default() -> Self {
+        Self(Inner::Empty)
+    }
+}
+
+impl From<()> for AsyncBody {
+    fn from(_: ()) -> Self {
+        Self(Inner::Empty)
+    }
+}
+
+impl From<Vec<u8>> for AsyncBody {
+    fn from(body: Vec<u8>) -> Self {
+        Self(Inner::SyncReader(std::io::Cursor::new(Cow::Owned(body))))
+    }
+}
+
+impl From<&'_ [u8]> for AsyncBody {
+    fn from(body: &[u8]) -> Self {
+        body.to_vec().into()
+    }
+}
+
+impl From<String> for AsyncBody {
+    fn from(body: String) -> Self {
+        body.into_bytes().into()
+    }
+}
+
+impl From<&'_ str> for AsyncBody {
+    fn from(body: &str) -> Self {
+        body.as_bytes().into()
+    }
+}
+
+impl<T: Into<Self>> From<Option<T>> for AsyncBody {
+    fn from(body: Option<T>) -> Self {
+        match body {
+            Some(body) => body.into(),
+            None => Self(Inner::Empty),
+        }
+    }
+}
+
+impl std::io::Read for AsyncBody {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        match &mut self.0 {
+            Inner::Empty => Ok(0),
+            Inner::SyncReader(cursor) => cursor.read(buf),
+            Inner::AsyncReader(async_reader) => smol::block_on(async_reader.read(buf)),
+        }
+    }
+}
+
+impl futures::AsyncRead for AsyncBody {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut [u8],
+    ) -> std::task::Poll<std::io::Result<usize>> {
+        // SAFETY: Standard Enum pin projection
+        let inner = unsafe { &mut self.get_unchecked_mut().0 };
+        match inner {
+            Inner::Empty => Poll::Ready(Ok(0)),
+            // Blocking call is over an in-memory buffer
+            Inner::SyncReader(cursor) => Poll::Ready(cursor.read(buf)),
+            Inner::AsyncReader(async_reader) => {
+                AsyncRead::poll_read(async_reader.as_mut(), cx, buf)
+            }
+        }
+    }
+}