sdk: Simplify handling of bundled relations in timeline

crates/matrix-sdk/src/events.rs

@@ -1,10 +1,10 @@
 use ruma::{
     events::{
-        BundledRelations, EventContent, EventContentFromType, MessageLikeEventContent,
-        MessageLikeEventType, MessageLikeUnsigned, OriginalSyncMessageLikeEvent,
-        OriginalSyncStateEvent, PossiblyRedactedStateEventContent, RedactContent,
-        RedactedMessageLikeEventContent, RedactedStateEventContent, RedactedSyncMessageLikeEvent,
-        RedactedSyncStateEvent, StateEventContent, StateEventType, StaticStateEventContent,
+        EventContent, EventContentFromType, MessageLikeEventContent, MessageLikeEventType,
+        MessageLikeUnsigned, OriginalSyncMessageLikeEvent, OriginalSyncStateEvent,
+        PossiblyRedactedStateEventContent, RedactContent, RedactedMessageLikeEventContent,
+        RedactedStateEventContent, RedactedSyncMessageLikeEvent, RedactedSyncStateEvent,
+        StateEventContent, StateEventType, StaticStateEventContent,
     },
     serde::from_raw_json_value,
     EventId, MilliSecondsSinceUnixEpoch, TransactionId, UserId,
@@ -39,16 +39,6 @@ impl SyncTimelineEventWithoutContent {
         }
     }
 
-    pub(crate) fn relations(&self) -> &BundledRelations {
-        static DEFAULT_BUNDLED_RELATIONS: BundledRelations = BundledRelations::new();
-        match self {
-            SyncTimelineEventWithoutContent::OriginalMessageLike(ev) => &ev.unsigned.relations,
-            SyncTimelineEventWithoutContent::OriginalState(ev) => &ev.unsigned.relations,
-            SyncTimelineEventWithoutContent::RedactedMessageLike(_)
-            | SyncTimelineEventWithoutContent::RedactedState(_) => &DEFAULT_BUNDLED_RELATIONS,
-        }
-    }
-
     pub(crate) fn sender(&self) -> &UserId {
         match self {
             Self::OriginalMessageLike(ev) => &ev.sender,

crates/matrix-sdk/src/room/timeline/event_handler.rs

@@ -73,7 +73,6 @@ pub(super) struct TimelineEventMetadata {
     pub(super) sender: OwnedUserId,
     pub(super) sender_profile: Option<Profile>,
     pub(super) is_own_event: bool,
-    pub(super) relations: BundledRelations,
     pub(super) encryption_info: Option<EncryptionInfo>,
     pub(super) read_receipts: IndexMap<OwnedUserId, Receipt>,
     pub(super) is_highlighted: bool,
@@ -83,6 +82,7 @@ pub(super) struct TimelineEventMetadata {
 pub(super) enum TimelineEventKind {
     Message {
         content: AnyMessageLikeEventContent,
+        relations: BundledRelations,
     },
     RedactedMessage,
     Redaction {
@@ -147,7 +147,7 @@ impl From<AnySyncTimelineEvent> for TimelineEventKind {
                 }),
             )) => Self::Redaction { redacts, content },
             AnySyncTimelineEvent::MessageLike(ev) => match ev.original_content() {
-                Some(content) => Self::Message { content },
+                Some(content) => Self::Message { content, relations: ev.relations().to_owned() },
                 None => Self::RedactedMessage,
             },
             AnySyncTimelineEvent::State(ev) => match ev {
@@ -274,7 +274,7 @@ impl<'a> TimelineEventHandler<'a> {
         trace!("Handling event");
 
         match event_kind {
-            TimelineEventKind::Message { content } => match content {
+            TimelineEventKind::Message { content, relations } => match content {
                 AnyMessageLikeEventContent::Reaction(c) => {
                     self.handle_reaction(c);
                 }
@@ -285,7 +285,7 @@ impl<'a> TimelineEventHandler<'a> {
                     self.handle_room_message_edit(re);
                 }
                 AnyMessageLikeEventContent::RoomMessage(c) => {
-                    self.add(NewEventTimelineItem::message(c, self.meta.relations.clone()));
+                    self.add(NewEventTimelineItem::message(c, relations));
                 }
                 AnyMessageLikeEventContent::RoomEncrypted(c) => self.handle_room_encrypted(c),
                 AnyMessageLikeEventContent::Sticker(c) => {

crates/matrix-sdk/src/room/timeline/inner.rs

@@ -207,7 +207,6 @@ impl<P: RoomDataProvider> TimelineInner<P> {
             sender,
             sender_profile,
             is_own_event: true,
-            relations: Default::default(),
             // FIXME: Should we supply something here for encrypted rooms?
             encryption_info: None,
             read_receipts: Default::default(),
@@ -216,7 +215,7 @@ impl<P: RoomDataProvider> TimelineInner<P> {
         };
 
         let flow = Flow::Local { txn_id, timestamp: MilliSecondsSinceUnixEpoch::now() };
-        let kind = TimelineEventKind::Message { content };
+        let kind = TimelineEventKind::Message { content, relations: Default::default() };
 
         let mut state = self.state.lock().await;
         TimelineEventHandler::new(event_meta, flow, &mut state, self.track_read_receipts)
@@ -792,33 +791,30 @@ async fn handle_remote_event<P: RoomDataProvider>(
     room_data_provider: &P,
     track_read_receipts: bool,
 ) -> HandleEventResult {
-    let (event_id, sender, origin_server_ts, txn_id, relations, event_kind) =
-        match raw.deserialize() {
+    let (event_id, sender, origin_server_ts, txn_id, event_kind) = match raw.deserialize() {
+        Ok(event) => (
+            event.event_id().to_owned(),
+            event.sender().to_owned(),
+            event.origin_server_ts(),
+            event.transaction_id().map(ToOwned::to_owned),
+            event.into(),
+        ),
+        Err(e) => match raw.deserialize_as::<SyncTimelineEventWithoutContent>() {
             Ok(event) => (
                 event.event_id().to_owned(),
                 event.sender().to_owned(),
                 event.origin_server_ts(),
                 event.transaction_id().map(ToOwned::to_owned),
-                event.relations().to_owned(),
-                event.into(),
+                TimelineEventKind::failed_to_parse(event, e),
             ),
-            Err(e) => match raw.deserialize_as::<SyncTimelineEventWithoutContent>() {
-                Ok(event) => (
-                    event.event_id().to_owned(),
-                    event.sender().to_owned(),
-                    event.origin_server_ts(),
-                    event.transaction_id().map(ToOwned::to_owned),
-                    event.relations().to_owned(),
-                    TimelineEventKind::failed_to_parse(event, e),
-                ),
-                Err(e) => {
-                    let event_type: Option<String> = raw.get_field("type").ok().flatten();
-                    let event_id: Option<String> = raw.get_field("event_id").ok().flatten();
-                    warn!(event_type, event_id, "Failed to deserialize timeline event: {e}");
-                    return HandleEventResult::default();
-                }
-            },
-        };
+            Err(e) => {
+                let event_type: Option<String> = raw.get_field("type").ok().flatten();
+                let event_id: Option<String> = raw.get_field("event_id").ok().flatten();
+                warn!(event_type, event_id, "Failed to deserialize timeline event: {e}");
+                return HandleEventResult::default();
+            }
+        },
+    };
 
     let is_own_event = sender == room_data_provider.own_user_id();
     let sender_profile = room_data_provider.profile(&sender).await;
@@ -832,7 +828,6 @@ async fn handle_remote_event<P: RoomDataProvider>(
         sender,
         sender_profile,
         is_own_event,
-        relations,
         encryption_info,
         read_receipts,
         is_highlighted,