refactor: Adapt to use of RedactionRules for redaction

Signed-off-by: Kévin Commaille <zecakeh@tedomum.fr>

Author: zecakeh

crates/matrix-sdk-base/src/response_processors/timeline.rs

@@ -65,9 +65,9 @@ pub async fn build<'notification, 'e2ee>(
                     AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomRedaction(
                         redaction_event,
                     )) => {
-                        let room_version = room_info.room_version_or_default();
+                        let redaction_rules = room_info.room_version_rules_or_default().redaction;
 
-                        if let Some(redacts) = redaction_event.redacts(&room_version) {
+                        if let Some(redacts) = redaction_event.redacts(&redaction_rules) {
                             room_info
                                 .handle_redaction(redaction_event, timeline_event.raw().cast_ref());
 

crates/matrix-sdk-base/src/room/create.rs

@@ -20,6 +20,7 @@ use ruma::{
         EmptyStateKey, RedactContent, RedactedStateEventContent, StateEventType,
     },
     room::RoomType,
+    room_version_rules::RedactionRules,
     OwnedUserId, RoomVersionId,
 };
 use serde::{Deserialize, Serialize};
@@ -109,10 +110,10 @@ impl RedactedStateEventContent for RedactedRoomCreateWithCreatorEventContent {
 impl RedactContent for RoomCreateWithCreatorEventContent {
     type Redacted = RedactedRoomCreateWithCreatorEventContent;
 
-    fn redact(self, version: &RoomVersionId) -> Self::Redacted {
+    fn redact(self, rules: &RedactionRules) -> Self::Redacted {
         let (content, sender) = self.into_event_content();
         // Use Ruma's redaction algorithm.
-        let content = content.redact(version);
+        let content = content.redact(rules);
         Self::from_event_content(content, sender)
     }
 }

crates/matrix-sdk-base/src/room/room_info.rs

@@ -19,7 +19,9 @@ use std::{
 
 use bitflags::bitflags;
 use eyeball::Subscriber;
-use matrix_sdk_common::{deserialized_responses::TimelineEventKind, ROOM_VERSION_FALLBACK};
+use matrix_sdk_common::{
+    deserialized_responses::TimelineEventKind, ROOM_VERSION_FALLBACK, ROOM_VERSION_RULES_FALLBACK,
+};
 use ruma::{
     api::client::sync::sync_events::v3::RoomSummary as RumaSummary,
     assign,
@@ -45,6 +47,7 @@ use ruma::{
         RedactedStateEventContent, StateEventType, StaticStateEventContent, SyncStateEvent,
     },
     room::RoomType,
+    room_version_rules::{RedactionRules, RoomVersionRules},
     serde::Raw,
     EventId, MilliSecondsSinceUnixEpoch, MxcUri, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId,
     OwnedRoomId, OwnedUserId, RoomAliasId, RoomId, RoomVersionId, UserId,
@@ -322,27 +325,31 @@ impl BaseRoomInfo {
     }
 
     pub(super) fn handle_redaction(&mut self, redacts: &EventId) {
-        let room_version = self.room_version().unwrap_or(&ROOM_VERSION_FALLBACK).to_owned();
+        let redaction_rules = self
+            .room_version()
+            .and_then(|room_version| room_version.rules())
+            .unwrap_or(ROOM_VERSION_RULES_FALLBACK)
+            .redaction;
 
         // FIXME: Use let chains once available to get rid of unwrap()s
         if self.avatar.has_event_id(redacts) {
-            self.avatar.as_mut().unwrap().redact(&room_version);
+            self.avatar.as_mut().unwrap().redact(&redaction_rules);
         } else if self.canonical_alias.has_event_id(redacts) {
-            self.canonical_alias.as_mut().unwrap().redact(&room_version);
+            self.canonical_alias.as_mut().unwrap().redact(&redaction_rules);
         } else if self.create.has_event_id(redacts) {
-            self.create.as_mut().unwrap().redact(&room_version);
+            self.create.as_mut().unwrap().redact(&redaction_rules);
         } else if self.guest_access.has_event_id(redacts) {
-            self.guest_access.as_mut().unwrap().redact(&room_version);
+            self.guest_access.as_mut().unwrap().redact(&redaction_rules);
         } else if self.history_visibility.has_event_id(redacts) {
-            self.history_visibility.as_mut().unwrap().redact(&room_version);
+            self.history_visibility.as_mut().unwrap().redact(&redaction_rules);
         } else if self.join_rules.has_event_id(redacts) {
-            self.join_rules.as_mut().unwrap().redact(&room_version);
+            self.join_rules.as_mut().unwrap().redact(&redaction_rules);
         } else if self.name.has_event_id(redacts) {
-            self.name.as_mut().unwrap().redact(&room_version);
+            self.name.as_mut().unwrap().redact(&redaction_rules);
         } else if self.tombstone.has_event_id(redacts) {
-            self.tombstone.as_mut().unwrap().redact(&room_version);
+            self.tombstone.as_mut().unwrap().redact(&redaction_rules);
         } else if self.topic.has_event_id(redacts) {
-            self.topic.as_mut().unwrap().redact(&room_version);
+            self.topic.as_mut().unwrap().redact(&redaction_rules);
         } else {
             self.rtc_member_events
                 .retain(|_, member_event| member_event.event_id() != Some(redacts));
@@ -451,11 +458,11 @@ pub struct RoomInfo {
     /// room state.
     pub(crate) base_info: Box<BaseRoomInfo>,
 
-    /// Did we already warn about an unknown room version in
-    /// [`RoomInfo::room_version_or_default`]? This is done to avoid
-    /// spamming about unknown room versions in the log for the same room.
+    /// Whether we already warned about unknown room version rules in
+    /// [`RoomInfo::room_version_rules_or_default`]. This is done to avoid
+    /// spamming about unknown room versions rules in the log for the same room.
     #[serde(skip)]
-    pub(crate) warned_about_unknown_room_version: Arc<AtomicBool>,
+    pub(crate) warned_about_unknown_room_version_rules: Arc<AtomicBool>,
 
     /// Cached display name, useful for sync access.
     ///
@@ -502,7 +509,7 @@ impl RoomInfo {
             latest_event: None,
             read_receipts: Default::default(),
             base_info: Box::new(BaseRoomInfo::new()),
-            warned_about_unknown_room_version: Arc::new(false.into()),
+            warned_about_unknown_room_version_rules: Arc::new(false.into()),
             cached_display_name: None,
             cached_user_defined_notification_mode: None,
             recency_stamp: None,
@@ -670,9 +677,9 @@ impl RoomInfo {
         event: &SyncRoomRedactionEvent,
         _raw: &Raw<SyncRoomRedactionEvent>,
     ) {
-        let room_version = self.room_version_or_default();
+        let redaction_rules = self.room_version_rules_or_default().redaction;
 
-        let Some(redacts) = event.redacts(&room_version) else {
+        let Some(redacts) = event.redacts(&redaction_rules) else {
             info!("Can't apply redaction, redacts field is missing");
             return;
         };
@@ -681,7 +688,7 @@ impl RoomInfo {
         if let Some(latest_event) = &mut self.latest_event {
             tracing::trace!("Checking if redaction applies to latest event");
             if latest_event.event_id().as_deref() == Some(redacts) {
-                match apply_redaction(latest_event.event().raw(), _raw, &room_version) {
+                match apply_redaction(latest_event.event().raw(), _raw, &redaction_rules) {
                     Some(redacted) => {
                         // Even if the original event was encrypted, redaction removes all its
                         // fields so it cannot possibly be successfully decrypted after redaction.
@@ -842,24 +849,26 @@ impl RoomInfo {
         self.base_info.room_version()
     }
 
-    /// Get the room version of this room, or a sensible default.
+    /// Get the room version rules of this room, or a sensible default.
     ///
-    /// Will warn (at most once) if the room creation event is missing from this
-    /// [`RoomInfo`].
-    pub fn room_version_or_default(&self) -> RoomVersionId {
+    /// Will warn (at most once) if the room create event is missing from this
+    /// [`RoomInfo`] or if the room version is unsupported.
+    pub fn room_version_rules_or_default(&self) -> RoomVersionRules {
         use std::sync::atomic::Ordering;
 
-        self.base_info.room_version().cloned().unwrap_or_else(|| {
-            if self
-                .warned_about_unknown_room_version
-                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-                .is_ok()
-            {
-                warn!("Unknown room version, falling back to {ROOM_VERSION_FALLBACK}");
-            }
+        self.base_info.room_version().and_then(|room_version| room_version.rules()).unwrap_or_else(
+            || {
+                if self
+                    .warned_about_unknown_room_version_rules
+                    .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+                    .is_ok()
+                {
+                    warn!("Unable to get the room version rules, defaulting to rules for room version {ROOM_VERSION_FALLBACK}");
+                }
 
-            ROOM_VERSION_FALLBACK
-        })
+                ROOM_VERSION_RULES_FALLBACK
+            },
+        )
     }
 
     /// Get the room type of this room.
@@ -1109,7 +1118,7 @@ pub(crate) enum SyncInfo {
 pub fn apply_redaction(
     event: &Raw<AnySyncTimelineEvent>,
     raw_redaction: &Raw<SyncRoomRedactionEvent>,
-    room_version: &RoomVersionId,
+    rules: &RedactionRules,
 ) -> Option<Raw<AnySyncTimelineEvent>> {
     use ruma::canonical_json::{redact_in_place, RedactedBecause};
 
@@ -1129,7 +1138,7 @@ pub fn apply_redaction(
         }
     };
 
-    let redact_result = redact_in_place(&mut event_json, room_version, Some(redacted_because));
+    let redact_result = redact_in_place(&mut event_json, rules, Some(redacted_because));
 
     if let Err(e) = redact_result {
         warn!("Failed to redact event: {e}");
@@ -1259,7 +1268,7 @@ mod tests {
                 assign!(BaseRoomInfo::new(), { pinned_events: Some(RoomPinnedEventsEventContent::new(vec![owned_event_id!("$a")])) }),
             ),
             read_receipts: Default::default(),
-            warned_about_unknown_room_version: Arc::new(false.into()),
+            warned_about_unknown_room_version_rules: Arc::new(false.into()),
             cached_display_name: None,
             cached_user_defined_notification_mode: None,
             recency_stamp: Some(42),

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

@@ -19,7 +19,7 @@ use std::{
 
 use async_trait::async_trait;
 use growable_bloom_filter::GrowableBloom;
-use matrix_sdk_common::ROOM_VERSION_FALLBACK;
+use matrix_sdk_common::{ROOM_VERSION_FALLBACK, ROOM_VERSION_RULES_FALLBACK};
 use ruma::{
     canonical_json::{redact, RedactedBecause},
     events::{
@@ -439,19 +439,19 @@ impl StateStore for MemoryStore {
             }
         }
 
-        let make_room_version = |room_info: &HashMap<OwnedRoomId, RoomInfo>, room_id| {
-            room_info.get(room_id).map(|info| info.room_version_or_default()).unwrap_or_else(|| {
+        let make_redaction_rules = |room_info: &HashMap<OwnedRoomId, RoomInfo>, room_id| {
+            room_info.get(room_id).map(|info| info.room_version_rules_or_default()).unwrap_or_else(|| {
                 warn!(
                     ?room_id,
-                    "Unable to find the room version, assuming {ROOM_VERSION_FALLBACK}"
+                    "Unable to get the room version rules, defaulting to rules for room version {ROOM_VERSION_FALLBACK}"
                 );
-                ROOM_VERSION_FALLBACK
-            })
+                ROOM_VERSION_RULES_FALLBACK
+            }).redaction
         };
 
         let inner = &mut *inner;
         for (room_id, redactions) in &changes.redactions {
-            let mut room_version = None;
+            let mut redaction_rules = None;
 
             if let Some(room) = inner.room_state.get_mut(room_id) {
                 for ref_room_mu in room.values_mut() {
@@ -460,8 +460,8 @@ impl StateStore for MemoryStore {
                             if let Some(redaction) = redactions.get(&event_id) {
                                 let redacted = redact(
                                     raw_evt.deserialize_as::<CanonicalJsonObject>()?,
-                                    room_version.get_or_insert_with(|| {
-                                        make_room_version(&inner.room_info, room_id)
+                                    redaction_rules.get_or_insert_with(|| {
+                                        make_redaction_rules(&inner.room_info, room_id)
                                     }),
                                     Some(RedactedBecause::from_raw_event(redaction)?),
                                 )

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

@@ -37,6 +37,7 @@ use ruma::{
         },
         EmptyStateKey, RedactContent, StateEventContent, StateEventType,
     },
+    room_version_rules::RedactionRules,
     OwnedRoomId, OwnedUserId, RoomId,
 };
 use serde::{Deserialize, Serialize};
@@ -117,7 +118,7 @@ impl RoomInfoV1 {
             latest_event: latest_event.map(|ev| Box::new(LatestEvent::new(ev))),
             read_receipts: Default::default(),
             base_info: base_info.migrate(create),
-            warned_about_unknown_room_version: Arc::new(false.into()),
+            warned_about_unknown_room_version_rules: Arc::new(false.into()),
             cached_display_name: None,
             cached_user_defined_notification_mode: None,
             recency_stamp: None,
@@ -233,7 +234,7 @@ impl StateEventContent for RoomNameEventContentV1 {
 impl RedactContent for RoomNameEventContentV1 {
     type Redacted = RedactedRoomNameEventContent;
 
-    fn redact(self, _version: &ruma::RoomVersionId) -> Self::Redacted {
+    fn redact(self, _rules: &RedactionRules) -> Self::Redacted {
         RedactedRoomNameEventContent::new()
     }
 }

crates/matrix-sdk-base/src/utils.rs

@@ -24,7 +24,8 @@ use ruma::{
         RedactContent, RedactedStateEventContent, StateEventContent, StaticStateEventContent,
         SyncStateEvent,
     },
-    EventId, OwnedEventId, RoomVersionId,
+    room_version_rules::RedactionRules,
+    EventId, OwnedEventId,
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
@@ -118,13 +119,13 @@ where
     /// Redacts this event.
     ///
     /// Does nothing if it is already redacted.
-    pub fn redact(&mut self, room_version: &RoomVersionId)
+    pub fn redact(&mut self, rules: &RedactionRules)
     where
         C: Clone,
     {
         if let MinimalStateEvent::Original(ev) = self {
             *self = MinimalStateEvent::Redacted(RedactedMinimalStateEvent {
-                content: ev.content.clone().redact(room_version),
+                content: ev.content.clone().redact(rules),
                 event_id: ev.event_id.clone(),
             });
         }

crates/matrix-sdk-common/src/lib.rs

@@ -42,7 +42,7 @@ pub mod ttl_cache;
 #[cfg(all(target_family = "wasm", not(tarpaulin_include)))]
 pub mod js_tracing;
 
-use ruma::RoomVersionId;
+use ruma::{room_version_rules::RoomVersionRules, RoomVersionId};
 pub use store_locks::LEASE_DURATION_MS;
 
 /// Alias for `Send` on non-wasm, empty trait (implemented by everything) on
@@ -108,3 +108,9 @@ uniffi::setup_scaffolding!();
 
 /// The room version to use as a fallback when the version of a room is unknown.
 pub const ROOM_VERSION_FALLBACK: RoomVersionId = RoomVersionId::V11;
+
+/// The room version rules to use as a fallback when the version of a room is
+/// unknown or unsupported.
+///
+/// These are the rules of the [`ROOM_VERSION_FALLBACK`].
+pub const ROOM_VERSION_RULES_FALLBACK: RoomVersionRules = RoomVersionRules::V11;

crates/matrix-sdk-indexeddb/src/state_store/mod.rs

@@ -30,7 +30,7 @@ use matrix_sdk_base::{
         SerializableEventContent, ServerInfo, StateChanges, StateStore, StoreError,
     },
     MinimalRoomMemberEvent, RoomInfo, RoomMemberships, StateStoreDataKey, StateStoreDataValue,
-    ROOM_VERSION_FALLBACK,
+    ROOM_VERSION_FALLBACK, ROOM_VERSION_RULES_FALLBACK,
 };
 use matrix_sdk_store_encryption::{Error as EncryptionError, StoreCipher};
 use ruma::{
@@ -917,32 +917,32 @@ impl_state_store!({
                 let range = self.encode_to_range(keys::ROOM_STATE, room_id)?;
                 let Some(cursor) = state.open_cursor_with_range(&range)?.await? else { continue };
 
-                let mut room_version = None;
+                let mut redaction_rules = None;
 
                 while let Some(key) = cursor.key() {
                     let raw_evt =
                         self.deserialize_value::<Raw<AnySyncStateEvent>>(&cursor.value())?;
                     if let Ok(Some(event_id)) = raw_evt.get_field::<OwnedEventId>("event_id") {
                         if let Some(redaction) = redactions.get(&event_id) {
-                            let version = {
-                                if room_version.is_none() {
-                                    room_version.replace(room_info
+                            let redaction_rules = {
+                                if redaction_rules.is_none() {
+                                    redaction_rules.replace(room_info
                                         .get(&self.encode_key(keys::ROOM_INFOS, room_id))?
                                         .await?
                                         .and_then(|f| self.deserialize_value::<RoomInfo>(&f).ok())
-                                        .map(|info| info.room_version_or_default())
+                                        .map(|info| info.room_version_rules_or_default())
                                         .unwrap_or_else(|| {
-                                            warn!(?room_id, "Unable to find the room version, assuming {ROOM_VERSION_FALLBACK}");
-                                            ROOM_VERSION_FALLBACK
-                                        })
+                                            warn!(?room_id, "Unable to get the room version rules, defaulting to rules for room version {ROOM_VERSION_FALLBACK}");
+                                            ROOM_VERSION_RULES_FALLBACK
+                                        }).redaction
                                     );
                                 }
-                                room_version.as_ref().unwrap()
+                                redaction_rules.as_ref().unwrap()
                             };
 
                             let redacted = redact(
                                 raw_evt.deserialize_as::<CanonicalJsonObject>()?,
-                                version,
+                                redaction_rules,
                                 Some(RedactedBecause::from_raw_event(redaction)?),
                             )
                             .map_err(StoreError::Redaction)?;