cleanup: move homeserver overriding to the SendRequest struct

Author: bnjbvr

crates/matrix-sdk/src/client/futures.rs

@@ -47,7 +47,7 @@ use crate::{
 #[allow(missing_debug_implementations)]
 pub struct SendRequest<R> {
     pub(crate) client: Client,
-    pub(crate) sliding_sync_proxy_url: Option<String>,
+    pub(crate) homeserver_override: Option<String>,
     pub(crate) request: R,
     pub(crate) config: Option<RequestConfig>,
     pub(crate) send_progress: SharedObservable<TransmissionProgress>,
@@ -69,6 +69,16 @@ impl<R> SendRequest<R> {
         self
     }
 
+    /// Replace this request's target (homeserver) with a custom one.
+    ///
+    /// This is useful at the moment because the current sliding sync
+    /// implementation uses a proxy server.
+    #[cfg(feature = "experimental-sliding-sync")]
+    pub fn with_homeserver_override(mut self, homeserver_override: Option<String>) -> Self {
+        self.homeserver_override = homeserver_override;
+        self
+    }
+
     /// Get a subscriber to observe the progress of sending the request
     /// body.
     #[cfg(not(target_arch = "wasm32"))]
@@ -87,13 +97,13 @@ where
     boxed_into_future!();
 
     fn into_future(self) -> Self::IntoFuture {
-        let Self { client, request, config, send_progress, sliding_sync_proxy_url } = self;
+        let Self { client, request, config, send_progress, homeserver_override } = self;
 
         Box::pin(async move {
             let res = Box::pin(client.send_inner(
                 request.clone(),
                 config,
-                sliding_sync_proxy_url.clone(),
+                homeserver_override.clone(),
                 send_progress.clone(),
             ))
             .await;
@@ -161,7 +171,7 @@ where
                     return Box::pin(client.send_inner(
                         request,
                         config,
-                        sliding_sync_proxy_url,
+                        homeserver_override,
                         send_progress,
                     ))
                     .await;

crates/matrix-sdk/src/client/mod.rs

@@ -1306,44 +1306,22 @@ impl Client {
             request,
             config,
             send_progress: Default::default(),
-            sliding_sync_proxy_url: None,
-        }
-    }
-
-    #[cfg(feature = "experimental-sliding-sync")]
-    // FIXME: remove this as soon as Sliding-Sync isn't needing an external server
-    // anymore
-    pub(crate) fn send_with_homeserver<Request>(
-        &self,
-        request: Request,
-        config: Option<RequestConfig>,
-        sliding_sync_proxy: Option<String>,
-    ) -> SendRequest<Request>
-    where
-        Request: OutgoingRequest + Clone + Debug,
-        HttpError: From<FromHttpResponseError<Request::EndpointError>>,
-    {
-        SendRequest {
-            client: self.clone(),
-            request,
-            config,
-            send_progress: Default::default(),
-            sliding_sync_proxy_url: sliding_sync_proxy,
+            homeserver_override: None,
         }
     }
 
     pub(crate) async fn send_inner<Request>(
         &self,
         request: Request,
         config: Option<RequestConfig>,
-        homeserver: Option<String>,
+        homeserver_override: Option<String>,
         send_progress: SharedObservable<TransmissionProgress>,
     ) -> HttpResult<Request::IncomingResponse>
     where
         Request: OutgoingRequest + Debug,
         HttpError: From<FromHttpResponseError<Request::EndpointError>>,
     {
-        let homeserver = match homeserver {
+        let homeserver = match homeserver_override {
             Some(hs) => hs,
             None => self.homeserver().to_string(),
         };

crates/matrix-sdk/src/sliding_sync/mod.rs

@@ -573,11 +573,10 @@ impl SlidingSync {
         debug!("Sending request");
 
         // Prepare the request.
-        let request = self.inner.client.send_with_homeserver(
-            request,
-            Some(request_config),
-            self.inner.sliding_sync_proxy.as_ref().map(ToString::to_string),
-        );
+        let request =
+            self.inner.client.send(request, Some(request_config)).with_homeserver_override(
+                self.inner.sliding_sync_proxy.as_ref().map(ToString::to_string),
+            );
 
         // Send the request and get a response with end-to-end encryption support.
         //