refactor: Make SendMediaUploadRequest a builder, allowing to create a media upload request with a more flexible API

Author: jmartinesp

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

@@ -156,17 +156,43 @@ where
     }
 }
 
-/// `IntoFuture` used to send media upload requests. It wraps another
-/// [`SendRequest`], checking its size will be accepted by the homeserver before
-/// uploading.
+/// `IntoFuture` used to send media upload requests. It works as a builder which
+/// can create a [`SendRequest`] given several configuration options, checking
+/// its size will be accepted by the homeserver before uploading.
 #[allow(missing_debug_implementations)]
 pub struct SendMediaUploadRequest {
-    send_request: SendRequest<media::create_content::v3::Request>,
+    client: Client,
+    request: media::create_content::v3::Request,
+    request_config: Option<RequestConfig>,
+    progress_observable: SharedObservable<TransmissionProgress>,
 }
-
 impl SendMediaUploadRequest {
-    pub fn new(request: SendRequest<media::create_content::v3::Request>) -> Self {
-        Self { send_request: request }
+    /// Creates a new instance.
+    pub fn new(client: Client, file: Vec<u8>) -> Self {
+        Self {
+            client,
+            request: media::create_content::v3::Request::new(file),
+            request_config: Default::default(),
+            progress_observable: SharedObservable::new(TransmissionProgress::default()),
+        }
+    }
+
+    /// Sets the content type of the media for the media upload request.
+    pub fn with_content_type(mut self, content_type: impl Into<String>) -> Self {
+        self.request.content_type = Some(content_type.into());
+        self
+    }
+
+    /// Sets the filename for the media upload request.
+    pub fn with_filename(mut self, filename: impl Into<String>) -> Self {
+        self.request.filename = Some(filename.into());
+        self
+    }
+
+    /// Applies the provided [`RequestConfig`] to the future [`SendRequest`].
+    pub fn with_request_config(mut self, request_config: Option<RequestConfig>) -> Self {
+        self.request_config = request_config;
+        self
     }
 
     /// Replace the default `SharedObservable` used for tracking upload
@@ -179,14 +205,24 @@ impl SendMediaUploadRequest {
         mut self,
         send_progress: SharedObservable<TransmissionProgress>,
     ) -> Self {
-        self.send_request = self.send_request.with_send_progress_observable(send_progress);
+        self.progress_observable = send_progress;
         self
     }
 
     /// Get a subscriber to observe the progress of sending the request
     /// body.
     pub fn subscribe_to_send_progress(&self) -> Subscriber<TransmissionProgress> {
-        self.send_request.send_progress.subscribe()
+        self.progress_observable.subscribe()
+    }
+
+    /// Creates the [`SendRequest`] using the provided parameters.
+    pub fn build_send_request(self) -> SendRequest<media::create_content::v3::Request> {
+        SendRequest {
+            client: self.client,
+            request: self.request,
+            config: self.request_config,
+            send_progress: self.progress_observable,
+        }
     }
 }
 
@@ -195,9 +231,9 @@ impl IntoFuture for SendMediaUploadRequest {
     boxed_into_future!();
 
     fn into_future(self) -> Self::IntoFuture {
-        let request_length = self.send_request.request.file.len();
-        let client = self.send_request.client.clone();
-        let send_request = self.send_request;
+        let send_request = self.build_send_request();
+        let request_length = send_request.request.file.len();
+        let client = send_request.client.clone();
 
         Box::pin(async move {
             let max_upload_size = client.load_or_fetch_max_upload_size().await?;

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

@@ -2909,7 +2909,6 @@ pub(crate) mod tests {
 
     use assert_matches::assert_matches;
     use assert_matches2::assert_let;
-    use eyeball::SharedObservable;
     use futures_util::{pin_mut, FutureExt};
     use js_int::{uint, UInt};
     use matrix_sdk_base::{
@@ -2950,10 +2949,9 @@ pub(crate) mod tests {
     use crate::{
         client::{futures::SendMediaUploadRequest, WeakClient},
         config::RequestConfig,
-        futures::SendRequest,
         media::MediaError,
         test_utils::{client::MockClientBuilder, mocks::MatrixMockServer},
-        Error, TransmissionProgress,
+        Error,
     };
 
     #[async_test]
@@ -3781,15 +3779,7 @@ pub(crate) mod tests {
         assert_eq!(*client.inner.server_max_upload_size.lock().await.get().unwrap(), uint!(1));
 
         let data = vec![1, 2];
-        let upload_request =
-            ruma::api::client::media::create_content::v3::Request::new(data.clone());
-        let request = SendRequest {
-            client: client.clone(),
-            request: upload_request,
-            config: None,
-            send_progress: SharedObservable::new(TransmissionProgress::default()),
-        };
-        let media_request = SendMediaUploadRequest::new(request);
+        let media_request = SendMediaUploadRequest::new(client, data.clone());
 
         let error = media_request.await.err();
         assert_let!(Some(Error::Media(MediaError::MediaTooLargeToUpload { max, current })) = error);

crates/matrix-sdk/src/media.rs

@@ -209,13 +209,15 @@ impl Media {
             self.client.request_config().timeout(Self::reasonable_upload_timeout(&data))
         });
 
-        let request = assign!(media::create_content::v3::Request::new(data), {
-            filename,
-            content_type: Some(content_type.essence_str().to_owned()),
-        });
+        let send_media_request = SendMediaUploadRequest::new(self.client.clone(), data)
+            .with_content_type(content_type.essence_str().to_owned())
+            .with_request_config(Some(request_config));
 
-        let request = self.client.send(request).with_request_config(request_config);
-        SendMediaUploadRequest::new(request)
+        if let Some(filename) = filename {
+            send_media_request.with_filename(filename)
+        } else {
+            send_media_request
+        }
     }
 
     /// Returns a reasonable upload timeout for an upload, based on the size of

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

@@ -142,7 +142,7 @@ use as_variant::as_variant;
 use matrix_sdk_base::store::FinishGalleryItemInfo;
 use matrix_sdk_base::{
     event_cache::store::EventCacheStoreError,
-    media::MediaRequestParameters,
+    media::{MediaEventContent, MediaRequestParameters},
     store::{
         ChildTransactionId, DependentQueuedRequest, DependentQueuedRequestKind, DynStateStore,
         FinishUploadThumbnailInfo, QueueWedgeError, QueuedRequest, QueuedRequestKind,
@@ -169,7 +169,7 @@ use ruma::{
 };
 use tokio::sync::{broadcast, oneshot, Mutex, Notify, OwnedMutexGuard};
 use tracing::{debug, error, info, instrument, trace, warn};
-use matrix_sdk_base::media::MediaEventContent;
+
 #[cfg(feature = "e2e-encryption")]
 use crate::crypto::{OlmError, SessionRecipientCollectionError};
 use crate::{