fix(sdk): Reload all the “inner states” of a RoomEventCache at once.

`RoomEventCache` holds the states for the room cache, the thread caches,
and the pinned-events cache. When the cross-process lock is dirty, it
has to reload all these caches.

Ideally, we must move all the states in a single struct, behind the
cross-process lock, because right now, when the lock is dirty, only a
single room is reloaded, not all the rooms. This is a temporary fix.

Author: Hywan

crates/matrix-sdk/src/event_cache/caches/pinned_events/mod.rs

@@ -36,14 +36,13 @@ use tracing::{debug, instrument, trace, warn};
 use super::super::redecryptor::ResolvedUtd;
 use super::{
     super::{EventCacheError, EventsOrigin, Result, persistence::send_updates_to_store},
+    TimelineVectorDiffs,
     event_linked_chunk::EventLinkedChunk,
     lock,
+    lock::Reload as _,
     room::RoomEventCacheLinkedChunkUpdate,
 };
-use crate::{
-    Room, client::WeakClient, config::RequestConfig, event_cache::TimelineVectorDiffs,
-    room::WeakRoom,
-};
+use crate::{Room, client::WeakClient, config::RequestConfig, room::WeakRoom};
 
 pub(in super::super) struct PinnedEventCacheState {
     /// The ID of the room owning this list of pinned events.
@@ -542,4 +541,12 @@ impl PinnedEventCache {
 
         Ok(Some(loaded_events))
     }
+
+    /// Force to reload the pinned events.
+    //
+    // TODO(@hywan): Temporary fix. All the states must be in a single struct behind
+    // the cross-process lock instead of being dispatched in each cache.
+    pub(super) async fn reload(&self) -> Result<()> {
+        self.state.write().await?.reload().await
+    }
 }

crates/matrix-sdk/src/event_cache/caches/room/state.rs

@@ -413,6 +413,16 @@ impl<'a> lock::Reload for RoomEventCacheStateLockWriteGuard<'a> {
     async fn reload(&mut self) -> Result<(), EventCacheError> {
         self.shrink_to_last_chunk().await?;
 
+        // Reload the threads.
+        for (_thread_id, thread_event_cache) in &mut self.threads {
+            thread_event_cache.reload().await?;
+        }
+
+        // Reload the pinned-events.
+        if let Some(pinned_event_cache) = self.pinned_event_cache.get_mut() {
+            pinned_event_cache.reload().await?;
+        }
+
         let diffs = self.state.room_linked_chunk.updates_as_vector_diffs();
 
         // Notify observers about the update.

crates/matrix-sdk/src/event_cache/caches/thread/mod.rs

@@ -33,6 +33,7 @@ use self::{pagination::ThreadPagination, updates::ThreadEventCacheUpdateSender};
 use super::{
     super::Result,
     EventsOrigin, TimelineVectorDiffs,
+    lock::Reload as _,
     room::{RoomEventCacheGenericUpdate, RoomEventCacheLinkedChunkUpdate},
 };
 use crate::room::WeakRoom;
@@ -229,6 +230,14 @@ impl ThreadEventCache {
             .and_then(|(_position, event)| event.event_id()))
     }
 
+    /// Force to reload the thread.
+    //
+    // TODO(@hywan): Temporary fix. All the states must be in a single struct behind
+    // the cross-process lock instead of being dispatched in each cache.
+    pub(super) async fn reload(&self) -> Result<()> {
+        self.inner.state.write().await?.reload().await
+    }
+
     /// Find a single event in this thread.
     ///
     /// It starts by looking into loaded events in `EventLinkedChunk` before