feat(sdk): Add SlidingSyncListBuilder::requires_timeout.

This patch adds a new `SlidingSyncListBuilder::requires_timeout` method
that takes a function deciding whether the list requires a timeout, i.e.
if the list should trigger a `http::Request::timeout`, i.e. if it
deserves a long-polling or not.

The default behaviour is kept for compatibility purposes.

Author: Hywan

crates/matrix-sdk/src/sliding_sync/list/builder.rs

@@ -33,6 +33,10 @@ struct SlidingSyncListCachedData {
 #[derive(Clone)]
 pub struct SlidingSyncListBuilder {
     sync_mode: SlidingSyncMode,
+    #[cfg(not(target_family = "wasm"))]
+    requires_timeout: Arc<dyn Fn(&SlidingSyncListRequestGenerator) -> bool + Send + Sync>,
+    #[cfg(target_family = "wasm")]
+    requires_timeout: Arc<dyn Fn(&SlidingSyncListRequestGenerator) -> bool>,
     required_state: Vec<(StateEventType, String)>,
     filters: Option<http::request::ListFilters>,
     timeline_limit: Bound,
@@ -70,6 +74,7 @@ impl SlidingSyncListBuilder {
     pub(super) fn new(name: impl Into<String>) -> Self {
         Self {
             sync_mode: SlidingSyncMode::default(),
+            requires_timeout: Arc::new(|request_generator| request_generator.is_fully_loaded()),
             required_state: vec![
                 (StateEventType::RoomEncryption, "".to_owned()),
                 (StateEventType::RoomTombstone, "".to_owned()),
@@ -117,6 +122,34 @@ impl SlidingSyncListBuilder {
         self
     }
 
+    /// Custom function to decide whether this list requires a
+    /// [`http::Request::timeout`] value.
+    ///
+    /// A list requires a `timeout` query if and only if we want the server to
+    /// wait on new updates, i.e. to do a long-polling.
+    #[cfg(not(target_family = "wasm"))]
+    pub fn requires_timeout<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&SlidingSyncListRequestGenerator) -> bool + Send + Sync + 'static,
+    {
+        self.requires_timeout = Arc::new(f);
+        self
+    }
+
+    /// Custom function to decide whether this list requires a
+    /// [`http::Request::timeout`] value.
+    ///
+    /// A list requires a `timeout` query if and only if we want the server to
+    /// wait on new updates, i.e. to do a long-polling.
+    #[cfg(target_family = "wasm")]
+    pub fn requires_timeout<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&SlidingSyncListRequestGenerator) -> bool + 'static,
+    {
+        self.requires_timeout = Arc::new(f);
+        self
+    }
+
     /// Required states to return per room.
     pub fn required_state(mut self, value: Vec<(StateEventType, String)>) -> Self {
         self.required_state = value;
@@ -186,6 +219,7 @@ impl SlidingSyncListBuilder {
                 timeline_limit: StdRwLock::new(self.timeline_limit),
                 name: self.name,
                 cache_policy: self.cache_policy,
+                requires_timeout: self.requires_timeout,
 
                 // Computed from the builder.
                 request_generator: StdRwLock::new(SlidingSyncListRequestGenerator::new(

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

@@ -4,7 +4,7 @@ mod request_generator;
 mod sticky;
 
 use std::{
-    fmt::Debug,
+    fmt,
     ops::RangeInclusive,
     sync::{Arc, RwLock as StdRwLock},
 };
@@ -95,18 +95,11 @@ impl SlidingSyncList {
     /// Check whether this list requires a [`http::Request::timeout`] value.
     ///
     /// A list requires a `timeout` query if and only if we want the server to
-    /// wait on new updates, i.e. to do a long-polling. If the list has a
-    /// selective sync mode ([`SlidingSyncMode::Selective`]), we expect the
-    /// server to always wait for new updates as the list ranges are always
-    /// the same. Otherwise, if the list is fully loaded, it means the list
-    /// ranges cover all the available rooms, then we expect the server
-    /// to always wait for new updates. If the list isn't fully loaded, it
-    /// means the current list ranges may hit a set of rooms that have no
-    /// update, but we don't want to wait for updates; we instead want to
-    /// move quickly to the next range.
+    /// wait on new updates, i.e. to do a long-polling.
     pub(super) fn requires_timeout(&self) -> bool {
-        self.inner.request_generator.read().unwrap().is_selective()
-            || self.state().is_fully_loaded()
+        let request_generator = &*self.inner.request_generator.read().unwrap();
+
+        (self.inner.requires_timeout)(request_generator)
     }
 
     /// Get a stream of state updates.
@@ -211,14 +204,19 @@ impl SlidingSyncList {
     }
 }
 
-#[derive(Debug)]
 pub(super) struct SlidingSyncListInner {
     /// Name of this list to easily recognize them.
     name: String,
 
     /// The state this list is in.
     state: SharedObservable<SlidingSyncListLoadingState>,
 
+    /// Does this list require a timeout?
+    #[cfg(not(target_family = "wasm"))]
+    requires_timeout: Arc<dyn Fn(&SlidingSyncListRequestGenerator) -> bool + Send + Sync>,
+    #[cfg(target_family = "wasm")]
+    requires_timeout: Arc<dyn Fn(&SlidingSyncListRequestGenerator) -> bool>,
+
     /// Parameters that are sticky, and can be sent only once per session (until
     /// the connection is dropped or the server invalidates what the client
     /// knows).
@@ -251,6 +249,15 @@ pub(super) struct SlidingSyncListInner {
     sync_mode: StdRwLock<SlidingSyncMode>,
 }
 
+impl fmt::Debug for SlidingSyncListInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SlidingSyncListInner")
+            .field("name", &self.name)
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
 impl SlidingSyncListInner {
     /// Change the sync-mode.
     ///
@@ -374,6 +381,7 @@ pub enum SlidingSyncListLoadingState {
     FullyLoaded,
 }
 
+#[cfg(test)]
 impl SlidingSyncListLoadingState {
     /// Check whether the state is [`Self::FullyLoaded`].
     fn is_fully_loaded(&self) -> bool {

crates/matrix-sdk/src/sliding_sync/list/request_generator.rs

@@ -35,7 +35,7 @@ use crate::{SlidingSyncListLoadingState, sliding_sync::Error};
 
 /// The kind of request generator.
 #[derive(Debug, PartialEq)]
-pub(super) enum SlidingSyncListRequestGeneratorKind {
+pub enum SlidingSyncListRequestGeneratorKind {
     /// Growing-mode (see [`SlidingSyncMode`]).
     Growing {
         /// Size of the batch, used to grow the range to fetch more rooms.
@@ -72,7 +72,7 @@ pub(super) enum SlidingSyncListRequestGeneratorKind {
 
 /// A request generator for [`SlidingSyncList`].
 #[derive(Debug)]
-pub(in super::super) struct SlidingSyncListRequestGenerator {
+pub struct SlidingSyncListRequestGenerator {
     /// The current ranges used by this request generator.
     ///
     /// Note there's only one range in the `Growing` and `Paging` mode.
@@ -114,22 +114,20 @@ impl SlidingSyncListRequestGenerator {
         }
     }
 
-    /// Check whether this request generator is of kind
-    /// [`SlidingSyncListRequestGeneratorKind::Selective`].
-    pub(super) fn is_selective(&self) -> bool {
-        matches!(self.kind, SlidingSyncListRequestGeneratorKind::Selective)
-    }
-
     /// Return a view on the ranges requested by this generator.
     ///
     /// For generators in the selective mode, this is the initial set of ranges.
     /// For growing and paginated generators, this is the range committed in the
     /// latest response received from the server.
-    #[cfg(test)]
-    pub(super) fn requested_ranges(&self) -> &[Range] {
+    pub fn requested_ranges(&self) -> &[Range] {
         &self.ranges
     }
 
+    /// Return the kind of request generator is used by this generator.
+    pub fn kind(&self) -> &SlidingSyncListRequestGeneratorKind {
+        &self.kind
+    }
+
     /// Update internal state of the generator (namely, ranges) before the next
     /// sliding sync request.
     pub(super) fn generate_next_ranges(
@@ -280,14 +278,21 @@ impl SlidingSyncListRequestGenerator {
         }
     }
 
-    #[cfg(test)]
-    pub(super) fn is_fully_loaded(&self) -> bool {
+    /// Check whether the list is fully loaded.
+    pub fn is_fully_loaded(&self) -> bool {
         match self.kind {
             SlidingSyncListRequestGeneratorKind::Paging { fully_loaded, .. }
             | SlidingSyncListRequestGeneratorKind::Growing { fully_loaded, .. } => fully_loaded,
             SlidingSyncListRequestGeneratorKind::Selective => true,
         }
     }
+
+    /// Check whether this request generator is of kind
+    /// [`SlidingSyncListRequestGeneratorKind::Selective`].
+    #[cfg(test)]
+    pub fn is_selective(&self) -> bool {
+        matches!(self.kind, SlidingSyncListRequestGeneratorKind::Selective)
+    }
 }
 
 fn create_range(