refactor(event cache): get rid of get_or_wait_for_token

Also the tests, they were not quite useful to port to the new mechanism
because they made little sense.

Author: bnjbvr

crates/matrix-sdk/src/event_cache/pagination.rs

@@ -27,10 +27,7 @@ use tracing::{debug, instrument, trace};
 
 use super::{
     deduplicator::DeduplicationOutcome,
-    room::{
-        events::{Gap, RoomEvents},
-        LoadMoreEventsBackwardsOutcome, RoomEventCacheInner,
-    },
+    room::{events::Gap, LoadMoreEventsBackwardsOutcome, RoomEventCacheInner},
     BackPaginationOutcome, EventsOrigin, Result, RoomEventCacheState, RoomEventCacheUpdate,
 };
 use crate::{event_cache::EventCacheError, room::MessagesOptions};
@@ -450,72 +447,6 @@ impl RoomPagination {
         Ok(backpagination_outcome)
     }
 
-    /// Get the latest pagination token, as stored in the room events linked
-    /// list, or wait for it for the given amount of time.
-    ///
-    /// It will only wait if we *never* saw an initial previous-batch token.
-    /// Otherwise, it will immediately skip.
-    #[doc(hidden)]
-    pub async fn get_or_wait_for_token(&self, wait_time: Option<Duration>) -> PaginationToken {
-        fn get_latest(events: &RoomEvents) -> Option<String> {
-            events.rchunks().find_map(|chunk| match chunk.content() {
-                ChunkContent::Gap(gap) => Some(gap.prev_token.clone()),
-                ChunkContent::Items(..) => None,
-            })
-        }
-
-        {
-            // Scope for the lock guard.
-            let state = self.inner.state.read().await;
-
-            // Check if the linked chunk contains any events. If so, absence of a gap means
-            // we've hit the start of the timeline. If not, absence of a gap
-            // means we've never received a pagination token from sync, and we
-            // should wait for one.
-            let has_events = state.events().events().next().is_some();
-
-            // Fast-path: we do have a previous-batch token already.
-            if let Some(found) = get_latest(state.events()) {
-                return PaginationToken::HasMore(found);
-            }
-
-            // If we had events, and there was no gap, then we've hit the end of the
-            // timeline.
-            if has_events {
-                return PaginationToken::HitEnd;
-            }
-
-            // If we've already waited for an initial previous-batch token before,
-            // immediately abort.
-            if state.waited_for_initial_prev_token {
-                return PaginationToken::None;
-            }
-        }
-
-        // If the caller didn't set a wait time, return none early.
-        let Some(wait_time) = wait_time else {
-            return PaginationToken::None;
-        };
-
-        // Otherwise, wait for a notification that we received a previous-batch token.
-        // Note the state lock is released while doing so, allowing other tasks to write
-        // into the linked chunk.
-        let _ = timeout(self.inner.pagination_batch_token_notifier.notified(), wait_time).await;
-
-        let mut state = self.inner.state.write().await;
-
-        state.waited_for_initial_prev_token = true;
-
-        if let Some(token) = get_latest(state.events()) {
-            PaginationToken::HasMore(token)
-        } else if state.events().events().next().is_some() {
-            // See logic above, in the read lock guard scope.
-            PaginationToken::HitEnd
-        } else {
-            PaginationToken::None
-        }
-    }
-
     /// Returns a subscriber to the pagination status used for the
     /// back-pagination integrated to the event cache.
     pub fn status(&self) -> Subscriber<RoomPaginationStatus> {
@@ -545,311 +476,3 @@ impl From<Option<String>> for PaginationToken {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    // Those tests require time to work, and it does not on wasm32.
-    #[cfg(not(target_arch = "wasm32"))]
-    mod time_tests {
-        use std::time::{Duration, Instant};
-
-        use assert_matches::assert_matches;
-        use matrix_sdk_base::RoomState;
-        use matrix_sdk_test::{async_test, event_factory::EventFactory, ALICE};
-        use ruma::{event_id, room_id, user_id};
-        use tokio::{spawn, time::sleep};
-
-        use crate::{
-            event_cache::{pagination::PaginationToken, room::events::Gap},
-            test_utils::logged_in_client,
-        };
-
-        #[async_test]
-        async fn test_wait_no_pagination_token() {
-            let client = logged_in_client(None).await;
-            let room_id = room_id!("!galette:saucisse.bzh");
-            client.base_client().get_or_create_room(room_id, RoomState::Joined);
-
-            let event_cache = client.event_cache();
-
-            event_cache.subscribe().unwrap();
-
-            let (room_event_cache, _drop_handlers) = event_cache.for_room(room_id).await.unwrap();
-
-            let pagination = room_event_cache.pagination();
-
-            // If I have a room with no events, and try to get a pagination token without
-            // waiting,
-            let found = pagination.get_or_wait_for_token(None).await;
-            // Then I don't get any pagination token.
-            assert_matches!(found, PaginationToken::None);
-
-            // Reset waited_for_initial_prev_token and event state.
-            let _ = pagination.inner.state.write().await.reset().await.unwrap();
-
-            // If I wait for a back-pagination token for 0 seconds,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::default())).await;
-            let waited = before.elapsed();
-            // then I don't get any,
-            assert_matches!(found, PaginationToken::None);
-            // and I haven't waited long.
-            assert!(waited.as_secs() < 1);
-
-            // Reset waited_for_initial_prev_token state.
-            let _ = pagination.inner.state.write().await.reset().await.unwrap();
-
-            // If I wait for a back-pagination token for 1 second,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::from_secs(1))).await;
-            let waited = before.elapsed();
-            // then I still don't get any.
-            assert_matches!(found, PaginationToken::None);
-            // and I've waited a bit.
-            assert!(waited.as_secs() < 2);
-            assert!(waited.as_secs() >= 1);
-        }
-
-        #[async_test]
-        async fn test_wait_hit_end_of_timeline() {
-            let client = logged_in_client(None).await;
-            let room_id = room_id!("!galette:saucisse.bzh");
-            client.base_client().get_or_create_room(room_id, RoomState::Joined);
-
-            let event_cache = client.event_cache();
-
-            event_cache.subscribe().unwrap();
-
-            let (room_event_cache, _drop_handlers) = event_cache.for_room(room_id).await.unwrap();
-
-            let f = EventFactory::new().room(room_id).sender(*ALICE);
-            let pagination = room_event_cache.pagination();
-
-            // Add a previous event.
-            room_event_cache
-                .inner
-                .state
-                .write()
-                .await
-                .with_events_mut(|events| {
-                    events.push_events([f
-                        .text_msg("this is the start of the timeline")
-                        .into_event()]);
-                })
-                .await
-                .unwrap();
-
-            // If I have a room with events, and try to get a pagination token without
-            // waiting,
-            let found = pagination.get_or_wait_for_token(None).await;
-            // I've reached the start of the timeline.
-            assert_matches!(found, PaginationToken::HitEnd);
-
-            // If I wait for a back-pagination token for 0 seconds,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::default())).await;
-            let waited = before.elapsed();
-            // Then I still have reached the start of the timeline.
-            assert_matches!(found, PaginationToken::HitEnd);
-            // and I've waited very little.
-            assert!(waited.as_secs() < 1);
-
-            // If I wait for a back-pagination token for 1 second,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::from_secs(1))).await;
-            let waited = before.elapsed();
-            // then I still don't get any.
-            assert_matches!(found, PaginationToken::HitEnd);
-            // and I've waited very little (there's no point in waiting in this case).
-            assert!(waited.as_secs() < 1);
-
-            // Now, reset state. We'll add an event *after* we've started waiting, this
-            // time.
-            room_event_cache.clear().await.unwrap();
-
-            spawn(async move {
-                sleep(Duration::from_secs(1)).await;
-
-                room_event_cache
-                    .inner
-                    .state
-                    .write()
-                    .await
-                    .with_events_mut(|events| {
-                        events.push_events([f
-                            .text_msg("this is the start of the timeline")
-                            .into_event()]);
-                    })
-                    .await
-                    .unwrap();
-            });
-
-            // If I wait for a pagination token,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::from_secs(2))).await;
-            let waited = before.elapsed();
-            // since sync has returned all events, and no prior gap, I've hit the end.
-            assert_matches!(found, PaginationToken::HitEnd);
-            // and I've waited for the whole duration.
-            assert!(waited.as_secs() >= 2);
-            assert!(waited.as_secs() < 3);
-        }
-
-        #[async_test]
-        async fn test_wait_for_pagination_token_already_present() {
-            let client = logged_in_client(None).await;
-            let room_id = room_id!("!galette:saucisse.bzh");
-            client.base_client().get_or_create_room(room_id, RoomState::Joined);
-
-            let event_cache = client.event_cache();
-
-            event_cache.subscribe().unwrap();
-
-            let (room_event_cache, _drop_handlers) = event_cache.for_room(room_id).await.unwrap();
-
-            let expected_token = "old".to_owned();
-
-            // When I have events and multiple gaps, in a room,
-            {
-                room_event_cache
-                    .inner
-                    .state
-                    .write()
-                    .await
-                    .with_events_mut(|room_events| {
-                        room_events.push_gap(Gap { prev_token: expected_token.clone() });
-                        room_events.push_events([EventFactory::new()
-                            .text_msg("yolo")
-                            .sender(user_id!("@b:z.h"))
-                            .event_id(event_id!("$ida"))
-                            .into_event()]);
-                    })
-                    .await
-                    .unwrap();
-            }
-
-            let pagination = room_event_cache.pagination();
-
-            // If I don't wait for a back-pagination token,
-            let found = pagination.get_or_wait_for_token(None).await;
-            // Then I get it.
-            assert_eq!(found, PaginationToken::HasMore(expected_token.clone()));
-
-            // If I wait for a back-pagination token for 0 seconds,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::default())).await;
-            let waited = before.elapsed();
-            // then I do get one.
-            assert_eq!(found, PaginationToken::HasMore(expected_token.clone()));
-            // and I haven't waited long.
-            assert!(waited.as_millis() < 100);
-
-            // If I wait for a back-pagination token for 1 second,
-            let before = Instant::now();
-            let found = pagination.get_or_wait_for_token(Some(Duration::from_secs(1))).await;
-            let waited = before.elapsed();
-            // then I do get one.
-            assert_eq!(found, PaginationToken::HasMore(expected_token));
-            // and I haven't waited long.
-            assert!(waited.as_millis() < 100);
-        }
-
-        #[async_test]
-        async fn test_wait_for_late_pagination_token() {
-            let client = logged_in_client(None).await;
-            let room_id = room_id!("!galette:saucisse.bzh");
-            client.base_client().get_or_create_room(room_id, RoomState::Joined);
-
-            let event_cache = client.event_cache();
-
-            event_cache.subscribe().unwrap();
-
-            let (room_event_cache, _drop_handles) = event_cache.for_room(room_id).await.unwrap();
-
-            let expected_token = "old".to_owned();
-
-            let before = Instant::now();
-            let cloned_expected_token = expected_token.clone();
-            let cloned_room_event_cache = room_event_cache.clone();
-            let insert_token_task = spawn(async move {
-                // If a backpagination token is inserted after 400 milliseconds,
-                sleep(Duration::from_millis(400)).await;
-
-                cloned_room_event_cache
-                    .inner
-                    .state
-                    .write()
-                    .await
-                    .with_events_mut(|events| {
-                        events.push_gap(Gap { prev_token: cloned_expected_token })
-                    })
-                    .await
-                    .unwrap();
-            });
-
-            let pagination = room_event_cache.pagination();
-
-            // Then first I don't get it (if I'm not waiting,)
-            let found = pagination.get_or_wait_for_token(None).await;
-            assert_matches!(found, PaginationToken::None);
-
-            // And if I wait for the back-pagination token for 600ms,
-            let found = pagination.get_or_wait_for_token(Some(Duration::from_millis(600))).await;
-            let waited = before.elapsed();
-
-            // then I do get one eventually.
-            assert_eq!(found, PaginationToken::HasMore(expected_token));
-            // and I have waited between ~400 and ~1000 milliseconds.
-            assert!(waited.as_secs() < 1);
-            assert!(waited.as_millis() >= 400);
-
-            // The task succeeded.
-            insert_token_task.await.unwrap();
-        }
-
-        #[async_test]
-        async fn test_get_latest_token() {
-            let client = logged_in_client(None).await;
-            let room_id = room_id!("!galette:saucisse.bzh");
-            client.base_client().get_or_create_room(room_id, RoomState::Joined);
-
-            let event_cache = client.event_cache();
-
-            event_cache.subscribe().unwrap();
-
-            let (room_event_cache, _drop_handles) = event_cache.for_room(room_id).await.unwrap();
-
-            let old_token = "old".to_owned();
-            let new_token = "new".to_owned();
-
-            // Assuming a room event cache that contains both an old and a new pagination
-            // token, and events in between,
-            room_event_cache
-                .inner
-                .state
-                .write()
-                .await
-                .with_events_mut(|events| {
-                    let f = EventFactory::new().room(room_id).sender(*ALICE);
-
-                    // This simulates a valid representation of a room: first group of gap+events
-                    // were e.g. restored from the cache; second group of gap+events was received
-                    // from a subsequent sync.
-                    events.push_gap(Gap { prev_token: old_token });
-                    events.push_events([f.text_msg("oldest from cache").into()]);
-
-                    events.push_gap(Gap { prev_token: new_token.clone() });
-                    events.push_events([f.text_msg("sync'd gappy timeline").into()]);
-                })
-                .await
-                .unwrap();
-
-            let pagination = room_event_cache.pagination();
-
-            // Retrieving the pagination token will return the most recent one, not the old
-            // one.
-            let found = pagination.get_or_wait_for_token(None).await;
-            assert_eq!(found, PaginationToken::HasMore(new_token));
-        }
-    }
-}