refactor: Adapt to addition of additional_creators in RoomCreateEventContent

Author: zecakeh

bindings/matrix-sdk-ffi/src/room/room_info.rs

@@ -17,7 +17,7 @@ use crate::{
 pub struct RoomInfo {
     id: String,
     encryption_state: EncryptionState,
-    creator: Option<String>,
+    creators: Option<Vec<String>>,
     /// The room's name from the room state event if received from sync, or one
     /// that's been computed otherwise.
     display_name: Option<String>,
@@ -102,7 +102,9 @@ impl RoomInfo {
         Ok(Self {
             id: room.room_id().to_string(),
             encryption_state: room.encryption_state(),
-            creator: room.creator().as_ref().map(ToString::to_string),
+            creators: room
+                .creators()
+                .map(|creators| creators.into_iter().map(Into::into).collect()),
             display_name: room.cached_display_name().map(|name| name.to_string()),
             raw_name: room.name(),
             topic: room.topic(),

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

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use matrix_sdk_common::ROOM_VERSION_RULES_FALLBACK;
 use ruma::{
     assign,
     events::{
@@ -70,18 +71,38 @@ pub struct RoomCreateWithCreatorEventContent {
     /// This is currently only used for spaces.
     #[serde(skip_serializing_if = "Option::is_none", rename = "type")]
     pub room_type: Option<RoomType>,
+
+    /// Additional room creators, considered to have "infinite" power level, in
+    /// room versions 12 onwards.
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub additional_creators: Vec<OwnedUserId>,
 }
 
 impl RoomCreateWithCreatorEventContent {
     /// Constructs a `RoomCreateWithCreatorEventContent` with the given original
     /// content and sender.
     pub fn from_event_content(content: RoomCreateEventContent, sender: OwnedUserId) -> Self {
-        let RoomCreateEventContent { federate, room_version, predecessor, room_type, .. } = content;
-        Self { creator: sender, federate, room_version, predecessor, room_type }
+        let RoomCreateEventContent {
+            federate,
+            room_version,
+            predecessor,
+            room_type,
+            additional_creators,
+            ..
+        } = content;
+        Self {
+            creator: sender,
+            federate,
+            room_version,
+            predecessor,
+            room_type,
+            additional_creators,
+        }
     }
 
     fn into_event_content(self) -> (RoomCreateEventContent, OwnedUserId) {
-        let Self { creator, federate, room_version, predecessor, room_type } = self;
+        let Self { creator, federate, room_version, predecessor, room_type, additional_creators } =
+            self;
 
         #[allow(deprecated)]
         let content = assign!(RoomCreateEventContent::new_v11(), {
@@ -90,10 +111,25 @@ impl RoomCreateWithCreatorEventContent {
             room_version,
             predecessor,
             room_type,
+            additional_creators,
         });
 
         (content, creator)
     }
+
+    /// Get the creators of the room from this content, according to the room
+    /// version.
+    pub(crate) fn creators(&self) -> Vec<OwnedUserId> {
+        let rules = self.room_version.rules().unwrap_or(ROOM_VERSION_RULES_FALLBACK);
+
+        if rules.authorization.explicitly_privilege_room_creators {
+            std::iter::once(self.creator.clone())
+                .chain(self.additional_creators.iter().cloned())
+                .collect()
+        } else {
+            vec![self.creator.clone()]
+        }
+    }
 }
 
 /// Redacted form of [`RoomCreateWithCreatorEventContent`].

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

@@ -157,9 +157,9 @@ impl Room {
         &self.room_id
     }
 
-    /// Get a copy of the room creator.
-    pub fn creator(&self) -> Option<OwnedUserId> {
-        self.inner.read().creator().map(ToOwned::to_owned)
+    /// Get a copy of the room creators.
+    pub fn creators(&self) -> Option<Vec<OwnedUserId>> {
+        self.inner.read().creators()
     }
 
     /// Get our own user id.

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

@@ -50,7 +50,7 @@ use ruma::{
     room_version_rules::{RedactionRules, RoomVersionRules},
     serde::Raw,
     EventId, MilliSecondsSinceUnixEpoch, MxcUri, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId,
-    OwnedRoomId, OwnedUserId, RoomAliasId, RoomId, RoomVersionId, UserId,
+    OwnedRoomId, OwnedUserId, RoomAliasId, RoomId, RoomVersionId,
 };
 use serde::{Deserialize, Serialize};
 use tracing::{debug, error, field::debug, info, instrument, warn};
@@ -879,11 +879,11 @@ impl RoomInfo {
         }
     }
 
-    /// Get the creator of this room.
-    pub fn creator(&self) -> Option<&UserId> {
+    /// Get the creators of this room.
+    pub fn creators(&self) -> Option<Vec<OwnedUserId>> {
         match self.base_info.create.as_ref()? {
-            MinimalStateEvent::Original(ev) => Some(&ev.content.creator),
-            MinimalStateEvent::Redacted(ev) => Some(&ev.content.creator),
+            MinimalStateEvent::Original(ev) => Some(ev.content.creators()),
+            MinimalStateEvent::Redacted(ev) => Some(ev.content.creators()),
         }
     }
 

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

@@ -234,13 +234,10 @@ impl From<&StrippedRoomNameEvent> for MinimalStateEvent<RoomNameEventContent> {
 
 impl From<&StrippedRoomCreateEvent> for MinimalStateEvent<RoomCreateWithCreatorEventContent> {
     fn from(event: &StrippedRoomCreateEvent) -> Self {
-        let content = RoomCreateWithCreatorEventContent {
-            creator: event.sender.clone(),
-            federate: event.content.federate,
-            room_version: event.content.room_version.clone(),
-            predecessor: event.content.predecessor.clone(),
-            room_type: event.content.room_type.clone(),
-        };
+        let content = RoomCreateWithCreatorEventContent::from_event_content(
+            event.content.clone(),
+            event.sender.clone(),
+        );
         Self::Original(OriginalMinimalStateEvent { content, event_id: None })
     }
 }

crates/matrix-sdk-sqlite/src/state_store.rs

@@ -2463,15 +2463,15 @@ mod migration_tests {
 
         let room_a = room_infos.iter().find(|r| r.room_id() == room_a_id).unwrap();
         assert_eq!(room_a.name(), Some(room_a_name));
-        assert_eq!(room_a.creator(), Some(room_a_create_sender));
+        assert_eq!(room_a.creators(), Some(vec![room_a_create_sender.to_owned()]));
 
         let room_b = room_infos.iter().find(|r| r.room_id() == room_b_id).unwrap();
         assert_eq!(room_b.name(), None);
-        assert_eq!(room_b.creator(), None);
+        assert_eq!(room_b.creators(), None);
 
         let room_c = room_infos.iter().find(|r| r.room_id() == room_c_id).unwrap();
         assert_eq!(room_c.name(), None);
-        assert_eq!(room_c.creator(), Some(room_c_create_sender));
+        assert_eq!(room_c.creators(), Some(vec![room_c_create_sender.to_owned()]));
     }
 
     #[async_test]