refactor(sdk): rename a few push_action_ctx variables back into push_ctx

Author: bnjbvr

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

@@ -55,22 +55,22 @@ impl<'a> Notification<'a> {
 
     /// Push a new [`sync::Notification`] in [`Self::notifications`] from
     /// `event` if and only if `predicate` returns `true` for at least one of
-    /// the [`Action`]s associated to this event and this `push_context`
-    /// (based on `Self::push_rules`).
+    /// the [`Action`]s associated to this event and this
+    /// `push_condition_room_ctx`. (based on `Self::push_rules`).
     ///
     /// This method returns the fetched [`Action`]s.
     pub fn push_notification_from_event_if<E, P>(
         &mut self,
         room_id: &RoomId,
-        push_context: &PushConditionRoomCtx,
+        push_condition_room_ctx: &PushConditionRoomCtx,
         event: &Raw<E>,
         predicate: P,
     ) -> &[Action]
     where
         Raw<E>: Into<RawAnySyncOrStrippedTimelineEvent>,
         P: Fn(&Action) -> bool,
     {
-        let actions = self.push_rules.get_actions(event, push_context);
+        let actions = self.push_rules.get_actions(event, push_condition_room_ctx);
 
         if actions.iter().any(predicate) {
             self.push_notification(room_id, actions.to_owned(), event.clone().into());

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

@@ -179,7 +179,7 @@ pub mod stripped {
 
         // We need to check for notifications after we have handled all state
         // events, to make sure we have the full push context.
-        if let Some(push_context) =
+        if let Some(push_condition_room_ctx) =
             timeline::get_push_room_context(context, room, room_info, notification.state_store)
                 .await?
         {
@@ -189,7 +189,7 @@ pub mod stripped {
             for event in state_events.values().flat_map(|map| map.values()) {
                 notification.push_notification_from_event_if(
                     room_id,
-                    &push_context,
+                    &push_condition_room_ctx,
                     event,
                     Action::should_notify,
                 );

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

@@ -54,7 +54,7 @@ pub async fn build<'notification, 'e2ee>(
     #[cfg(feature = "e2e-encryption")] e2ee: e2ee::E2EE<'e2ee>,
 ) -> Result<Timeline> {
     let mut timeline = Timeline::new(timeline_inputs.limited, timeline_inputs.prev_batch);
-    let mut push_context =
+    let mut push_condition_room_ctx =
         get_push_room_context(context, room, room_info, notification.state_store).await?;
     let room_id = room.room_id();
 
@@ -127,18 +127,23 @@ pub async fn build<'notification, 'e2ee>(
                     AnySyncTimelineEvent::MessageLike(_) => (),
                 }
 
-                if let Some(push_context) = &mut push_context {
-                    update_push_room_context(context, push_context, room.own_user_id(), room_info)
+                if let Some(push_condition_room_ctx) = &mut push_condition_room_ctx {
+                    update_push_room_context(
+                        context,
+                        push_condition_room_ctx,
+                        room.own_user_id(),
+                        room_info,
+                    )
                 } else {
-                    push_context =
+                    push_condition_room_ctx =
                         get_push_room_context(context, room, room_info, notification.state_store)
                             .await?;
                 }
 
-                if let Some(push_context) = &push_context {
+                if let Some(push_condition_room_ctx) = &push_condition_room_ctx {
                     let actions = notification.push_notification_from_event_if(
                         room_id,
-                        push_context,
+                        push_condition_room_ctx,
                         timeline_event.raw(),
                         Action::should_notify,
                     );

crates/matrix-sdk-ui/src/notification_client.rs

@@ -188,7 +188,7 @@ impl NotificationClient {
             NotificationProcessSetup::MultipleProcesses
         ));
 
-        let push_action_ctx = room.push_context().await?;
+        let push_ctx = room.push_context().await?;
         let sync_permit_guard = match &self.process_setup {
             NotificationProcessSetup::MultipleProcesses => {
                 // We're running on our own process, dedicated for notifications. In that case,
@@ -218,9 +218,8 @@ impl NotificationClient {
 
                         sleep(Duration::from_millis(wait)).await;
 
-                        let new_event = room
-                            .decrypt_event(raw_event.cast_ref(), push_action_ctx.as_ref())
-                            .await?;
+                        let new_event =
+                            room.decrypt_event(raw_event.cast_ref(), push_ctx.as_ref()).await?;
 
                         match new_event.kind {
                             matrix_sdk::deserialized_responses::TimelineEventKind::UnableToDecrypt {
@@ -261,7 +260,7 @@ impl NotificationClient {
 
         match encryption_sync {
             Ok(sync) => match sync.run_fixed_iterations(2, sync_permit_guard).await {
-                Ok(()) => match room.decrypt_event(raw_event.cast_ref(), push_action_ctx.as_ref()).await {
+                Ok(()) => match room.decrypt_event(raw_event.cast_ref(), push_ctx.as_ref()).await {
                     Ok(new_event) => match new_event.kind {
                         matrix_sdk::deserialized_responses::TimelineEventKind::UnableToDecrypt {
                             utd_info, ..

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

@@ -255,8 +255,8 @@ async fn decrypt_by_index<D: Decryptor>(
     should_retry: impl Fn(&str) -> bool,
     retry_indices: Vec<usize>,
 ) {
-    let push_context = room_data_provider.push_context().await;
-    let push_context = push_context.as_ref();
+    let push_ctx = room_data_provider.push_context().await;
+    let push_ctx = push_ctx.as_ref();
     let unable_to_decrypt_hook = state.meta.unable_to_decrypt_hook.clone();
 
     let retry_one = |item: Arc<TimelineItem>| {
@@ -291,7 +291,7 @@ async fn decrypt_by_index<D: Decryptor>(
                 return None;
             };
 
-            match decryptor.decrypt_event_impl(original_json, push_context).await {
+            match decryptor.decrypt_event_impl(original_json, push_ctx).await {
                 Ok(event) => {
                     if let SdkTimelineEventKind::UnableToDecrypt { utd_info, .. } = event.kind {
                         info!(

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

@@ -394,15 +394,14 @@ impl RoomDataProvider for TestRoomDataProvider {
             users_default: int!(0),
             notifications: NotificationPowerLevels::new(),
         };
-        let push_context = PushConditionRoomCtx {
+        let push_condition_room_ctx = PushConditionRoomCtx {
             room_id: room_id!("!my_room:server.name").to_owned(),
             member_count: uint!(2),
             user_id: ALICE.to_owned(),
             user_display_name: "Alice".to_owned(),
             power_levels: Some(power_levels),
         };
-
-        Some(PushContext::new(push_context, push_rules))
+        Some(PushContext::new(push_condition_room_ctx, push_rules))
     }
 
     async fn load_fully_read_marker(&self) -> Option<OwnedEventId> {

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

@@ -282,17 +282,17 @@ pub(super) trait Decryptor: AsyncTraitDeps + Clone + 'static {
     fn decrypt_event_impl(
         &self,
         raw: &Raw<AnySyncTimelineEvent>,
-        push_context: Option<&PushContext>,
+        push_ctx: Option<&PushContext>,
     ) -> impl Future<Output = Result<TimelineEvent>> + SendOutsideWasm;
 }
 
 impl Decryptor for Room {
     async fn decrypt_event_impl(
         &self,
         raw: &Raw<AnySyncTimelineEvent>,
-        push_context: Option<&PushContext>,
+        push_ctx: Option<&PushContext>,
     ) -> Result<TimelineEvent> {
-        self.decrypt_event(raw.cast_ref(), push_context).await
+        self.decrypt_event(raw.cast_ref(), push_ctx).await
     }
 }
 
@@ -301,7 +301,7 @@ impl Decryptor for (matrix_sdk_base::crypto::OlmMachine, ruma::OwnedRoomId) {
     async fn decrypt_event_impl(
         &self,
         raw: &Raw<AnySyncTimelineEvent>,
-        push_context: Option<&PushContext>,
+        push_ctx: Option<&PushContext>,
     ) -> Result<TimelineEvent> {
         let (olm_machine, room_id) = self;
         let decryption_settings =
@@ -318,7 +318,7 @@ impl Decryptor for (matrix_sdk_base::crypto::OlmMachine, ruma::OwnedRoomId) {
         };
 
         // Fill the push actions here, to mimic what `Room::decrypt_event` does.
-        timeline_event.push_actions = push_context.map(|ctx| ctx.for_event(timeline_event.raw()));
+        timeline_event.push_actions = push_ctx.map(|ctx| ctx.for_event(timeline_event.raw()));
 
         Ok(timeline_event)
     }

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

@@ -360,12 +360,9 @@ impl Room {
         let request = options.into_request(room_id);
         let http_response = self.client.send(request).await?;
 
-        let push_action_ctx = self.push_context().await?;
+        let push_ctx = self.push_context().await?;
         let chunk = join_all(
-            http_response
-                .chunk
-                .into_iter()
-                .map(|ev| self.try_decrypt_event(ev, push_action_ctx.as_ref())),
+            http_response.chunk.into_iter().map(|ev| self.try_decrypt_event(ev, push_ctx.as_ref())),
         )
         .await;
 
@@ -496,8 +493,8 @@ impl Room {
             get_room_event::v3::Request::new(self.room_id().to_owned(), event_id.to_owned());
 
         let raw_event = self.client.send(request).with_request_config(request_config).await?.event;
-        let push_action_ctx = self.push_context().await?;
-        let event = self.try_decrypt_event(raw_event, push_action_ctx.as_ref()).await;
+        let push_ctx = self.push_context().await?;
+        let event = self.try_decrypt_event(raw_event, push_ctx.as_ref()).await;
 
         // Save the event into the event cache, if it's set up.
         if let Ok((cache, _handles)) = self.event_cache().await {
@@ -553,10 +550,10 @@ impl Room {
 
         let response = self.client.send(request).with_request_config(request_config).await?;
 
-        let push_action_ctx = self.push_context().await?;
-        let push_action_ctx = push_action_ctx.as_ref();
+        let push_ctx = self.push_context().await?;
+        let push_ctx = push_ctx.as_ref();
         let target_event = if let Some(event) = response.event {
-            Some(self.try_decrypt_event(event, push_action_ctx).await)
+            Some(self.try_decrypt_event(event, push_ctx).await)
         } else {
             None
         };
@@ -566,16 +563,10 @@ impl Room {
         // decryption error, so we should prevent against most bad cases here.
         let (events_before, events_after) = join!(
             join_all(
-                response
-                    .events_before
-                    .into_iter()
-                    .map(|ev| self.try_decrypt_event(ev, push_action_ctx)),
+                response.events_before.into_iter().map(|ev| self.try_decrypt_event(ev, push_ctx)),
             ),
             join_all(
-                response
-                    .events_after
-                    .into_iter()
-                    .map(|ev| self.try_decrypt_event(ev, push_action_ctx)),
+                response.events_after.into_iter().map(|ev| self.try_decrypt_event(ev, push_ctx)),
             ),
         );
 

crates/matrix-sdk/tests/integration/client.rs

@@ -770,10 +770,10 @@ async fn test_encrypt_room_event() {
     .expect("We should be able to construct a full event from the encrypted event content")
     .cast();
 
-    let push_action_ctx =
+    let push_ctx =
         room.push_context().await.expect("We should be able to get the push action context");
     let timeline_event = room
-        .decrypt_event(&event, push_action_ctx.as_ref())
+        .decrypt_event(&event, push_ctx.as_ref())
         .await
         .expect("We should be able to decrypt an event that we ourselves have encrypted");
 

testing/matrix-sdk-integration-testing/src/tests/nse.rs

@@ -425,8 +425,8 @@ async fn decrypt_event(
     event: &Raw<OriginalSyncMessageLikeEvent<RoomEncryptedEventContent>>,
 ) -> Option<(OwnedEventId, String)> {
     let room = client.get_room(room_id).unwrap();
-    let push_action_ctx = room.push_context().await.unwrap();
-    let Ok(decrypted) = room.decrypt_event(event, push_action_ctx.as_ref()).await else {
+    let push_ctx = room.push_context().await.unwrap();
+    let Ok(decrypted) = room.decrypt_event(event, push_ctx.as_ref()).await else {
         return None;
     };