refactor(common): Rename LockStoreError to CrossProcessLockError.

This patch renames the `LockStoreError` enum to `CrossProcessLockError`
to be consistent with the other types in the same module.

The `BackingStoreError` variant is also renamed to `TryLockError`.

Author: Hywan

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

@@ -15,7 +15,7 @@
 
 //! Error conditions.
 
-use matrix_sdk_common::cross_process_lock::LockStoreError;
+use matrix_sdk_common::cross_process_lock::CrossProcessLockError;
 #[cfg(feature = "e2e-encryption")]
 use matrix_sdk_crypto::{CryptoStoreError, MegolmError, OlmError};
 use thiserror::Error;
@@ -51,7 +51,7 @@ pub enum Error {
 
     /// An error happened while attempting to lock the event cache store.
     #[error(transparent)]
-    EventCacheLock(#[from] LockStoreError),
+    EventCacheLock(#[from] CrossProcessLockError),
 
     /// An error occurred in the crypto store.
     #[cfg(feature = "e2e-encryption")]

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

@@ -28,7 +28,7 @@ mod memory_store;
 mod traits;
 
 use matrix_sdk_common::cross_process_lock::{
-    CrossProcessLock, CrossProcessLockGuard, LockStoreError, TryLock,
+    CrossProcessLock, CrossProcessLockError, CrossProcessLockGuard, TryLock,
 };
 pub use matrix_sdk_store_encryption::Error as StoreEncryptionError;
 use ruma::{
@@ -86,7 +86,7 @@ impl EventCacheStoreLock {
     }
 
     /// Acquire a spin lock (see [`CrossProcessLock::spin_lock`]).
-    pub async fn lock(&self) -> Result<EventCacheStoreLockGuard<'_>, LockStoreError> {
+    pub async fn lock(&self) -> Result<EventCacheStoreLockGuard<'_>, CrossProcessLockError> {
         let cross_process_lock_guard = self.cross_process_lock.spin_lock(None).await?;
 
         Ok(EventCacheStoreLockGuard { cross_process_lock_guard, store: self.store.deref() })

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

@@ -32,7 +32,7 @@ use std::fmt;
 use std::{ops::Deref, sync::Arc};
 
 use matrix_sdk_common::cross_process_lock::{
-    CrossProcessLock, CrossProcessLockGuard, LockStoreError, TryLock,
+    CrossProcessLock, CrossProcessLockError, CrossProcessLockGuard, TryLock,
 };
 use matrix_sdk_store_encryption::Error as StoreEncryptionError;
 pub use traits::{DynMediaStore, IntoMediaStore, MediaStore, MediaStoreInner};
@@ -125,7 +125,7 @@ impl MediaStoreLock {
     }
 
     /// Acquire a spin lock (see [`CrossProcessLock::spin_lock`]).
-    pub async fn lock(&self) -> Result<MediaStoreLockGuard<'_>, LockStoreError> {
+    pub async fn lock(&self) -> Result<MediaStoreLockGuard<'_>, CrossProcessLockError> {
         let cross_process_lock_guard = self.cross_process_lock.spin_lock(None).await?;
 
         Ok(MediaStoreLockGuard { cross_process_lock_guard, store: self.store.deref() })

crates/matrix-sdk-common/src/cross_process_lock.rs

@@ -190,7 +190,9 @@ where
 
     /// Try to lock once, returns whether the lock was obtained or not.
     #[instrument(skip(self), fields(?self.lock_key, ?self.lock_holder))]
-    pub async fn try_lock_once(&self) -> Result<Option<CrossProcessLockGuard>, LockStoreError> {
+    pub async fn try_lock_once(
+        &self,
+    ) -> Result<Option<CrossProcessLockGuard>, CrossProcessLockError> {
         // Hold onto the locking attempt mutex for the entire lifetime of this
         // function, to avoid multiple reentrant calls.
         let mut _attempt = self.locking_attempt.lock().await;
@@ -212,7 +214,7 @@ where
             .locker
             .try_lock(LEASE_DURATION_MS, &self.lock_key, &self.lock_holder)
             .await
-            .map_err(|err| LockStoreError::BackingStoreError(Box::new(err)))?;
+            .map_err(|err| CrossProcessLockError::TryLockError(Box::new(err)))?;
 
         if !acquired {
             trace!("Couldn't acquire the lock immediately.");
@@ -302,7 +304,7 @@ where
     pub async fn spin_lock(
         &self,
         max_backoff: Option<u32>,
-    ) -> Result<CrossProcessLockGuard, LockStoreError> {
+    ) -> Result<CrossProcessLockGuard, CrossProcessLockError> {
         let max_backoff = max_backoff.unwrap_or(MAX_BACKOFF_MS);
 
         // Note: reads/writes to the backoff are racy across threads in theory, but the
@@ -330,7 +332,7 @@ where
                 }
                 WaitingTime::Stop => {
                     // We've reached the maximum backoff, abandon.
-                    return Err(LockStoreError::LockTimeout);
+                    return Err(CrossProcessLockError::LockTimeout);
                 }
             };
 
@@ -348,18 +350,18 @@ where
 
 /// Error related to the locking API of the store.
 #[derive(Debug, thiserror::Error)]
-pub enum LockStoreError {
+pub enum CrossProcessLockError {
     /// Spent too long waiting for a database lock.
     #[error("a lock timed out")]
     LockTimeout,
 
     #[error(transparent)]
     #[cfg(not(target_family = "wasm"))]
-    BackingStoreError(#[from] Box<dyn Error + Send + Sync>),
+    TryLockError(#[from] Box<dyn Error + Send + Sync>),
 
     #[error(transparent)]
     #[cfg(target_family = "wasm")]
-    BackingStoreError(Box<dyn Error>),
+    TryLockError(Box<dyn Error>),
 }
 
 #[cfg(test)]
@@ -379,8 +381,8 @@ mod tests {
     };
 
     use super::{
-        CrossProcessLock, CrossProcessLockGuard, EXTEND_LEASE_EVERY_MS, LockStoreError, TryLock,
-        memory_store_helper::try_take_leased_lock,
+        CrossProcessLock, CrossProcessLockError, CrossProcessLockGuard, EXTEND_LEASE_EVERY_MS,
+        TryLock, memory_store_helper::try_take_leased_lock,
     };
 
     #[derive(Clone, Default)]
@@ -416,7 +418,7 @@ mod tests {
         sleep(Duration::from_millis(EXTEND_LEASE_EVERY_MS)).await;
     }
 
-    type TestResult = Result<(), LockStoreError>;
+    type TestResult = Result<(), CrossProcessLockError>;
 
     #[async_test]
     async fn test_simple_lock_unlock() -> TestResult {
@@ -518,7 +520,7 @@ mod tests {
             .expect("lock was obtained after spin-locking");
 
         // Now if lock1 tries to get the lock with a small timeout, it will fail.
-        assert_matches!(lock1.spin_lock(Some(200)).await, Err(LockStoreError::LockTimeout));
+        assert_matches!(lock1.spin_lock(Some(200)).await, Err(CrossProcessLockError::LockTimeout));
 
         Ok(())
     }

crates/matrix-sdk/src/authentication/oauth/cross_process.rs

@@ -5,7 +5,9 @@ use matrix_sdk_base::crypto::{
     store::{LockableCryptoStore, Store},
     CryptoStoreError,
 };
-use matrix_sdk_common::cross_process_lock::{CrossProcessLock, CrossProcessLockGuard, LockStoreError};
+use matrix_sdk_common::cross_process_lock::{
+    CrossProcessLock, CrossProcessLockError, CrossProcessLockGuard,
+};
 use sha2::{Digest as _, Sha256};
 use thiserror::Error;
 use tokio::sync::{Mutex, OwnedMutexGuard};
@@ -216,7 +218,7 @@ pub enum CrossProcessRefreshLockError {
 
     /// The locking itself failed.
     #[error(transparent)]
-    LockError(#[from] LockStoreError),
+    LockError(#[from] CrossProcessLockError),
 
     /// The previous hash isn't valid.
     #[error("the previous stored hash isn't a valid integer")]

crates/matrix-sdk/src/error.rs

@@ -46,8 +46,9 @@ use thiserror::Error;
 use url::ParseError as UrlParseError;
 
 use crate::{
-    authentication::oauth::OAuthError, event_cache::EventCacheError, media::MediaError,
-    room::reply::ReplyError, sliding_sync::Error as SlidingSyncError, cross_process_lock::LockStoreError,
+    authentication::oauth::OAuthError, cross_process_lock::CrossProcessLockError,
+    event_cache::EventCacheError, media::MediaError, room::reply::ReplyError,
+    sliding_sync::Error as SlidingSyncError,
 };
 
 /// Result type of the matrix-sdk.
@@ -315,7 +316,7 @@ pub enum Error {
 
     /// An error occurred with a cross-process store lock.
     #[error(transparent)]
-    CrossProcessLockError(Box<LockStoreError>),
+    CrossProcessLockError(Box<CrossProcessLockError>),
 
     /// An error occurred during a E2EE operation.
     #[cfg(feature = "e2e-encryption")]
@@ -479,8 +480,8 @@ impl From<CryptoStoreError> for Error {
     }
 }
 
-impl From<LockStoreError> for Error {
-    fn from(error: LockStoreError) -> Self {
+impl From<CrossProcessLockError> for Error {
+    fn from(error: CrossProcessLockError) -> Self {
         Error::CrossProcessLockError(Box::new(error))
     }
 }

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

@@ -37,6 +37,7 @@ use eyeball::{SharedObservable, Subscriber};
 use eyeball_im::VectorDiff;
 use futures_util::future::{join_all, try_join_all};
 use matrix_sdk_base::{
+    cross_process_lock::CrossProcessLockError,
     deserialized_responses::{AmbiguityChange, TimelineEvent},
     event_cache::{
         store::{EventCacheStoreError, EventCacheStoreLock},
@@ -45,7 +46,6 @@ use matrix_sdk_base::{
     executor::AbortOnDrop,
     linked_chunk::{self, lazy_loader::LazyLoaderError, OwnedLinkedChunkId},
     serde_helpers::extract_thread_root_from_content,
-    cross_process_lock::LockStoreError,
     sync::RoomUpdates,
     timer, ThreadingSupport,
 };
@@ -111,7 +111,7 @@ pub enum EventCacheError {
 
     /// An error happening when attempting to (cross-process) lock storage.
     #[error(transparent)]
-    LockingStorage(#[from] LockStoreError),
+    LockingStorage(#[from] CrossProcessLockError),
 
     /// The [`EventCache`] owns a weak reference to the [`Client`] it pertains
     /// to. It's possible this weak reference points to nothing anymore, at

crates/matrix-sdk/src/send_queue/mod.rs

@@ -141,14 +141,14 @@ use eyeball::SharedObservable;
 #[cfg(feature = "unstable-msc4274")]
 use matrix_sdk_base::store::FinishGalleryItemInfo;
 use matrix_sdk_base::{
+    cross_process_lock::CrossProcessLockError,
     event_cache::store::EventCacheStoreError,
     media::{store::MediaStoreError, MediaRequestParameters},
     store::{
         ChildTransactionId, DependentQueuedRequest, DependentQueuedRequestKind, DynStateStore,
         FinishUploadThumbnailInfo, QueueWedgeError, QueuedRequest, QueuedRequestKind,
         SentMediaInfo, SentRequestKey, SerializableEventContent,
     },
-    cross_process_lock::LockStoreError,
     RoomState, StoreError,
 };
 use matrix_sdk_common::{
@@ -2354,7 +2354,7 @@ pub enum RoomSendQueueStorageError {
 
     /// Error caused when attempting to get a handle on the event cache store.
     #[error(transparent)]
-    LockError(#[from] LockStoreError),
+    LockError(#[from] CrossProcessLockError),
 
     /// Error caused when (de)serializing into/from json.
     #[error(transparent)]