feat(timeline): handle local echoes of redactions

Signed-off-by: Johannes Marbach <n0-0ne+github@mailbox.org>

Author: Johennes

crates/matrix-sdk-ui/CHANGELOG.md

@@ -8,6 +8,8 @@ All notable changes to this project will be documented in this file.
 
 ### Bug Fixes
 
+- Handle local echoes of redactions in the timeline.
+  ([#6250](https://github.com/matrix-org/matrix-rust-sdk/pull/6250))
 - Include secondary relations when re-initializing a threaded timeline after a lag.
   ([#6209](https://github.com/matrix-org/matrix-rust-sdk/pull/6209))
 - Ensure that the display name of a `Room` in a `NotificationStatus` coming 

crates/matrix-sdk-ui/src/timeline/controller/aggregations.rs

@@ -126,7 +126,12 @@ pub(crate) enum AggregationKind {
     },
 
     /// An event has been redacted.
-    Redaction,
+    Redaction {
+        /// Whether this aggregation results from the local echo of a redaction.
+        /// Local echoes of redactions are applied reversibly whereas remote
+        /// echoes of redactions are applied irreversibly.
+        is_local: bool,
+    },
 
     /// An event has been edited.
     ///
@@ -237,11 +242,15 @@ impl Aggregation {
                 }
             }
 
-            AggregationKind::Redaction => {
-                if event.content().is_redacted() {
+            AggregationKind::Redaction { is_local } => {
+                let is_local_redacted =
+                    event.content().is_redacted() && event.unredacted_content.is_some();
+                let is_remote_redacted =
+                    event.content().is_redacted() && event.unredacted_content.is_none();
+                if *is_local && is_local_redacted || !*is_local && is_remote_redacted {
                     ApplyAggregationResult::LeftItemIntact
                 } else {
-                    let new_item = event.redact(&rules.redaction);
+                    let new_item = event.redact(&rules.redaction, *is_local);
                     *event = Cow::Owned(new_item);
                     ApplyAggregationResult::UpdatedItem
                 }
@@ -352,9 +361,21 @@ impl Aggregation {
                 ApplyAggregationResult::Error(AggregationError::CantUndoPollEnd)
             }
 
-            AggregationKind::Redaction => {
-                // Redactions are not reversible.
-                ApplyAggregationResult::Error(AggregationError::CantUndoRedaction)
+            AggregationKind::Redaction { is_local } => {
+                let is_local_redacted = event.unredacted_content.is_some();
+                if *is_local {
+                    if is_local_redacted {
+                        // Unapply local redaction.
+                        *event = Cow::Owned(event.unredact());
+                        ApplyAggregationResult::UpdatedItem
+                    } else {
+                        // Event isn't locally redacted. Nothing to do.
+                        ApplyAggregationResult::LeftItemIntact
+                    }
+                } else {
+                    // Remote redactions are not reversible.
+                    ApplyAggregationResult::Error(AggregationError::CantUndoRedaction)
+                }
             }
 
             AggregationKind::Reaction { key, sender, .. } => {
@@ -477,7 +498,7 @@ impl Aggregations {
     pub fn add(&mut self, related_to: TimelineEventItemId, aggregation: Aggregation) {
         // If the aggregation is a redaction, it invalidates all the other aggregations;
         // remove them.
-        if matches!(aggregation.kind, AggregationKind::Redaction) {
+        if matches!(aggregation.kind, AggregationKind::Redaction { .. }) {
             for agg in self.related_events.remove(&related_to).unwrap_or_default() {
                 self.inverted_map.remove(&agg.own_id);
             }
@@ -488,7 +509,7 @@ impl Aggregations {
         if let Some(previous_aggregations) = self.related_events.get(&related_to)
             && previous_aggregations
                 .iter()
-                .any(|agg| matches!(agg.kind, AggregationKind::Redaction))
+                .any(|agg| matches!(agg.kind, AggregationKind::Redaction { .. }))
         {
             return;
         }
@@ -698,7 +719,7 @@ impl Aggregations {
                 AggregationKind::PollResponse { .. }
                 | AggregationKind::PollEnd { .. }
                 | AggregationKind::Edit(..)
-                | AggregationKind::Redaction
+                | AggregationKind::Redaction { .. }
                 | AggregationKind::BeaconUpdate { .. }
                 | AggregationKind::BeaconStop { .. } => {
                     // Nothing particular to do.

crates/matrix-sdk-ui/src/timeline/controller/decryption_retry_task.rs

@@ -239,6 +239,7 @@ mod tests {
                 None,
                 timestamp(),
                 TimelineItemContent::MsgLike(MsgLikeContent::redacted()),
+                None,
                 event_kind,
                 true,
             )),
@@ -282,6 +283,7 @@ mod tests {
                         UtdCause::Unknown,
                     ),
                 )),
+                None,
                 event_kind,
                 true,
             )),
@@ -329,6 +331,7 @@ mod tests {
                     None,
                     None,
                 ),
+                None,
                 event_kind,
                 true,
             )),

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

@@ -1269,8 +1269,21 @@ impl<P: RoomDataProvider> TimelineController<P> {
                 self.handle_local_reaction(key, send_handle, applies_to).await;
             }
 
-            LocalEchoContent::Redaction { .. } => {
-                // TODO: Handle local redactions in the timeline.
+            LocalEchoContent::Redaction { redacts, send_error, .. } => {
+                self.handle_local_redaction(echo.transaction_id.clone(), redacts).await;
+
+                if let Some(send_error) = send_error {
+                    self.update_event_send_state(
+                        &echo.transaction_id,
+                        EventSendState::SendingFailed {
+                            error: Arc::new(matrix_sdk::Error::SendQueueWedgeError(Box::new(
+                                send_error,
+                            ))),
+                            is_recoverable: false,
+                        },
+                    )
+                    .await;
+                }
             }
         }
     }
@@ -1312,6 +1325,34 @@ impl<P: RoomDataProvider> TimelineController<P> {
         tr.commit();
     }
 
+    /// Applies a local echo of a redaction.
+    pub(super) async fn handle_local_redaction(
+        &self,
+        txn_id: OwnedTransactionId,
+        redacts: OwnedEventId,
+    ) {
+        let mut state = self.state.write().await;
+        let mut tr = state.transaction();
+
+        let target = TimelineEventItemId::EventId(redacts);
+
+        let aggregation = Aggregation::new(
+            TimelineEventItemId::TransactionId(txn_id),
+            AggregationKind::Redaction { is_local: true },
+        );
+
+        tr.meta.aggregations.add(target.clone(), aggregation.clone());
+        find_item_and_apply_aggregation(
+            &tr.meta.aggregations,
+            &mut tr.items,
+            &target,
+            aggregation,
+            &tr.meta.room_version_rules,
+        );
+
+        tr.commit();
+    }
+
     /// Handle a single room send queue update.
     pub(crate) async fn handle_room_send_queue_update(&self, update: RoomSendQueueUpdate) {
         match update {

crates/matrix-sdk-ui/src/timeline/controller/observable_items.rs

@@ -748,6 +748,7 @@ mod observable_items_tests {
                     in_reply_to: None,
                     thread_summary: None,
                 }),
+                None,
                 EventTimelineItemKind::Remote(RemoteEventTimelineItem {
                     event_id: event_id.parse().unwrap(),
                     transaction_id: None,
@@ -784,6 +785,7 @@ mod observable_items_tests {
                     in_reply_to: None,
                     thread_summary: None,
                 }),
+                None,
                 EventTimelineItemKind::Local(LocalEventTimelineItem {
                     send_state: EventSendState::NotSentYet { progress: None },
                     transaction_id: transaction_id.into(),

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

@@ -687,6 +687,7 @@ mod tests {
             None,
             timestamp,
             TimelineItemContent::MsgLike(MsgLikeContent::redacted()),
+            None,
             event_kind,
             false,
         )

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

@@ -830,8 +830,12 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
         }
 
         let target = TimelineEventItemId::EventId(redacted.clone());
-        let aggregation =
-            Aggregation::new(self.ctx.flow.timeline_item_id(), AggregationKind::Redaction);
+        let aggregation = Aggregation::new(
+            self.ctx.flow.timeline_item_id(),
+            AggregationKind::Redaction {
+                is_local: false, // We can only get here for remote echoes of redactions.
+            },
+        );
         self.meta.aggregations.add(target.clone(), aggregation.clone());
 
         find_item_and_apply_aggregation(
@@ -951,6 +955,7 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
             forwarder_profile,
             timestamp,
             content,
+            None,
             kind,
             is_room_encrypted,
         );

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

@@ -78,8 +78,13 @@ pub struct EventTimelineItem {
     pub(super) forwarder_profile: Option<TimelineDetails<Profile>>,
     /// The timestamp of the event.
     pub(super) timestamp: MilliSecondsSinceUnixEpoch,
-    /// The content of the event.
+    /// The content of the event. Might be redacted if a redaction for this
+    /// event is currently being sent or has been received from the server.
     pub(super) content: TimelineItemContent,
+    /// If a redaction for this event is currently being sent but the server
+    /// hasn't yet acknowledged it via its remote echo, the original content
+    /// before redaction. Otherwise, None.
+    pub(super) unredacted_content: Option<TimelineItemContent>,
     /// The kind of event timeline item, local or remote.
     pub(super) kind: EventTimelineItemKind,
     /// Whether or not the event belongs to an encrypted room.
@@ -125,6 +130,7 @@ impl EventTimelineItem {
         forwarder_profile: Option<TimelineDetails<Profile>>,
         timestamp: MilliSecondsSinceUnixEpoch,
         content: TimelineItemContent,
+        unredacted_content: Option<TimelineItemContent>,
         kind: EventTimelineItemKind,
         is_room_encrypted: bool,
     ) -> Self {
@@ -135,6 +141,7 @@ impl EventTimelineItem {
             forwarder_profile,
             timestamp,
             content,
+            unredacted_content,
             kind,
             is_room_encrypted,
         }
@@ -478,7 +485,7 @@ impl EventTimelineItem {
     }
 
     /// Create a clone of the current item, with content that's been redacted.
-    pub(super) fn redact(&self, rules: &RedactionRules) -> Self {
+    pub(super) fn redact(&self, rules: &RedactionRules, is_local: bool) -> Self {
         let content = self.content.redact(rules);
         let kind = match &self.kind {
             EventTimelineItemKind::Local(l) => EventTimelineItemKind::Local(l.clone()),
@@ -491,6 +498,26 @@ impl EventTimelineItem {
             forwarder_profile: self.forwarder_profile.clone(),
             timestamp: self.timestamp,
             content,
+            unredacted_content: is_local.then_some(self.content.clone()),
+            kind,
+            is_room_encrypted: self.is_room_encrypted,
+        }
+    }
+
+    pub(super) fn unredact(&self) -> Self {
+        let Some(content) = &self.unredacted_content else { return self.clone() };
+        let kind = match &self.kind {
+            EventTimelineItemKind::Local(l) => EventTimelineItemKind::Local(l.clone()),
+            EventTimelineItemKind::Remote(r) => EventTimelineItemKind::Remote(r.redact()),
+        };
+        Self {
+            sender: self.sender.clone(),
+            sender_profile: self.sender_profile.clone(),
+            forwarder: self.forwarder.clone(),
+            forwarder_profile: self.forwarder_profile.clone(),
+            timestamp: self.timestamp,
+            content: content.clone(),
+            unredacted_content: None,
             kind,
             is_room_encrypted: self.is_room_encrypted,
         }

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

@@ -173,6 +173,12 @@ impl TestTimeline {
         txn_id
     }
 
+    async fn handle_local_redaction(&self, redacts: OwnedEventId) -> OwnedTransactionId {
+        let txn_id = TransactionId::new();
+        self.controller.handle_local_redaction(txn_id.clone(), redacts).await;
+        txn_id
+    }
+
     async fn handle_back_paginated_event(&self, event: Raw<AnyTimelineEvent>) {
         let timeline_event = TimelineEvent::from_plaintext(event.cast());
         self.controller

crates/matrix-sdk-ui/src/timeline/tests/redaction.rs

@@ -23,6 +23,7 @@ use ruma::{
         StateEventContentChange, reaction::RedactedReactionEventContent,
         room::message::OriginalSyncRoomMessageEvent,
     },
+    owned_event_id,
 };
 use stream_assert::{assert_next_matches, assert_pending};
 
@@ -203,3 +204,34 @@ async fn test_reaction_redaction_timeline_filter() {
     assert_eq!(item.content().reactions().cloned().unwrap_or_default().len(), 0);
     assert_eq!(timeline.controller.items().await.len(), 2);
 }
+
+#[async_test]
+async fn test_local_and_remote_echo_of_redaction() {
+    let timeline = TestTimeline::new();
+    let mut stream = timeline.subscribe_events().await;
+
+    let f = &timeline.factory;
+
+    // Send a message.
+    let event_id = owned_event_id!("$1");
+    timeline
+        .handle_live_event(f.text_msg("Hello, world!").sender(&ALICE).event_id(&event_id))
+        .await;
+    let item = assert_next_matches!(stream, VectorDiff::PushBack { value } => value);
+    assert!(!item.content().is_redacted());
+    assert!(item.unredacted_content.is_none());
+
+    // Now redact the message. We first emit the local echo of the redaction event.
+    // The timeline event should be marked as being under redaction.
+    timeline.handle_local_redaction(event_id.clone()).await;
+    let item = assert_next_matches!(stream, VectorDiff::Set { index: 0, value } => value);
+    assert!(item.content().is_redacted());
+    assert!(item.unredacted_content.is_some());
+
+    // Then comes the remote echo of the redaction event. The timeline event should
+    // now be redacted.
+    timeline.handle_live_event(f.redaction(&event_id).sender(&ALICE)).await;
+    let item = assert_next_matches!(stream, VectorDiff::Set { index: 0, value } => value);
+    assert!(item.content().is_redacted());
+    assert!(item.unredacted_content.is_none());
+}