chore(sdk): PinnedEventsCache::new takes a WeakRoom instead of a Room.

This patch changes `PinnedEventsCache::new` to receive a `WeakRoom`
instead of a `Room`. It then returns a `Result<Self>`, with `Err` if the
`WeakRoom` doesn't point to the `Room` anymore. Thus, this patch changes
`get_or_init` by `get_or_try_init`, but this one is unstable. So this
patch switches from `OnceLock` to `OnceCell`, which provides a stable
one. Why this change? Because in a later refactoring, providing a `Room`
is a bit annoying: all we will have is a `WeakRoom`. We could do this
work of upgrading the `WeakRoom` to a `Room`, but it seems akward as all
caches are holding a `WeakRoom` if room is necessary.

Author: Hywan

Cargo.lock

@@ -62,6 +62,7 @@ js-sys = { version = "0.3.82", default-features = false, features = ["std"] }
 mime = { version = "0.3.17", default-features = false }
 oauth2 = { version = "5.0.0", default-features = false, features = ["timing-resistant-secret-traits"] }
 oauth2-reqwest = { version = "0.1.0-alpha.3", default-features = false }
+once_cell = { version = "1.21", default-features = false }
 pbkdf2 = { version = "0.12.2", default-features = false }
 pin-project-lite = { version = "0.2.16", default-features = false }
 proc-macro2 = { version = "1.0.106", default-features = false }

Cargo.toml

@@ -128,6 +128,7 @@ mime.workspace = true
 mime2ext = "0.1.54"
 oauth2.workspace = true
 oauth2-reqwest.workspace = true
+once_cell.workspace = true
 percent-encoding = "2.3.2"
 pin-project-lite.workspace = true
 rand = { workspace = true, optional = true }

crates/matrix-sdk/Cargo.toml

@@ -212,14 +212,15 @@ pub struct PinnedEventsCache {
 impl PinnedEventsCache {
     /// Creates a new [`PinnedEventsCache`] for the given room.
     pub(in super::super) fn new(
-        room: Room,
+        weak_room: &WeakRoom,
         linked_chunk_update_sender: Sender<RoomEventCacheLinkedChunkUpdate>,
         store: EventCacheStoreLock,
-    ) -> Self {
-        let sender = Sender::new(32);
-
+    ) -> Result<Self> {
+        let room = weak_room.get().ok_or(EventCacheError::ClientDropped)?;
         let room_id = room.room_id().to_owned();
 
+        let sender = Sender::new(32);
+
         let chunk = EventLinkedChunk::new();
 
         let state =
@@ -236,7 +237,7 @@ impl PinnedEventsCache {
                 .abort_on_drop(),
         );
 
-        Self { state, _task: task }
+        Ok(Self { state, _task: task })
     }
 
     /// Subscribe to live events from this room's pinned events cache.

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

@@ -162,10 +162,9 @@ impl RoomEventCache {
     pub async fn subscribe_to_pinned_events(
         &self,
     ) -> Result<(Vec<Event>, Receiver<TimelineVectorDiffs>)> {
-        let room = self.inner.weak_room.get().ok_or(EventCacheError::ClientDropped)?;
         let state = self.inner.state.read().await?;
 
-        state.subscribe_to_pinned_events(room).await
+        state.subscribe_to_pinned_events(&self.inner.weak_room).await
     }
 
     /// Create or get an event-focused timeline cache for this room.

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

@@ -15,7 +15,7 @@
 use std::{
     collections::HashMap,
     sync::{
-        Arc, OnceLock,
+        Arc,
         atomic::{AtomicUsize, Ordering},
     },
 };
@@ -36,6 +36,7 @@ use matrix_sdk_base::{
     sync::Timeline,
 };
 use matrix_sdk_common::executor::spawn;
+use once_cell::sync::OnceCell;
 use ruma::{
     EventId, OwnedEventId, OwnedRoomId, OwnedUserId,
     events::{
@@ -72,7 +73,7 @@ use super::{
     EventsOrigin, RoomEventCacheGenericUpdate, RoomEventCacheLinkedChunkUpdate,
     RoomEventCacheUpdate, RoomEventCacheUpdateSender, sort_positions_descending,
 };
-use crate::{Room, room::WeakRoom};
+use crate::room::WeakRoom;
 
 /// Key for the event-focused caches.
 #[derive(Hash, PartialEq, Eq)]
@@ -111,7 +112,7 @@ pub struct RoomEventCacheState {
     event_focused_caches: HashMap<EventFocusedCacheKey, EventFocusedCache>,
 
     /// Cache for pinned events in this room, initialized on-demand.
-    pinned_events_cache: OnceLock<PinnedEventsCache>,
+    pinned_events_cache: OnceCell<PinnedEventsCache>,
 
     pagination_status: SharedObservable<SharedPaginationStatus>,
 
@@ -260,7 +261,7 @@ impl LockedRoomEventCacheState {
             room_version_rules,
             waited_for_initial_prev_token: false,
             subscriber_count: Default::default(),
-            pinned_events_cache: OnceLock::new(),
+            pinned_events_cache: OnceCell::new(),
             automatic_pagination,
         }))
     }
@@ -373,15 +374,15 @@ impl<'a> RoomEventCacheStateLockReadGuard<'a> {
     /// This requires the room's event cache to be initialized.
     pub async fn subscribe_to_pinned_events(
         &self,
-        room: Room,
+        weak_room: &WeakRoom,
     ) -> Result<(Vec<Event>, Receiver<TimelineVectorDiffs>), EventCacheError> {
-        let pinned_events_cache = self.state.pinned_events_cache.get_or_init(|| {
+        let pinned_events_cache = self.state.pinned_events_cache.get_or_try_init(|| {
             PinnedEventsCache::new(
-                room,
+                weak_room,
                 self.state.linked_chunk_update_sender.clone(),
                 self.state.store.clone(),
             )
-        });
+        })?;
 
         pinned_events_cache.subscribe().await
     }