refactor(base): Add methods on StateChanges to get a member or power level event

To reduce duplication.

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

Author: zecakeh

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

@@ -20,8 +20,6 @@ use std::collections::BTreeSet;
 
 #[cfg(feature = "e2e-encryption")]
 use matrix_sdk_common::deserialized_responses::TimelineEvent;
-#[cfg(feature = "e2e-encryption")]
-use ruma::events::StateEventType;
 use ruma::{
     api::client::sync::sync_events::{
         v3::{InviteState, InvitedRoom, KnockState, KnockedRoom},
@@ -441,19 +439,9 @@ pub(crate) async fn cache_latest_events(
     let mut encrypted_events =
         Vec::with_capacity(room.latest_encrypted_events.read().unwrap().capacity());
 
-    // Try to get room power levels from the current changes
-    let power_levels_from_changes = || {
-        let state_changes = changes?.state.get(room_info.room_id())?;
-        let room_power_levels_state =
-            state_changes.get(&StateEventType::RoomPowerLevels)?.values().next()?;
-        match room_power_levels_state.deserialize().ok()? {
-            AnySyncStateEvent::RoomPowerLevels(ev) => Some(ev.power_levels()),
-            _ => None,
-        }
-    };
-
-    // If we didn't get any info, try getting it from local data
-    let power_levels = match power_levels_from_changes() {
+    // Try to get room power levels from the current changes. If we didn't get any
+    // info, try getting it from local data.
+    let power_levels = match changes.and_then(|changes| changes.power_levels(room_info.room_id())) {
         Some(power_levels) => Some(power_levels),
         None => room.power_levels().await.ok(),
     };

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

@@ -17,11 +17,8 @@ use matrix_sdk_common::deserialized_responses::TimelineEvent;
 use ruma::events::SyncMessageLikeEvent;
 use ruma::{
     events::{
-        room::power_levels::{
-            RoomPowerLevelsEvent, RoomPowerLevelsEventContent, StrippedRoomPowerLevelsEvent,
-        },
-        AnyStrippedStateEvent, AnySyncMessageLikeEvent, AnySyncStateEvent, AnySyncTimelineEvent,
-        StateEventType,
+        room::power_levels::RoomPowerLevelsEventContent, AnySyncMessageLikeEvent,
+        AnySyncTimelineEvent,
     },
     push::{Action, PushConditionRoomCtx},
     UInt, UserId,
@@ -207,23 +204,13 @@ fn update_push_room_context(
     push_rules.member_count = UInt::new(room_info.active_members_count()).unwrap_or(UInt::MAX);
 
     // TODO: Use if let chain once stable
-    if let Some(AnySyncStateEvent::RoomMember(member)) =
-        context.state_changes.state.get(room_id).and_then(|events| {
-            events.get(&StateEventType::RoomMember)?.get(user_id.as_str())?.deserialize().ok()
-        })
-    {
-        push_rules.user_display_name = member
-            .as_original()
-            .and_then(|ev| ev.content.displayname.clone())
-            .unwrap_or_else(|| user_id.localpart().to_owned())
+    if let Some(member) = context.state_changes.member(room_id, user_id) {
+        push_rules.user_display_name =
+            member.content.displayname.unwrap_or_else(|| user_id.localpart().to_owned())
     }
 
-    if let Some(AnySyncStateEvent::RoomPowerLevels(event)) =
-        context.state_changes.state.get(room_id).and_then(|types| {
-            types.get(&StateEventType::RoomPowerLevels)?.get("")?.deserialize().ok()
-        })
-    {
-        push_rules.power_levels = Some(event.power_levels().into());
+    if let Some(power_levels) = context.state_changes.power_levels(room_id) {
+        push_rules.power_levels = Some(power_levels.into());
     }
 }
 
@@ -246,19 +233,7 @@ pub async fn get_push_room_context(
     let member_count = room_info.active_members_count();
 
     // TODO: Use if let chain once stable
-    let user_display_name = if let Some(AnySyncStateEvent::RoomMember(member)) =
-        context.state_changes.state.get(room_id).and_then(|events| {
-            events.get(&StateEventType::RoomMember)?.get(user_id.as_str())?.deserialize().ok()
-        }) {
-        member
-            .as_original()
-            .and_then(|ev| ev.content.displayname.clone())
-            .unwrap_or_else(|| user_id.localpart().to_owned())
-    } else if let Some(AnyStrippedStateEvent::RoomMember(member)) =
-        context.state_changes.stripped_state.get(room_id).and_then(|events| {
-            events.get(&StateEventType::RoomMember)?.get(user_id.as_str())?.deserialize().ok()
-        })
-    {
+    let user_display_name = if let Some(member) = context.state_changes.member(room_id, user_id) {
         member.content.displayname.unwrap_or_else(|| user_id.localpart().to_owned())
     } else if let Some(member) = Box::pin(room.get_member(user_id)).await? {
         member.name().to_owned()
@@ -267,38 +242,21 @@ pub async fn get_push_room_context(
         return Ok(None);
     };
 
-    let power_levels = if let Some(event) =
-        context.state_changes.state.get(room_id).and_then(|types| {
-            types
-                .get(&StateEventType::RoomPowerLevels)?
-                .get("")?
-                .deserialize_as::<RoomPowerLevelsEvent>()
-                .ok()
-        }) {
-        Some(event.power_levels().into())
-    } else if let Some(event) =
-        context.state_changes.stripped_state.get(room_id).and_then(|types| {
-            types
-                .get(&StateEventType::RoomPowerLevels)?
-                .get("")?
-                .deserialize_as::<StrippedRoomPowerLevelsEvent>()
-                .ok()
-        })
-    {
-        Some(event.power_levels().into())
+    let power_levels = if let Some(power_levels) = context.state_changes.power_levels(room_id) {
+        Some(power_levels)
     } else {
         state_store
             .get_state_event_static::<RoomPowerLevelsEventContent>(room_id)
             .await?
             .and_then(|e| e.deserialize().ok())
-            .map(|event| event.power_levels().into())
+            .map(|event| event.power_levels())
     };
 
     Ok(Some(PushConditionRoomCtx {
         user_id: user_id.to_owned(),
         room_id: room_id.to_owned(),
         member_count: UInt::new(member_count).unwrap_or(UInt::MAX),
         user_display_name,
-        power_levels,
+        power_levels: power_levels.map(Into::into),
     }))
 }

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

@@ -18,17 +18,14 @@ use std::{
 };
 
 use ruma::{
-    events::{
-        room::member::{MembershipState, SyncRoomMemberEvent},
-        StateEventType,
-    },
+    events::room::member::{MembershipState, SyncRoomMemberEvent},
     OwnedEventId, OwnedRoomId, OwnedUserId, RoomId, UserId,
 };
 use tracing::{instrument, trace};
 
 use super::{DynStateStore, Result, StateChanges};
 use crate::{
-    deserialized_responses::{AmbiguityChange, DisplayName, RawMemberEvent},
+    deserialized_responses::{AmbiguityChange, DisplayName, SyncOrStrippedState},
     store::StateStoreExt,
 };
 
@@ -188,17 +185,13 @@ impl AmbiguityCache {
     ) -> Result<Option<String>> {
         let user_id = new_event.state_key();
 
-        let old_event = if let Some(m) = changes
-            .state
-            .get(room_id)
-            .and_then(|events| events.get(&StateEventType::RoomMember)?.get(user_id.as_str()))
-        {
-            Some(RawMemberEvent::Sync(m.clone().cast()))
+        let old_event = if let Some(member) = changes.member(room_id, user_id) {
+            Some(SyncOrStrippedState::Stripped(member))
         } else {
-            self.store.get_member_event(room_id, user_id).await?
+            self.store.get_member_event(room_id, user_id).await?.and_then(|r| r.deserialize().ok())
         };
 
-        let Some(Ok(old_event)) = old_event.map(|r| r.deserialize()) else { return Ok(None) };
+        let Some(old_event) = old_event else { return Ok(None) };
 
         if is_member_active(old_event.membership()) {
             let display_name = if let Some(d) = changes

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

@@ -21,6 +21,7 @@
 //! store.
 
 use std::{
+    borrow::Borrow,
     collections::{BTreeMap, BTreeSet, HashMap},
     fmt,
     ops::Deref,
@@ -47,13 +48,20 @@ use ruma::{
     events::{
         presence::PresenceEvent,
         receipt::ReceiptEventContent,
-        room::{member::StrippedRoomMemberEvent, redaction::SyncRoomRedactionEvent},
+        room::{
+            member::{RoomMemberEventContent, StrippedRoomMemberEvent},
+            power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
+            redaction::SyncRoomRedactionEvent,
+        },
         AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent, AnyStrippedStateEvent,
-        AnySyncStateEvent, GlobalAccountDataEventType, RoomAccountDataEventType, StateEventType,
+        AnySyncStateEvent, EmptyStateKey, GlobalAccountDataEventType, RedactContent,
+        RedactedStateEventContent, RoomAccountDataEventType, StateEventType, StaticEventContent,
+        StaticStateEventContent, StrippedStateEvent, SyncStateEvent,
     },
     serde::Raw,
     EventId, OwnedEventId, OwnedRoomId, OwnedUserId, RoomId, UserId,
 };
+use serde::de::DeserializeOwned;
 use tokio::sync::{broadcast, Mutex, RwLock};
 use tracing::warn;
 
@@ -556,6 +564,88 @@ impl StateChanges {
     pub fn add_receipts(&mut self, room_id: &RoomId, event: ReceiptEventContent) {
         self.receipts.insert(room_id.to_owned(), event);
     }
+
+    /// Get a specific state event of statically-known type with the given state
+    /// key in the given room, if it is present in the `state` map of these
+    /// `StateChanges`.
+    pub(crate) fn state_static_for_key<C, K>(
+        &self,
+        room_id: &RoomId,
+        state_key: &K,
+    ) -> Option<&Raw<SyncStateEvent<C>>>
+    where
+        C: StaticEventContent + StaticStateEventContent + RedactContent,
+        C::Redacted: RedactedStateEventContent,
+        C::StateKey: Borrow<K>,
+        K: AsRef<str> + ?Sized,
+    {
+        self.state.get(room_id)?.get(&C::TYPE.into())?.get(state_key.as_ref()).map(Raw::cast_ref)
+    }
+
+    /// Get a specific stripped state event of statically-known type with the
+    /// given state key in the given room, if it is present in the
+    /// `stripped_state` map of these `StateChanges`.
+    pub(crate) fn stripped_state_static_for_key<C, K>(
+        &self,
+        room_id: &RoomId,
+        state_key: &K,
+    ) -> Option<&Raw<StrippedStateEvent<C::PossiblyRedacted>>>
+    where
+        C: StaticEventContent + StaticStateEventContent,
+        C::StateKey: Borrow<K>,
+        K: AsRef<str> + ?Sized,
+    {
+        self.stripped_state
+            .get(room_id)?
+            .get(&C::TYPE.into())?
+            .get(state_key.as_ref())
+            .map(Raw::cast_ref)
+    }
+
+    /// Get a specific state event of statically-known type with the given state
+    /// key in the given room, if it is present in the `state` or
+    /// `stripped_state` map of these `StateChanges` and it deserializes
+    /// successfully.
+    pub(crate) fn any_state_static_for_key<C, K>(
+        &self,
+        room_id: &RoomId,
+        state_key: &K,
+    ) -> Option<StrippedStateEvent<C::PossiblyRedacted>>
+    where
+        C: StaticEventContent + StaticStateEventContent + RedactContent,
+        C::Redacted: RedactedStateEventContent,
+        C::PossiblyRedacted: DeserializeOwned,
+        C::StateKey: Borrow<K>,
+        K: AsRef<str> + ?Sized,
+    {
+        self.state_static_for_key::<C, K>(room_id, state_key)
+            .map(Raw::cast_ref)
+            .or_else(|| self.stripped_state_static_for_key::<C, K>(room_id, state_key))?
+            .deserialize()
+            .ok()
+    }
+
+    /// Get the member for the given user in the given room from an event
+    /// contained in these `StateChanges`, if any.
+    pub(crate) fn member(
+        &self,
+        room_id: &RoomId,
+        user_id: &UserId,
+    ) -> Option<StrippedRoomMemberEvent> {
+        self.any_state_static_for_key::<RoomMemberEventContent, _>(room_id, user_id)
+    }
+
+    /// Get the power levels for the given room from an event contained in these
+    /// `StateChanges`, if any.
+    pub(crate) fn power_levels(&self, room_id: &RoomId) -> Option<RoomPowerLevels> {
+        Some(
+            self.any_state_static_for_key::<RoomPowerLevelsEventContent, _>(
+                room_id,
+                &EmptyStateKey,
+            )?
+            .power_levels(),
+        )
+    }
 }
 
 /// Configuration for the various stores.