refactor(sdk): Use Ruma support for (un)stable feature flags for authenticated media

Signed-off-by: Kévin Commaille <[email protected]>

Author: zecakeh

crates/matrix-sdk/src/config/request.rs

@@ -19,7 +19,6 @@ use std::{
 };
 
 use matrix_sdk_common::debug::DebugStructExt;
-use ruma::api::MatrixVersion;
 
 use crate::http_client::DEFAULT_REQUEST_TIMEOUT;
 
@@ -49,7 +48,6 @@ pub struct RequestConfig {
     pub(crate) max_retry_time: Option<Duration>,
     pub(crate) max_concurrent_requests: Option<NonZeroUsize>,
     pub(crate) force_auth: bool,
-    pub(crate) force_matrix_version: Option<MatrixVersion>,
 }
 
 #[cfg(not(tarpaulin_include))]
@@ -62,16 +60,14 @@ impl Debug for RequestConfig {
             max_retry_time: retry_timeout,
             force_auth,
             max_concurrent_requests,
-            force_matrix_version,
         } = self;
 
         let mut res = fmt.debug_struct("RequestConfig");
         res.field("timeout", timeout)
             .maybe_field("read_timeout", read_timeout)
             .maybe_field("retry_limit", retry_limit)
             .maybe_field("max_retry_time", retry_timeout)
-            .maybe_field("max_concurrent_requests", max_concurrent_requests)
-            .maybe_field("force_matrix_version", force_matrix_version);
+            .maybe_field("max_concurrent_requests", max_concurrent_requests);
 
         if *force_auth {
             res.field("force_auth", &true);
@@ -90,7 +86,6 @@ impl Default for RequestConfig {
             max_retry_time: Default::default(),
             max_concurrent_requests: Default::default(),
             force_auth: false,
-            force_matrix_version: Default::default(),
         }
     }
 }
@@ -173,17 +168,6 @@ impl RequestConfig {
         self.force_auth = true;
         self
     }
-
-    /// Force the Matrix version used to select which version of the endpoint to
-    /// use.
-    ///
-    /// Can be used to force the use of a stable endpoint when the versions
-    /// advertised by the homeserver do not support it.
-    #[must_use]
-    pub(crate) fn force_matrix_version(mut self, version: MatrixVersion) -> Self {
-        self.force_matrix_version = Some(version);
-        self
-    }
 }
 
 #[cfg(test)]

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

@@ -14,7 +14,6 @@
 
 use std::{
     any::type_name,
-    borrow::Cow,
     fmt::Debug,
     num::NonZeroUsize,
     sync::{
@@ -109,15 +108,6 @@ impl HttpClient {
     {
         trace!(request_type = type_name::<R>(), "Serializing request");
 
-        let supported_versions = if let Some(matrix_version) = config.force_matrix_version {
-            Cow::Owned(SupportedVersions {
-                versions: [matrix_version].into(),
-                features: Default::default(),
-            })
-        } else {
-            Cow::Borrowed(supported_versions)
-        };
-
         let send_access_token = match access_token {
             Some(access_token) => {
                 if config.force_auth {
@@ -130,7 +120,7 @@ impl HttpClient {
         };
 
         let request = request
-            .try_into_http_request::<BytesMut>(&homeserver, send_access_token, &supported_versions)?
+            .try_into_http_request::<BytesMut>(&homeserver, send_access_token, supported_versions)?
             .map(|body| body.freeze());
 
         Ok(request)

crates/matrix-sdk/src/media.rs

@@ -29,7 +29,7 @@ use mime::Mime;
 use ruma::{
     api::{
         client::{authenticated_media, error::ErrorKind, media},
-        FeatureFlag, MatrixVersion,
+        OutgoingRequest,
     },
     assign,
     events::room::{MediaSource, ThumbnailInfo},
@@ -441,18 +441,10 @@ impl Media {
             // available for the user or the file size
             .timeout(None);
 
-        // Use the authenticated endpoints when the server supports Matrix 1.11 or the
-        // authenticated media stable feature.
-        let (use_auth, request_config) =
-            if self.client.server_versions().await?.contains(&MatrixVersion::V1_11) {
-                (true, request_config)
-            } else if self.client.unstable_features().await?.contains(&FeatureFlag::Msc3916Stable) {
-                // We need to force the use of the stable endpoint with the Matrix version
-                // because Ruma does not handle stable features.
-                (true, request_config.force_matrix_version(MatrixVersion::V1_11))
-            } else {
-                (false, request_config)
-            };
+        // Use the authenticated endpoints when the server supports it.
+        let supported_versions = self.client.supported_versions().await?;
+        let use_auth =
+            authenticated_media::get_content::v1::Request::is_supported(&supported_versions);
 
         let content: Vec<u8> = match &request.source {
             MediaSource::Encrypted(file) => {