feat(send_queue): send redactions via the send queue

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

@@ -117,6 +117,14 @@ pub enum QueuedRequestKind {
         #[serde(default)]
         accumulated: Vec<AccumulatedSentMediaInfo>,
     },
+
+    /// A redaction of another event to send.
+    Redaction {
+        /// The ID of the event to redact.
+        redacts: OwnedEventId,
+        /// The reason for the event being redacted.
+        reason: Option<String>,
+    },
 }
 
 impl From<SerializableEventContent> for QueuedRequestKind {
@@ -421,12 +429,27 @@ pub enum SentRequestKey {
 
     /// The parent transaction returned an uploaded resource URL.
     Media(SentMediaInfo),
+
+    /// The parent transaction returned a redaction event when it succeeded.
+    Redaction {
+        /// The event ID returned by the server.
+        event_id: OwnedEventId,
+
+        /// The ID of the redacted event.
+        redacts: OwnedEventId,
+
+        /// The reason for the event being redacted.
+        reason: Option<String>,
+    },
 }
 
 impl SentRequestKey {
     /// Converts the current parent key into an event id, if possible.
     pub fn into_event_id(self) -> Option<OwnedEventId> {
-        as_variant!(self, Self::Event { event_id, .. } => event_id)
+        match self {
+            Self::Event { event_id, .. } | Self::Redaction { event_id, .. } => Some(event_id),
+            _ => None,
+        }
     }
 
     /// Converts the current parent key into information about a sent media, if

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,20 @@ impl Aggregation {
                 ApplyAggregationResult::Error(AggregationError::CantUndoPollEnd)
             }
 
-            AggregationKind::Redaction => {
-                // Redactions are not reversible.
-                ApplyAggregationResult::Error(AggregationError::CantUndoRedaction)
+            AggregationKind::Redaction { is_local } => {
+                if *is_local {
+                    if event.unredacted_content.is_some() {
+                        // 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 +497,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 +508,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 +718,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/mod.rs

@@ -1268,6 +1268,23 @@ impl<P: RoomDataProvider> TimelineController<P> {
             LocalEchoContent::React { key, send_handle, applies_to } => {
                 self.handle_local_reaction(key, send_handle, applies_to).await;
             }
+
+            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;
+                }
+            }
         }
     }
 
@@ -1308,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/event_handler.rs

@@ -834,8 +834,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(

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.
@@ -135,6 +140,7 @@ impl EventTimelineItem {
             forwarder_profile,
             timestamp,
             content,
+            unredacted_content: None,
             kind,
             is_room_encrypted,
         }
@@ -478,7 +484,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 +497,29 @@ impl EventTimelineItem {
             forwarder_profile: self.forwarder_profile.clone(),
             timestamp: self.timestamp,
             content,
+            unredacted_content: is_local.then(|| self.content.clone()),
+            kind,
+            is_room_encrypted: self.is_room_encrypted,
+        }
+    }
+
+    /// Create a clone of the current item, with content restored from the
+    /// item's unredacted_content field (if it was previously set by a call to
+    /// the `redact(...)` method).
+    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());
+}

crates/matrix-sdk/CHANGELOG.md

@@ -8,6 +8,10 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
+- Enable sending redaction events through the send queue via `RoomSendQueue::send_redaction`.
+  This includes local echoes for redaction events through the new `LocalEchoContent::Redaction`
+  variant.
+  ([#6250](https://github.com/matrix-org/matrix-rust-sdk/pull/6250))
 - The `beacon_info` start event ([MSC3672](https://github.com/matrix-org/matrix-spec-proposals/pull/3672))
   is now included when computing the latest event for a room, so live location sharing
   sessions can be surfaced as a room's most recent activity.

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

@@ -313,6 +313,11 @@ async fn handle_thread_subscriber_send_queue_update(
                     // Nothing to do, reactions don't count as a thread
                     // subscription.
                 }
+
+                LocalEchoContent::Redaction { .. } => {
+                    // Nothing to do, redactions don't count as a thread
+                    // subscription.
+                }
             }
             return true;
         }