update #3

Author: Hywan

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

@@ -612,7 +612,10 @@ mod private {
         deserialized_responses::{ThreadSummary, ThreadSummaryStatus, TimelineEventKind},
         event_cache::{
             Event, Gap,
-            store::{DynEventCacheStore, EventCacheStoreLock},
+            store::{
+                DynEventCacheStore, EventCacheStoreLock, EventCacheStoreLockGuard,
+                EventCacheStoreLockState,
+            },
         },
         linked_chunk::{
             ChunkContent, ChunkIdentifierGenerator, ChunkMetadata, LinkedChunkId,
@@ -707,7 +710,19 @@ mod private {
             store: EventCacheStoreLock,
             pagination_status: SharedObservable<RoomPaginationStatus>,
         ) -> Result<Self, EventCacheError> {
-            let store_lock = store.lock().await?;
+            let store_guard = match store.lock().await? {
+                // The lock is clean: all good.
+                EventCacheStoreLockState::Clean(guard) => guard,
+
+                // The lock is dirty: that's not a problem here! Why? Because we are creating the
+                // state, so it's necessarily new, which means we don't need to refresh it. We must
+                // clear the dirtiness though.
+                EventCacheStoreLockState::Dirty(guard) => {
+                    EventCacheStoreLockGuard::clear_dirty(&guard);
+
+                    guard
+                }
+            };
 
             let linked_chunk_id = LinkedChunkId::Room(&room_id);
 
@@ -716,15 +731,15 @@ mod private {
             // If loading the full linked chunk failed, we'll clear the event cache, as it
             // indicates that at some point, there's some malformed data.
             let full_linked_chunk_metadata =
-                match Self::load_linked_chunk_metadata(&*store_lock, linked_chunk_id).await {
+                match Self::load_linked_chunk_metadata(&*store_guard, linked_chunk_id).await {
                     Ok(metas) => metas,
                     Err(err) => {
                         error!(
                             "error when loading a linked chunk's metadata from the store: {err}"
                         );
 
                         // Try to clear storage for this room.
-                        store_lock
+                        store_guard
                             .handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear])
                             .await?;
 
@@ -733,7 +748,7 @@ mod private {
                     }
                 };
 
-            let linked_chunk = match store_lock
+            let linked_chunk = match store_guard
                 .load_last_chunk(linked_chunk_id)
                 .await
                 .map_err(EventCacheError::from)
@@ -748,7 +763,7 @@ mod private {
                     );
 
                     // Try to clear storage for this room.
-                    store_lock
+                    store_guard
                         .handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear])
                         .await?;
 
@@ -910,20 +925,32 @@ mod private {
         pub(in super::super) async fn load_more_events_backwards(
             &mut self,
         ) -> Result<LoadMoreEventsBackwardsOutcome, EventCacheError> {
+            let store_guard = match self.store.lock().await? {
+                // The lock is clean: we don't need to refresh the in-memory state.
+                EventCacheStoreLockState::Clean(guard) => guard,
+
+                // The lock is dirty: we need to refresh the in-memory state before working with it.
+                EventCacheStoreLockState::Dirty(guard) => {
+                    EventCacheStoreLockGuard::clear_dirty(&guard);
+
+                    self.shrink_to_last_chunk_with_store_guard(&guard).await?;
+
+                    guard
+                }
+            };
+
             // If any in-memory chunk is a gap, don't load more events, and let the caller
             // resolve the gap.
             if let Some(prev_token) = self.room_linked_chunk.rgap().map(|gap| gap.prev_token) {
                 return Ok(LoadMoreEventsBackwardsOutcome::Gap { prev_token: Some(prev_token) });
             }
 
-            let store = self.store.lock().await?;
-
             let prev_first_chunk =
                 self.room_linked_chunk.chunks().next().expect("a linked chunk is never empty");
 
             // The first chunk is not a gap, we can load its previous chunk.
             let linked_chunk_id = LinkedChunkId::Room(&self.room);
-            let new_first_chunk = match store
+            let new_first_chunk = match store_guard
                 .load_previous_chunk(linked_chunk_id, prev_first_chunk.identifier())
                 .await
             {
@@ -952,7 +979,9 @@ mod private {
                     error!("error when loading the previous chunk of a linked chunk: {err}");
 
                     // Clear storage for this room.
-                    store.handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear]).await?;
+                    store_guard
+                        .handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear])
+                        .await?;
 
                     // Return the error.
                     return Err(err.into());
@@ -972,7 +1001,9 @@ mod private {
                 error!("error when inserting the previous chunk into its linked chunk: {err}");
 
                 // Clear storage for this room.
-                store.handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear]).await?;
+                store_guard
+                    .handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear])
+                    .await?;
 
                 // Return the error.
                 return Err(err.into());
@@ -1011,8 +1042,27 @@ mod private {
         ///
         /// Otherwise, returns `None`.
         pub(super) async fn shrink_to_last_chunk(&mut self) -> Result<(), EventCacheError> {
-            let store_lock = self.store.lock().await?;
+            let store_guard = match self.store.lock().await? {
+                // The lock is clean: all good!
+                EventCacheStoreLockState::Clean(guard) => guard,
+
+                // The lock is dirty. We need to refresh the in-memory state. Fortunately for us,
+                // that's exactly what this current method does. Let's clear the dirtiness, and
+                // let's keep going.
+                EventCacheStoreLockState::Dirty(guard) => {
+                    EventCacheStoreLockGuard::clear_dirty(&guard);
+
+                    guard
+                }
+            };
+
+            self.shrink_to_last_chunk_with_store_guard(&store_guard).await
+        }
 
+        async fn shrink_to_last_chunk_with_store_guard(
+            &mut self,
+            store_lock: &EventCacheStoreLockGuard,
+        ) -> Result<(), EventCacheError> {
             // Attempt to load the last chunk.
             let linked_chunk_id = LinkedChunkId::Room(&self.room);
             let (last_chunk, chunk_identifier_generator) =
@@ -1081,6 +1131,7 @@ mod private {
             &mut self,
         ) -> Result<Vec<VectorDiff<Event>>, EventCacheError> {
             self.shrink_to_last_chunk().await?;
+
             Ok(self.room_linked_chunk.updates_as_vector_diffs())
         }