refactor(timeline): make use of PushContext in the RoomDataProvider trait

Author: bnjbvr

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

@@ -255,7 +255,7 @@ async fn decrypt_by_index<D: Decryptor>(
     should_retry: impl Fn(&str) -> bool,
     retry_indices: Vec<usize>,
 ) {
-    let push_rules_context = room_data_provider.push_rules_and_context().await;
+    let push_context = room_data_provider.push_context().await;
     let unable_to_decrypt_hook = state.meta.unable_to_decrypt_hook.clone();
 
     let retry_one = |item: Arc<TimelineItem>| {
@@ -324,7 +324,7 @@ async fn decrypt_by_index<D: Decryptor>(
         .retry_event_decryption(
             retry_one,
             retry_indices,
-            push_rules_context,
+            push_context,
             room_data_provider,
             settings,
         )

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

@@ -1500,7 +1500,7 @@ impl TimelineController {
 
     #[instrument(skip(self), fields(room_id = ?self.room().room_id()))]
     pub(super) async fn retry_event_decryption(&self, session_ids: Option<BTreeSet<String>>) {
-        self.retry_event_decryption_inner(self.room().to_owned(), session_ids).await
+        self.retry_event_decryption_inner(self.room().clone(), session_ids).await
     }
 }
 

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

@@ -15,7 +15,9 @@
 use std::{future::Future, sync::Arc};
 
 use eyeball_im::VectorDiff;
-use matrix_sdk::{deserialized_responses::TimelineEvent, send_queue::SendHandle};
+use matrix_sdk::{
+    deserialized_responses::TimelineEvent, room::PushContext, send_queue::SendHandle,
+};
 #[cfg(test)]
 use ruma::events::receipt::ReceiptEventContent;
 use ruma::{
@@ -178,7 +180,7 @@ impl TimelineState {
         &mut self,
         retry_one: impl Fn(Arc<TimelineItem>) -> Fut,
         retry_indices: Vec<usize>,
-        push_rules_context: Option<(ruma::push::Ruleset, ruma::push::PushConditionRoomCtx)>,
+        push_context: Option<PushContext>,
         room_data_provider: &P,
         settings: &TimelineSettings,
     ) where
@@ -199,9 +201,7 @@ impl TimelineState {
                 continue;
             };
 
-            event.push_actions = push_rules_context.as_ref().map(|(push_rules, push_context)| {
-                push_rules.get_actions(event.raw(), push_context).to_owned()
-            });
+            event.push_actions = push_context.as_ref().map(|ctx| ctx.for_event(event.raw()));
 
             let handle_one_res = txn
                 .handle_remote_event(

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

@@ -31,7 +31,7 @@ use matrix_sdk::{
     crypto::OlmMachine,
     deserialized_responses::{EncryptionInfo, TimelineEvent},
     event_cache::paginator::{PaginableRoom, PaginatorError},
-    room::{EventWithContextResponse, Messages, MessagesOptions},
+    room::{EventWithContextResponse, Messages, MessagesOptions, PushContext},
     send_queue::RoomSendQueueUpdate,
     BoxFuture,
 };
@@ -387,7 +387,7 @@ impl RoomDataProvider for TestRoomDataProvider {
         map
     }
 
-    async fn push_rules_and_context(&self) -> Option<(Ruleset, PushConditionRoomCtx)> {
+    async fn push_context(&self) -> Option<PushContext> {
         let push_rules = Ruleset::server_default(&ALICE);
         let power_levels = PushConditionPowerLevelsCtx {
             users: BTreeMap::new(),
@@ -402,7 +402,7 @@ impl RoomDataProvider for TestRoomDataProvider {
             power_levels: Some(power_levels),
         };
 
-        Some((push_rules, push_context))
+        Some(PushContext::new(push_context, push_rules))
     }
 
     async fn load_fully_read_marker(&self) -> Option<OwnedEventId> {

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

@@ -22,6 +22,7 @@ use matrix_sdk::{
     crypto::types::events::CryptoContextInfo,
     deserialized_responses::{EncryptionInfo, TimelineEvent},
     event_cache::paginator::PaginableRoom,
+    room::PushContext,
     AsyncTraitDeps, Result, Room, SendOutsideWasm,
 };
 use matrix_sdk_base::{latest_event::LatestEvent, RoomInfo};
@@ -31,11 +32,10 @@ use ruma::{
         receipt::{Receipt, ReceiptThread, ReceiptType},
         AnyMessageLikeEventContent, AnySyncTimelineEvent,
     },
-    push::{PushConditionRoomCtx, Ruleset},
     serde::Raw,
     EventId, OwnedEventId, OwnedTransactionId, OwnedUserId, RoomVersionId, UserId,
 };
-use tracing::{debug, error};
+use tracing::error;
 
 use super::{Profile, RedactError, TimelineBuilder};
 use crate::timeline::{self, pinned_events_loader::PinnedEventsRoom, Timeline};
@@ -104,9 +104,7 @@ pub(super) trait RoomDataProvider:
     /// Load the current fully-read event id, from storage.
     fn load_fully_read_marker(&self) -> impl Future<Output = Option<OwnedEventId>> + '_;
 
-    fn push_rules_and_context(
-        &self,
-    ) -> impl Future<Output = Option<(Ruleset, PushConditionRoomCtx)>> + SendOutsideWasm + '_;
+    fn push_context(&self) -> impl Future<Output = Option<PushContext>> + SendOutsideWasm + '_;
 
     /// Send an event to that room.
     fn send(
@@ -224,24 +222,8 @@ impl RoomDataProvider for Room {
         unthreaded_receipts
     }
 
-    async fn push_rules_and_context(&self) -> Option<(Ruleset, PushConditionRoomCtx)> {
-        match self.push_condition_room_ctx().await {
-            Ok(Some(push_context)) => match self.client().account().push_rules().await {
-                Ok(push_rules) => Some((push_rules, push_context)),
-                Err(e) => {
-                    error!("Could not get push rules: {e}");
-                    None
-                }
-            },
-            Ok(None) => {
-                debug!("Could not aggregate push context");
-                None
-            }
-            Err(e) => {
-                error!("Could not get push context: {e}");
-                None
-            }
-        }
+    async fn push_context(&self) -> Option<PushContext> {
+        self.push_context().await.ok().flatten()
     }
 
     async fn load_fully_read_marker(&self) -> Option<OwnedEventId> {

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

@@ -204,6 +204,11 @@ pub struct PushContext {
 }
 
 impl PushContext {
+    /// Create a new [`PushContext`] from its inner components.
+    pub fn new(push_condition_room_ctx: PushConditionRoomCtx, push_rules: Ruleset) -> Self {
+        Self { push_condition_room_ctx, push_rules }
+    }
+
     /// Compute the push rules for a given event.
     pub fn for_event<T>(&self, event: &Raw<T>) -> Vec<Action> {
         self.push_rules.get_actions(event, &self.push_condition_room_ctx).to_owned()
@@ -2945,7 +2950,7 @@ impl Room {
             return Ok(None);
         };
         let push_rules = self.client().account().push_rules().await?;
-        Ok(Some(PushContext { push_condition_room_ctx, push_rules }))
+        Ok(Some(PushContext::new(push_condition_room_ctx, push_rules)))
     }
 
     /// Get the push actions for the given event with the current room state.