refactor(event cache): have the room pagination handle waiting for the previous pagination token from sync

This case is very specific to the room pagination, and will not apply to
the thread pagination; by removing it from the generic pagination logic,
we'll be able to use the generic pagination logic for threads.

Author: bnjbvr

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

@@ -185,35 +185,39 @@ impl RoomPagination {
             let mut state_guard = self.inner.state.write().await;
 
             match state_guard.load_more_events_backwards().await? {
-                LoadMoreEventsBackwardsOutcome::WaitForInitialPrevToken => {
-                    const DEFAULT_WAIT_FOR_TOKEN_DURATION: Duration = Duration::from_secs(3);
-
-                    // Release the state guard while waiting, to not deadlock the sync task.
-                    drop(state_guard);
-
-                    // Otherwise, wait for a notification that we received a previous-batch token.
-                    trace!("waiting for a pagination token…");
-                    let _ = timeout(
-                        self.inner.pagination_batch_token_notifier.notified(),
-                        DEFAULT_WAIT_FOR_TOKEN_DURATION,
-                    )
-                    .await;
-                    trace!("done waiting");
-
-                    self.inner.state.write().await.waited_for_initial_prev_token = true;
-
-                    // Retry!
-                    //
-                    // Note: the next call to `load_more_events_backwards` can't return
-                    // `WaitForInitialPrevToken` because we've just set to
-                    // `waited_for_initial_prev_token`, so this is not an infinite loop.
-                    //
-                    // Note 2: not a recursive call, because recursive and async have a bad time
-                    // together.
-                    continue;
-                }
-
                 LoadMoreEventsBackwardsOutcome::Gap { prev_token } => {
+                    if prev_token.is_none() && !state_guard.waited_for_initial_prev_token {
+                        // We didn't reload a pagination token, and we haven't waited for one; wait
+                        // and start over.
+
+                        const DEFAULT_WAIT_FOR_TOKEN_DURATION: Duration = Duration::from_secs(3);
+
+                        // Release the state guard while waiting, to not deadlock the sync task.
+                        drop(state_guard);
+
+                        // Otherwise, wait for a notification that we received a previous-batch
+                        // token.
+                        trace!("waiting for a pagination token…");
+                        let _ = timeout(
+                            self.inner.pagination_batch_token_notifier.notified(),
+                            DEFAULT_WAIT_FOR_TOKEN_DURATION,
+                        )
+                        .await;
+                        trace!("done waiting");
+
+                        self.inner.state.write().await.waited_for_initial_prev_token = true;
+
+                        // Retry!
+                        //
+                        // Note: the next call to `load_more_events_backwards` can't return
+                        // `WaitForInitialPrevToken` because we've just set to
+                        // `waited_for_initial_prev_token`, so this is not an infinite loop.
+                        //
+                        // Note 2: not a recursive call, because recursive and async have a bad time
+                        // together.
+                        continue;
+                    }
+
                     // We have a gap, so resolve it with a network back-pagination.
                     drop(state_guard);
                     return self.paginate_backwards_with_network(batch_size, prev_token).await;

crates/matrix-sdk/src/event_cache/room/mod.rs

@@ -301,10 +301,6 @@ impl RoomEventCache {
                     // TODO: implement :)
                     unimplemented!("loading from disk for threads is not implemented yet");
                 }
-
-                LoadMoreEventsBackwardsOutcome::WaitForInitialPrevToken => {
-                    unreachable!("unused for threads")
-                }
             }
         }
     }
@@ -595,9 +591,6 @@ pub(super) enum LoadMoreEventsBackwardsOutcome {
 
     /// Events have been inserted.
     Events { events: Vec<Event>, timeline_event_diffs: Vec<VectorDiff<Event>>, reached_start: bool },
-
-    /// The caller must wait for the initial previous-batch token, and retry.
-    WaitForInitialPrevToken,
 }
 
 // Use a private module to hide `events` to this parent module.
@@ -946,23 +939,15 @@ mod private {
                     // sync for that room, because every room must have *at least* a room creation
                     // event. Otherwise, we have reached the start of the timeline.
 
-                    let result = if self.room_linked_chunk.events().next().is_some() {
+                    if self.room_linked_chunk.events().next().is_some() {
                         // If there's at least one event, this means we've reached the start of the
                         // timeline, since the chunk is fully loaded.
                         trace!("chunk is fully loaded and non-empty: reached_start=true");
-                        LoadMoreEventsBackwardsOutcome::StartOfTimeline
-                    } else if !self.waited_for_initial_prev_token {
-                        // There no events. Since we haven't yet, wait for an initial
-                        // previous-token.
-                        LoadMoreEventsBackwardsOutcome::WaitForInitialPrevToken
-                    } else {
-                        // Otherwise, we've already waited, *and* received no previous-batch token
-                        // from the sync, *and* there are still no events in the fully-loaded
-                        // chunk: start back-pagination from the end of the room.
-                        LoadMoreEventsBackwardsOutcome::Gap { prev_token: None }
-                    };
+                        return Ok(LoadMoreEventsBackwardsOutcome::StartOfTimeline);
+                    }
 
-                    return Ok(result);
+                    // Otherwise, start back-pagination from the end of the room.
+                    return Ok(LoadMoreEventsBackwardsOutcome::Gap { prev_token: None });
                 }
 
                 Err(err) => {