feat(base,sdk): Support for dirty cross-process lock in the EventCache

benchmarks/benches/event_cache.rs

@@ -317,6 +317,7 @@ fn find_event_relations(c: &mut Criterion) {
                                 let (target, relations) = room_event_cache
                                     .find_event_with_relations(target_event_id, filter)
                                     .await
+                                    .unwrap()
                                     .unwrap();
                                 assert_eq!(target.event_id().as_deref().unwrap(), target_event_id);
                                 assert_eq!(relations.len(), num_related_events as usize);

benchmarks/benches/room_bench.rs

@@ -181,6 +181,8 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
                 .lock()
                 .await
                 .unwrap()
+                .as_clean()
+                .unwrap()
                 .clear_all_linked_chunks()
                 .await
                 .unwrap();

crates/matrix-sdk-base/src/client.rs

@@ -57,7 +57,7 @@ use crate::{
     InviteAcceptanceDetails, RoomStateFilter, SessionMeta,
     deserialized_responses::DisplayName,
     error::{Error, Result},
-    event_cache::store::EventCacheStoreLock,
+    event_cache::store::{EventCacheStoreLock, EventCacheStoreLockState},
     media::store::MediaStoreLock,
     response_processors::{self as processors, Context},
     room::{
@@ -1062,7 +1062,15 @@ impl BaseClient {
         self.state_store.forget_room(room_id).await?;
 
         // Remove the room in the event cache store too.
-        self.event_cache_store().lock().await?.remove_room(room_id).await?;
+        match self.event_cache_store().lock().await? {
+            // If the lock is clear, we can do the operation as expected.
+            // If the lock is dirty, we can ignore to refresh the state, we just need to remove a
+            // room. Also, we must not mark the lock as non-dirty because other operations may be
+            // critical and may need to refresh the `EventCache`' state.
+            EventCacheStoreLockState::Clean(guard) | EventCacheStoreLockState::Dirty(guard) => {
+                guard.remove_room(room_id).await?
+            }
+        }
 
         Ok(())
     }

crates/matrix-sdk-base/src/event_cache/store/mod.rs

@@ -29,7 +29,7 @@ mod traits;
 
 use matrix_sdk_common::cross_process_lock::{
     CrossProcessLock, CrossProcessLockError, CrossProcessLockGeneration, CrossProcessLockGuard,
-    TryLock,
+    MappedCrossProcessLockState, TryLock,
 };
 pub use matrix_sdk_store_encryption::Error as StoreEncryptionError;
 use ruma::{OwnedEventId, events::AnySyncTimelineEvent, serde::Raw};
@@ -83,37 +83,61 @@ impl EventCacheStoreLock {
     }
 
     /// Acquire a spin lock (see [`CrossProcessLock::spin_lock`]).
-    pub async fn lock(&self) -> Result<EventCacheStoreLockGuard<'_>, CrossProcessLockError> {
-        let cross_process_lock_guard = self.cross_process_lock.spin_lock(None).await??.into_guard();
+    pub async fn lock(&self) -> Result<EventCacheStoreLockState, CrossProcessLockError> {
+        let lock_state =
+            self.cross_process_lock.spin_lock(None).await??.map(|cross_process_lock_guard| {
+                EventCacheStoreLockGuard { cross_process_lock_guard, store: self.store.clone() }
+            });
 
-        Ok(EventCacheStoreLockGuard { cross_process_lock_guard, store: self.store.deref() })
+        Ok(lock_state)
     }
 }
 
+/// The equivalent of [`CrossProcessLockState`] but for the [`EventCacheStore`].
+///
+/// [`CrossProcessLockState`]: matrix_sdk_common::cross_process_lock::CrossProcessLockState
+pub type EventCacheStoreLockState = MappedCrossProcessLockState<EventCacheStoreLockGuard>;
+
 /// An RAII implementation of a “scoped lock” of an [`EventCacheStoreLock`].
 /// When this structure is dropped (falls out of scope), the lock will be
 /// unlocked.
-pub struct EventCacheStoreLockGuard<'a> {
+#[derive(Clone)]
+pub struct EventCacheStoreLockGuard {
     /// The cross process lock guard.
     #[allow(unused)]
     cross_process_lock_guard: CrossProcessLockGuard,
 
     /// A reference to the store.
-    store: &'a DynEventCacheStore,
+    store: Arc<DynEventCacheStore>,
+}
+
+impl EventCacheStoreLockGuard {
+    /// Forward to [`CrossProcessLockGuard::clear_dirty`].
+    ///
+    /// This is an associated method to avoid colliding with the [`Deref`]
+    /// implementation.
+    pub fn clear_dirty(this: &Self) {
+        this.cross_process_lock_guard.clear_dirty();
+    }
+
+    /// Force to [`CrossProcessLockGuard::is_dirty`].
+    pub fn is_dirty(this: &Self) -> bool {
+        this.cross_process_lock_guard.is_dirty()
+    }
 }
 
 #[cfg(not(tarpaulin_include))]
-impl fmt::Debug for EventCacheStoreLockGuard<'_> {
+impl fmt::Debug for EventCacheStoreLockGuard {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         formatter.debug_struct("EventCacheStoreLockGuard").finish_non_exhaustive()
     }
 }
 
-impl Deref for EventCacheStoreLockGuard<'_> {
+impl Deref for EventCacheStoreLockGuard {
     type Target = DynEventCacheStore;
 
     fn deref(&self) -> &Self::Target {
-        self.store
+        self.store.as_ref()
     }
 }
 

crates/matrix-sdk-base/src/media/store/mod.rs

@@ -33,7 +33,7 @@ use std::{ops::Deref, sync::Arc};
 
 use matrix_sdk_common::cross_process_lock::{
     CrossProcessLock, CrossProcessLockError, CrossProcessLockGeneration, CrossProcessLockGuard,
-    CrossProcessLockKind, TryLock,
+    CrossProcessLockState, TryLock,
 };
 use matrix_sdk_store_encryption::Error as StoreEncryptionError;
 pub use traits::{DynMediaStore, IntoMediaStore, MediaStore, MediaStoreInner};
@@ -135,14 +135,14 @@ impl MediaStoreLock {
     pub async fn lock(&self) -> Result<MediaStoreLockGuard<'_>, CrossProcessLockError> {
         let cross_process_lock_guard = match self.cross_process_lock.spin_lock(None).await?? {
             // The lock is clean: no other hold acquired it, all good!
-            CrossProcessLockKind::Clean(guard) => guard,
+            CrossProcessLockState::Clean(guard) => guard,
 
             // The lock is dirty: another holder acquired it since the last time we acquired it.
             // It's not a problem in the case of the `MediaStore` because this API is “stateless” at
             // the time of writing (2025-11-11). There is nothing that can be out-of-sync: all the
             // state is in the database, nothing in memory.
-            CrossProcessLockKind::Dirty(guard) => {
-                self.cross_process_lock.clear_dirty();
+            CrossProcessLockState::Dirty(guard) => {
+                guard.clear_dirty();
 
                 guard
             }