feat: Client::cross_process_store_locks_holder_name is used everywh…

…ere.

See the Changelog Section to get the details.

Changelog: `Client::cross_process_store_locks_holder_name` is used everywhere:
 - `StoreConfig::new()` now takes a
   `cross_process_store_locks_holder_name` argument.
 - `StoreConfig` no longer implements `Default`.
 - `BaseClient::new()` has been removed.
 - `BaseClient::clone_with_in_memory_state_store()` now takes a
   `cross_process_store_locks_holder_name` argument.
 - `BaseClient` no longer implements `Default`.
 - `EventCacheStoreLock::new()` no longer takes a `key` argument.
 - `BuilderStoreConfig` no longer has
   `cross_process_store_locks_holder_name` field for `Sqlite` and
   `IndexedDb`.

benchmarks/benches/room_bench.rs

@@ -74,7 +74,10 @@ pub fn receive_all_members_benchmark(c: &mut Criterion) {
         .block_on(sqlite_store.save_changes(&changes))
         .expect("initial filling of sqlite failed");
 
-    let base_client = BaseClient::with_store_config(StoreConfig::new().state_store(sqlite_store));
+    let base_client = BaseClient::with_store_config(
+        StoreConfig::new("cross-process-store-locks-holder-name".to_owned())
+            .state_store(sqlite_store),
+    );
 
     runtime
         .block_on(base_client.set_session_meta(

benchmarks/benches/store_bench.rs

@@ -69,7 +69,10 @@ pub fn restore_session(c: &mut Criterion) {
         b.to_async(&runtime).iter(|| async {
             let client = Client::builder()
                 .homeserver_url("https://matrix.example.com")
-                .store_config(StoreConfig::new().state_store(store.clone()))
+                .store_config(
+                    StoreConfig::new("cross-process-store-locks-holder-name".to_owned())
+                        .state_store(store.clone()),
+                )
                 .build()
                 .await
                 .expect("Can't build client");
@@ -96,7 +99,10 @@ pub fn restore_session(c: &mut Criterion) {
                 b.to_async(&runtime).iter(|| async {
                     let client = Client::builder()
                         .homeserver_url("https://matrix.example.com")
-                        .store_config(StoreConfig::new().state_store(store.clone()))
+                        .store_config(
+                            StoreConfig::new("cross-process-store-locks-holder-name".to_owned())
+                                .state_store(store.clone()),
+                        )
                         .build()
                         .await
                         .expect("Can't build client");

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

@@ -139,11 +139,6 @@ impl fmt::Debug for BaseClient {
 }
 
 impl BaseClient {
-    /// Create a new default client.
-    pub fn new() -> Self {
-        BaseClient::with_store_config(StoreConfig::default())
-    }
-
     /// Create a new client.
     ///
     /// # Arguments
@@ -173,8 +168,12 @@ impl BaseClient {
     /// Clones the current base client to use the same crypto store but a
     /// different, in-memory store config, and resets transient state.
     #[cfg(feature = "e2e-encryption")]
-    pub async fn clone_with_in_memory_state_store(&self) -> Result<Self> {
-        let config = StoreConfig::new().state_store(MemoryStore::new());
+    pub async fn clone_with_in_memory_state_store(
+        &self,
+        cross_process_store_locks_holder_name: &str,
+    ) -> Result<Self> {
+        let config = StoreConfig::new(cross_process_store_locks_holder_name.to_owned())
+            .state_store(MemoryStore::new());
         let config = config.crypto_store(self.crypto_store.clone());
 
         let copy = Self {
@@ -207,8 +206,12 @@ impl BaseClient {
     /// different, in-memory store config, and resets transient state.
     #[cfg(not(feature = "e2e-encryption"))]
     #[allow(clippy::unused_async)]
-    pub async fn clone_with_in_memory_state_store(&self) -> Result<Self> {
-        let config = StoreConfig::new().state_store(MemoryStore::new());
+    pub async fn clone_with_in_memory_state_store(
+        &self,
+        cross_process_store_locks_holder: &str,
+    ) -> Result<Self> {
+        let config = StoreConfig::new(cross_process_store_locks_holder.to_owned())
+            .state_store(MemoryStore::new());
         Ok(Self::with_store_config(config))
     }
 
@@ -1689,12 +1692,6 @@ impl BaseClient {
     }
 }
 
-impl Default for BaseClient {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 fn handle_room_member_event_for_profiles(
     room_id: &RoomId,
     event: &SyncStateEvent<RoomMemberEventContent>,
@@ -1737,8 +1734,9 @@ mod tests {
 
     use super::BaseClient;
     use crate::{
-        store::StateStoreExt, test_utils::logged_in_base_client, DisplayName, RoomState,
-        SessionMeta,
+        store::{StateStoreExt, StoreConfig},
+        test_utils::logged_in_base_client,
+        DisplayName, RoomState, SessionMeta,
     };
 
     #[async_test]
@@ -1945,7 +1943,9 @@ mod tests {
         let user_id = user_id!("@alice:example.org");
         let room_id = room_id!("!ithpyNKDtmhneaTQja:example.org");
 
-        let client = BaseClient::new();
+        let client = BaseClient::with_store_config(StoreConfig::new(
+            "cross-process-store-locks-holder-name".to_owned(),
+        ));
         client
             .set_session_meta(
                 SessionMeta { user_id: user_id.to_owned(), device_id: "FOOBAR".into() },
@@ -2003,7 +2003,9 @@ mod tests {
         let inviter_user_id = user_id!("@bob:example.org");
         let room_id = room_id!("!ithpyNKDtmhneaTQja:example.org");
 
-        let client = BaseClient::new();
+        let client = BaseClient::with_store_config(StoreConfig::new(
+            "cross-process-store-locks-holder-name".to_owned(),
+        ));
         client
             .set_session_meta(
                 SessionMeta { user_id: user_id.to_owned(), device_id: "FOOBAR".into() },
@@ -2063,7 +2065,9 @@ mod tests {
         let inviter_user_id = user_id!("@bob:example.org");
         let room_id = room_id!("!ithpyNKDtmhneaTQja:example.org");
 
-        let client = BaseClient::new();
+        let client = BaseClient::with_store_config(StoreConfig::new(
+            "cross-process-store-locks-holder-name".to_owned(),
+        ));
         client
             .set_session_meta(
                 SessionMeta { user_id: user_id.to_owned(), device_id: "FOOBAR".into() },

crates/matrix-sdk-base/src/event_cache_store/mod.rs

@@ -60,7 +60,10 @@ impl fmt::Debug for EventCacheStoreLock {
 
 impl EventCacheStoreLock {
     /// Create a new lock around the [`EventCacheStore`].
-    pub fn new<S>(store: S, key: String, holder: String) -> Self
+    ///
+    /// The `holder` argument represents the holder inside the
+    /// [`CrossProcessStoreLock::new`].
+    pub fn new<S>(store: S, holder: String) -> Self
     where
         S: IntoEventCacheStore,
     {
@@ -69,7 +72,7 @@ impl EventCacheStoreLock {
         Self {
             cross_process_lock: CrossProcessStoreLock::new(
                 LockableEventCacheStore(store.clone()),
-                key,
+                "default".to_owned(),
                 holder,
             ),
             store,

crates/matrix-sdk-base/src/rooms/normal.rs

@@ -1850,7 +1850,7 @@ mod tests {
     use crate::latest_event::LatestEvent;
     use crate::{
         rooms::RoomNotableTags,
-        store::{IntoStateStore, MemoryStore, StateChanges, StateStore},
+        store::{IntoStateStore, MemoryStore, StateChanges, StateStore, StoreConfig},
         BaseClient, DisplayName, MinimalStateEvent, OriginalMinimalStateEvent,
         RoomInfoNotableUpdateReasons, SessionMeta,
     };
@@ -2138,7 +2138,9 @@ mod tests {
     #[async_test]
     async fn test_is_favourite() {
         // Given a room,
-        let client = BaseClient::new();
+        let client = BaseClient::with_store_config(StoreConfig::new(
+            "cross-process-store-locks-holder-name".to_owned(),
+        ));
 
         client
             .set_session_meta(
@@ -2216,7 +2218,9 @@ mod tests {
     #[async_test]
     async fn test_is_low_priority() {
         // Given a room,
-        let client = BaseClient::new();
+        let client = BaseClient::with_store_config(StoreConfig::new(
+            "cross-process-store-locks-holder-name".to_owned(),
+        ));
 
         client
             .set_session_meta(
@@ -2672,7 +2676,9 @@ mod tests {
         use crate::{RoomInfoNotableUpdate, RoomInfoNotableUpdateReasons};
 
         // Given a room,
-        let client = BaseClient::new();
+        let client = BaseClient::with_store_config(StoreConfig::new(
+            "cross-process-store-locks-holder-name".to_owned(),
+        ));
 
         client
             .set_session_meta(

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

@@ -482,14 +482,16 @@ impl StateChanges {
 /// ```
 /// # use matrix_sdk_base::store::StoreConfig;
 ///
-/// let store_config = StoreConfig::new();
+/// let store_config =
+///     StoreConfig::new("cross-process-store-locks-holder-name".to_owned());
 /// ```
 #[derive(Clone)]
 pub struct StoreConfig {
     #[cfg(feature = "e2e-encryption")]
     pub(crate) crypto_store: Arc<DynCryptoStore>,
     pub(crate) state_store: Arc<DynStateStore>,
     pub(crate) event_cache_store: event_cache_store::EventCacheStoreLock,
+    cross_process_store_locks_holder_name: String,
 }
 
 #[cfg(not(tarpaulin_include))]
@@ -501,17 +503,20 @@ impl fmt::Debug for StoreConfig {
 
 impl StoreConfig {
     /// Create a new default `StoreConfig`.
+    ///
+    /// To learn more about `cross_process_store_locks_holder_name`, please read
+    /// [`CrossProcessStoreLock::new`](matrix_sdk_common::store_locks::CrossProcessStoreLock::new).
     #[must_use]
-    pub fn new() -> Self {
+    pub fn new(cross_process_store_locks_holder_name: String) -> Self {
         Self {
             #[cfg(feature = "e2e-encryption")]
             crypto_store: matrix_sdk_crypto::store::MemoryStore::new().into_crypto_store(),
             state_store: Arc::new(MemoryStore::new()),
             event_cache_store: event_cache_store::EventCacheStoreLock::new(
                 event_cache_store::MemoryStore::new(),
-                "default-key".to_owned(),
-                "matrix-sdk-base".to_owned(),
+                cross_process_store_locks_holder_name.clone(),
             ),
+            cross_process_store_locks_holder_name,
         }
     }
 
@@ -531,21 +536,14 @@ impl StoreConfig {
     }
 
     /// Set a custom implementation of an `EventCacheStore`.
-    ///
-    /// The `key` and `holder` arguments represent the key and holder inside the
-    /// [`CrossProcessStoreLock::new`][matrix_sdk_common::store_locks::CrossProcessStoreLock::new].
-    pub fn event_cache_store<S>(mut self, event_cache_store: S, key: String, holder: String) -> Self
+    pub fn event_cache_store<S>(mut self, event_cache_store: S) -> Self
     where
         S: event_cache_store::IntoEventCacheStore,
     {
-        self.event_cache_store =
-            event_cache_store::EventCacheStoreLock::new(event_cache_store, key, holder);
+        self.event_cache_store = event_cache_store::EventCacheStoreLock::new(
+            event_cache_store,
+            self.cross_process_store_locks_holder_name.clone(),
+        );
         self
     }
 }
-
-impl Default for StoreConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}

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

@@ -18,12 +18,14 @@
 
 use ruma::{owned_user_id, UserId};
 
-use crate::{BaseClient, SessionMeta};
+use crate::{store::StoreConfig, BaseClient, SessionMeta};
 
 /// Create a [`BaseClient`] with the given user id, if provided, or an hardcoded
 /// one otherwise.
 pub(crate) async fn logged_in_base_client(user_id: Option<&UserId>) -> BaseClient {
-    let client = BaseClient::new();
+    let client = BaseClient::with_store_config(StoreConfig::new(
+        "cross-process-store-locks-holder-name".to_owned(),
+    ));
     let user_id =
         user_id.map(|user_id| user_id.to_owned()).unwrap_or_else(|| owned_user_id!("@u:e.uk"));
     client