feat(sdk): Split RoomEventCacheUpdate::SyncEvents.

This patch splits `RoomEventCacheUpdate::SyncEvents` into 2 new variants:
`AddTimelineEvents` and `AddEphemeralEvents`.

This patch takes this opportunity to update `matrix_sdk_ui::timeline`
a little bit too. `handle_sync_events` is renamed
`handle_ephemeral_events`, and the `SyncTimelineEvent` argument is
removed: it's possible to use `add_events_at` directly to handle the
`SyncTimelineEvent`s.

Author: Hywan

crates/matrix-sdk-ui/src/timeline/builder.rs

@@ -15,7 +15,11 @@
 use std::{collections::BTreeSet, sync::Arc};
 
 use futures_util::{pin_mut, StreamExt};
-use matrix_sdk::{event_cache::RoomEventCacheUpdate, executor::spawn, Room};
+use matrix_sdk::{
+    event_cache::{EventsOrigin, RoomEventCacheUpdate},
+    executor::spawn,
+    Room,
+};
 use ruma::{events::AnySyncTimelineEvent, RoomVersionId};
 use tokio::sync::{broadcast, mpsc};
 use tracing::{info, info_span, trace, warn, Instrument, Span};
@@ -27,7 +31,10 @@ use super::{
     queue::send_queued_messages,
     Error, Timeline, TimelineDropHandle, TimelineFocus,
 };
-use crate::{timeline::event_item::RemoteEventOrigin, unable_to_decrypt_hook::UtdHookManager};
+use crate::{
+    timeline::{event_item::RemoteEventOrigin, inner::TimelineEnd},
+    unable_to_decrypt_hook::UtdHookManager,
+};
 
 /// Builder that allows creating and configuring various parts of a
 /// [`Timeline`].
@@ -220,12 +227,23 @@ impl TimelineBuilder {
                             inner.clear().await;
                         }
 
-                        RoomEventCacheUpdate::SyncEvents { timeline, ephemeral } => {
-                            trace!("Received new events from sync.");
+                        RoomEventCacheUpdate::AddTimelineEvents { events, origin } => {
+                            trace!("Received new timeline events from sync.");
+
+                            inner.add_events_at(
+                                events,
+                                TimelineEnd::Back,
+                                match origin {
+                                    EventsOrigin::Sync => RemoteEventOrigin::Sync,
+                                }
+                            ).await;
+                        }
+
+                        RoomEventCacheUpdate::AddEphemeralEvents { events } => {
+                            trace!("Received new ephemeral events from sync.");
 
-                            // TODO: (bnjbvr) ephemeral should be handled by the event cache, and
-                            // we should replace this with a simple `add_events_at`.
-                            inner.handle_sync_events(timeline, ephemeral).await;
+                            // TODO: (bnjbvr) ephemeral should be handled by the event cache.
+                            inner.handle_ephemeral_events(events).await;
                         }
 
                         RoomEventCacheUpdate::UpdateMembers { ambiguity_changes } => {

crates/matrix-sdk-ui/src/timeline/inner/mod.rs

@@ -606,13 +606,12 @@ impl<P: RoomDataProvider> TimelineInner<P> {
         self.state.write().await.handle_fully_read_marker(fully_read_event_id);
     }
 
-    pub(super) async fn handle_sync_events(
+    pub(super) async fn handle_ephemeral_events(
         &self,
-        events: Vec<SyncTimelineEvent>,
-        ephemeral: Vec<Raw<AnySyncEphemeralRoomEvent>>,
+        events: Vec<Raw<AnySyncEphemeralRoomEvent>>,
     ) {
         let mut state = self.state.write().await;
-        state.handle_sync_events(events, ephemeral, &self.room_data_provider, &self.settings).await;
+        state.handle_ephemeral_events(events, &self.room_data_provider).await;
     }
 
     #[cfg(test)]

crates/matrix-sdk-ui/src/timeline/inner/state.rs

@@ -127,37 +127,28 @@ impl TimelineInnerState {
     }
 
     #[instrument(skip_all)]
-    pub(super) async fn handle_sync_events<P: RoomDataProvider>(
+    pub(super) async fn handle_ephemeral_events<P: RoomDataProvider>(
         &mut self,
-        events: Vec<SyncTimelineEvent>,
-        ephemeral: Vec<Raw<AnySyncEphemeralRoomEvent>>,
+        events: Vec<Raw<AnySyncEphemeralRoomEvent>>,
         room_data_provider: &P,
-        settings: &TimelineInnerSettings,
     ) {
+        if events.is_empty() {
+            return;
+        }
+
         let mut txn = self.transaction();
 
-        txn.add_events_at(
-            events,
-            TimelineEnd::Back,
-            RemoteEventOrigin::Sync,
-            room_data_provider,
-            settings,
-        )
-        .await;
-
-        if !ephemeral.is_empty() {
-            trace!("Handling ephemeral room events");
-            let own_user_id = room_data_provider.own_user_id();
-            for raw_event in ephemeral {
-                match raw_event.deserialize() {
-                    Ok(AnySyncEphemeralRoomEvent::Receipt(ev)) => {
-                        txn.handle_explicit_read_receipts(ev.content, own_user_id);
-                    }
-                    Ok(_) => {}
-                    Err(e) => {
-                        let event_type = raw_event.get_field::<String>("type").ok().flatten();
-                        warn!(event_type, "Failed to deserialize ephemeral event: {e}");
-                    }
+        trace!("Handling ephemeral room events");
+        let own_user_id = room_data_provider.own_user_id();
+        for raw_event in events {
+            match raw_event.deserialize() {
+                Ok(AnySyncEphemeralRoomEvent::Receipt(ev)) => {
+                    txn.handle_explicit_read_receipts(ev.content, own_user_id);
+                }
+                Ok(_) => {}
+                Err(e) => {
+                    let event_type = raw_event.get_field::<String>("type").ok().flatten();
+                    warn!(event_type, "Failed to deserialize ephemeral event: {e}");
                 }
             }
         }

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

@@ -44,7 +44,6 @@
 use std::{
     collections::BTreeMap,
     fmt::Debug,
-    result::Result as StdResult,
     sync::{Arc, OnceLock},
 };
 
@@ -60,10 +59,7 @@ use ruma::{
     OwnedEventId, OwnedRoomId, RoomId,
 };
 use tokio::sync::{
-    broadcast::{
-        error::{RecvError, SendError},
-        Receiver, Sender,
-    },
+    broadcast::{error::RecvError, Receiver, Sender},
     Mutex, RwLock, RwLockWriteGuard,
 };
 use tracing::{error, info_span, instrument, trace, warn, Instrument as _, Span};
@@ -676,7 +672,13 @@ impl RoomEventCacheInner {
         }
 
         // The ordering is important here.
-        let _ = self.sender.send(RoomEventCacheUpdate::SyncEvents { timeline, ephemeral })?;
+        let _ = self.sender.send(RoomEventCacheUpdate::AddTimelineEvents {
+            events: sync_timeline_events,
+            origin: EventsOrigin::Sync,
+        });
+        let _ = self
+            .sender
+            .send(RoomEventCacheUpdate::AddEphemeralEvents { events: sync_ephemeral_events });
         let _ = self.sender.send(RoomEventCacheUpdate::UpdateMembers { ambiguity_changes });
 
         Ok(())
@@ -721,16 +723,30 @@ pub enum RoomEventCacheUpdate {
         ambiguity_changes: BTreeMap<OwnedEventId, AmbiguityChange>,
     },
 
-    /// The room has new events.
-    SyncEvents {
+    /// The room has received new timeline events.
+    AddTimelineEvents {
         /// All the new events that have been added to the room's timeline.
-        timeline: Vec<SyncTimelineEvent>,
+        events: Vec<SyncTimelineEvent>,
+
+        /// Where the events are coming from.
+        origin: EventsOrigin,
+    },
+
+    /// The room has received new ephemeral events.
+    AddEphemeralEvents {
         /// XXX: this is temporary, until read receipts are handled in the event
         /// cache
-        ephemeral: Vec<Raw<AnySyncEphemeralRoomEvent>>,
+        events: Vec<Raw<AnySyncEphemeralRoomEvent>>,
     },
 }
 
+/// Indicate where events are coming from.
+#[derive(Debug, Clone)]
+pub enum EventsOrigin {
+    /// Events are coming from a sync.
+    Sync,
+}
+
 #[cfg(test)]
 mod tests {
     use assert_matches2::assert_matches;

crates/matrix-sdk/tests/integration/event_cache.rs

@@ -104,9 +104,9 @@ async fn test_add_initial_events() {
         .expect("should've received a room event cache update");
 
     // Which contains the event that was sent beforehand.
-    assert_let!(RoomEventCacheUpdate::SyncEvents { timeline: timeline_events, .. } = update);
-    assert_eq!(timeline_events.len(), 1);
-    assert_event_matches_msg(&timeline_events[0], "bonjour monde");
+    assert_let!(RoomEventCacheUpdate::AddTimelineEvents { events, .. } = update);
+    assert_eq!(events.len(), 1);
+    assert_event_matches_msg(&events[0], "bonjour monde");
 
     // And when I later add initial events to this room,
 
@@ -130,9 +130,9 @@ async fn test_add_initial_events() {
         .await
         .expect("timeout after receiving a sync update")
         .expect("should've received a room event cache update");
-    assert_let!(RoomEventCacheUpdate::SyncEvents { timeline: timeline_events, .. } = update);
-    assert_eq!(timeline_events.len(), 1);
-    assert_event_matches_msg(&timeline_events[0], "new choice!");
+    assert_let!(RoomEventCacheUpdate::AddTimelineEvents { events, .. } = update);
+    assert_eq!(events.len(), 1);
+    assert_event_matches_msg(&events[0], "new choice!");
 
     // That's all, folks!
     assert!(subscriber.is_empty());
@@ -233,9 +233,9 @@ async fn test_ignored_unignored() {
         .expect("timeout after receiving a sync update")
         .expect("should've received a room event cache update");
 
-    assert_let!(RoomEventCacheUpdate::SyncEvents { timeline: timeline_events, .. } = update);
-    assert_eq!(timeline_events.len(), 1);
-    assert_event_matches_msg(&timeline_events[0], "i don't like this dexter");
+    assert_let!(RoomEventCacheUpdate::AddTimelineEvents { events, .. } = update);
+    assert_eq!(events.len(), 1);
+    assert_event_matches_msg(&events[0], "i don't like this dexter");
 
     // The other room has been cleared too.
     {