Merge branch 'main' into rav/history_sharing/save_key_bundle_data

Author: richvdh

.github/workflows/detect-long-path.yml

@@ -25,7 +25,7 @@ jobs:
       - uses: actions/checkout@v4
       - name: Check for changed files
         id: changed-files
-        uses: tj-actions/changed-files@9b4bb2bedb217d3ede225b6b07ebde713177cd8f # v45
+        uses: tj-actions/changed-files@c34c1c13a740b06851baff92ab9a653d93ad6ce7 # v45
       - name: Detect long path
         env:
           ALL_CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files }} # ignore the deleted files

CONTRIBUTING.md

@@ -57,6 +57,23 @@ cargo insta test
 cargo insta review
 ```
 
+### Intermittent failure policy
+
+While we strive to add test coverage for as many features as we can, it sometimes happens that the
+tests will be intermittently failing in CI (such tests are sometimes called "flaky"). This can be
+caused by race conditions of all sorts, either in the test code itself, but sometimes in the
+underlying feature being tested too, and as such, it requires some investigation, usually from the
+original author of the test.
+
+Whenever such an intermittent failure happens, we try to open an issue to track the failures,
+adding the
+[`intermittent-failure`](https://github.com/matrix-org/matrix-rust-sdk/issues?q=is%3Aissue%20state%3Aopen%20label%3Aintermittent-failure)
+label to it, and commenting with links to CI runs where the failure happened.
+
+If a test has been intermittently failing for **two weeks** or more, and no one is actively working
+on fixing it, then we might decide to mark the test as `ignored` until it is fixed, to not cause
+unrelated failures in other contributors' pull requests and pushes.
+
 ## Pull requests
 
 Ideally, a PR should have a *proper title*, with *atomic logical commits*, and

Cargo.lock

@@ -554,8 +554,10 @@ impl OlmMachine {
             }),
         )?;
 
-        let to_device_events =
-            to_device_events.into_iter().map(|event| event.json().get().to_owned()).collect();
+        let to_device_events = to_device_events
+            .into_iter()
+            .map(|event| event.to_raw().json().get().to_owned())
+            .collect();
         let room_key_infos = room_key_infos.into_iter().map(|info| info.into()).collect();
 
         Ok(SyncChangesResult { to_device_events, room_key_infos })

bindings/matrix-sdk-crypto-ffi/src/machine.rs

@@ -10,6 +10,10 @@ Additions:
 
 - Add room topic string to `StateEventContent`
 
+Breaking changes:
+
+- `contacts` has been removed from `OidcConfiguration` (it was unused since the switch to OAuth). 
+
 ## [0.11.0] - 2025-04-11
 
 Breaking changes:

bindings/matrix-sdk-ffi/CHANGELOG.md

@@ -119,8 +119,6 @@ pub struct OidcConfiguration {
     pub tos_uri: Option<String>,
     /// A URI that contains the client's privacy policy.
     pub policy_uri: Option<String>,
-    /// An array of e-mail addresses of people responsible for this client.
-    pub contacts: Option<Vec<String>>,
 
     /// Pre-configured registrations for use with homeservers that don't support
     /// dynamic client registration.

bindings/matrix-sdk-ffi/src/authentication.rs

@@ -40,6 +40,12 @@ All notable changes to this project will be documented in this file.
 - [**breaking**] `BaseClient::set_session_metadata` is renamed
   `activate`, and `BaseClient::logged_in` is renamed `is_activated`
   ([#4850](https://github.com/matrix-org/matrix-rust-sdk/pull/4850))
+- [**breaking] `DependentQueuedRequestKind::UploadFileWithThumbnail`
+  was renamed to `DependentQueuedRequestKind::UploadFileOrThumbnail`.
+  Under the `unstable-msc4274` feature, `DependentQueuedRequestKind::UploadFileOrThumbnail`
+  and `SentMediaInfo` were generalized to allow chaining multiple dependent
+  file / thumbnail uploads.
+  ([#4897](https://github.com/matrix-org/matrix-rust-sdk/pull/4897))
 
 ## [0.10.0] - 2025-02-04
 

crates/matrix-sdk-base/CHANGELOG.md

@@ -43,6 +43,9 @@ testing = [
     "matrix-sdk-crypto?/testing",
 ]
 
+# Add support for inline media galleries via msgtypes
+unstable-msc4274 = []
+
 [dependencies]
 as_variant = { workspace = true }
 assert_matches = { workspace = true, optional = true }

crates/matrix-sdk-base/Cargo.toml

@@ -533,7 +533,7 @@ impl BaseClient {
 
         let push_rules = self.get_push_rules(&global_account_data_processor).await?;
 
-        let mut new_rooms = RoomUpdates::default();
+        let mut room_updates = RoomUpdates::default();
         let mut notifications = Default::default();
 
         let mut updated_members_in_room: BTreeMap<OwnedRoomId, BTreeSet<OwnedUserId>> =
@@ -564,7 +564,7 @@ impl BaseClient {
             )
             .await?;
 
-            new_rooms.joined.insert(room_id, joined_room_update);
+            room_updates.joined.insert(room_id, joined_room_update);
         }
 
         for (room_id, left_room) in response.rooms.leave {
@@ -591,7 +591,7 @@ impl BaseClient {
             )
             .await?;
 
-            new_rooms.left.insert(room_id, left_room_update);
+            room_updates.left.insert(room_id, left_room_update);
         }
 
         for (room_id, invited_room) in response.rooms.invite {
@@ -608,7 +608,7 @@ impl BaseClient {
             )
             .await?;
 
-            new_rooms.invited.insert(room_id, invited_room_update);
+            room_updates.invited.insert(room_id, invited_room_update);
         }
 
         for (room_id, knocked_room) in response.rooms.knock {
@@ -625,7 +625,7 @@ impl BaseClient {
             )
             .await?;
 
-            new_rooms.knocked.insert(room_id, knocked_room_update);
+            room_updates.knocked.insert(room_id, knocked_room_update);
         }
 
         global_account_data_processor.apply(&mut context, &self.state_store).await;
@@ -654,12 +654,19 @@ impl BaseClient {
             .await?;
         }
 
+        let mut context = Context::default();
+
         // Now that all the rooms information have been saved, update the display name
-        // cache (which relies on information stored in the database). This will
-        // live in memory, until the next sync which will saves the room info to
-        // disk; we do this to avoid saving that would be redundant with the
-        // above. Oh well.
-        new_rooms.update_in_memory_caches(&self.state_store).await;
+        // of the updated rooms (which relies on information stored in the database).
+        processors::room::display_name::update_for_rooms(
+            &mut context,
+            &room_updates,
+            &self.state_store,
+        )
+        .await;
+
+        // Save the new display name updates if any.
+        processors::changes::save_only(context, &self.state_store).await?;
 
         for (room_id, member_ids) in updated_members_in_room {
             if let Some(room) = self.get_room(&room_id) {
@@ -673,7 +680,7 @@ impl BaseClient {
         }
 
         let response = SyncResponse {
-            rooms: new_rooms,
+            rooms: room_updates,
             presence: response.presence.events,
             account_data: response.account_data.events,
             to_device,
@@ -1325,7 +1332,7 @@ mod tests {
         let room = client.get_room(room_id).expect("Room not found");
         assert_eq!(room.state(), RoomState::Invited);
         assert_eq!(
-            room.compute_display_name().await.expect("fetching display name failed"),
+            room.compute_display_name().await.expect("fetching display name failed").into_inner(),
             RoomDisplayName::Calculated("Kyra".to_owned())
         );
     }

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

@@ -25,6 +25,16 @@ use crate::{
     Result,
 };
 
+/// Save the [`StateChanges`] from the [`Context`] inside the [`BaseStateStore`]
+/// only! The changes aren't applied on the in-memory rooms.
+#[instrument(skip_all)]
+pub async fn save_only(context: Context, state_store: &BaseStateStore) -> Result<()> {
+    save_changes(&context, state_store, None).await?;
+    broadcast_room_info_notable_updates(&context, state_store);
+
+    Ok(())
+}
+
 /// Save the [`StateChanges`] from the [`Context`] inside the
 /// [`BaseStateStore`], and apply them on the in-memory rooms.
 #[instrument(skip_all)]
@@ -39,28 +49,36 @@ pub async fn save_and_apply(
     let previous_ignored_user_list =
         state_store.get_account_data_event_static().await.ok().flatten();
 
+    save_changes(&context, state_store, sync_token).await?;
+    apply_changes(&context, ignore_user_list_changes, previous_ignored_user_list);
+    broadcast_room_info_notable_updates(&context, state_store);
+
+    trace!("applied changes");
+
+    Ok(())
+}
+
+async fn save_changes(
+    context: &Context,
+    state_store: &BaseStateStore,
+    sync_token: Option<String>,
+) -> Result<()> {
     state_store.save_changes(&context.state_changes).await?;
 
     if let Some(sync_token) = sync_token {
         *state_store.sync_token.write().await = Some(sync_token);
     }
-    apply_changes(context, state_store, ignore_user_list_changes, previous_ignored_user_list);
-
-    trace!("applied changes");
 
     Ok(())
 }
 
 fn apply_changes(
-    context: Context,
-    state_store: &BaseStateStore,
+    context: &Context,
     ignore_user_list_changes: &SharedObservable<Vec<String>>,
     previous_ignored_user_list: Option<Raw<IgnoredUserListEvent>>,
 ) {
-    let (state_changes, room_info_notable_updates) = context.into_parts();
-
     if let Some(event) =
-        state_changes.account_data.get(&GlobalAccountDataEventType::IgnoredUserList)
+        context.state_changes.account_data.get(&GlobalAccountDataEventType::IgnoredUserList)
     {
         match event.deserialize_as::<IgnoredUserListEvent>() {
             Ok(event) => {
@@ -93,11 +111,13 @@ fn apply_changes(
             }
         }
     }
+}
 
-    for (room_id, room_info) in &state_changes.room_infos {
+fn broadcast_room_info_notable_updates(context: &Context, state_store: &BaseStateStore) {
+    for (room_id, room_info) in &context.state_changes.room_infos {
         if let Some(room) = state_store.room(room_id) {
             let room_info_notable_update_reasons =
-                room_info_notable_updates.get(room_id).copied().unwrap_or_default();
+                context.room_info_notable_updates.get(room_id).copied().unwrap_or_default();
 
             room.set_room_info(room_info.clone(), room_info_notable_update_reasons)
         }

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

@@ -99,6 +99,15 @@ async fn process(
         let (events, room_key_updates) =
             olm_machine.receive_sync_changes(encryption_sync_changes).await?;
 
+        let events = events
+            .iter()
+            // TODO: There is loss of information here, after calling `to_raw` it is not
+            // possible to make the difference between a successfully decrypted event and a plain
+            // text event. This information needs to be propagated to top layer at some point if
+            // clients relies on custom encrypted to device events.
+            .map(|p| p.to_raw())
+            .collect();
+
         Output { decrypted_to_device_events: events, room_key_updates: Some(room_key_updates) }
     } else {
         // If we have no `OlmMachine`, just return the events that were passed in.

crates/matrix-sdk-base/src/response_processors/e2ee/to_device.rs

@@ -46,10 +46,4 @@ impl Context {
     pub fn new(state_changes: StateChanges) -> Self {
         Self { state_changes, room_info_notable_updates: Default::default() }
     }
-
-    pub fn into_parts(self) -> (StateChanges, RoomInfoNotableUpdates) {
-        let Self { state_changes, room_info_notable_updates } = self;
-
-        (state_changes, room_info_notable_updates)
-    }
 }

crates/matrix-sdk-base/src/response_processors/mod.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/notification.rs

@@ -0,0 +1,47 @@
+// Copyright 2025 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::super::Context;
+use crate::{
+    rooms::UpdatedRoomDisplayName, store::BaseStateStore, sync::RoomUpdates,
+    RoomInfoNotableUpdateReasons,
+};
+
+pub async fn update_for_rooms(
+    context: &mut Context,
+    room_updates: &RoomUpdates,
+    state_store: &BaseStateStore,
+) {
+    for room in room_updates
+        .left
+        .keys()
+        .chain(room_updates.joined.keys())
+        .chain(room_updates.invited.keys())
+        .chain(room_updates.knocked.keys())
+        .filter_map(|room_id| state_store.room(room_id))
+    {
+        // Compute the display name. If it's different, let's register the `RoomInfo` in
+        // the `StateChanges`.
+        if let Ok(UpdatedRoomDisplayName::New(_)) = room.compute_display_name().await {
+            let room_id = room.room_id().to_owned();
+
+            context.state_changes.room_infos.insert(room_id.clone(), room.clone_info());
+            context
+                .room_info_notable_updates
+                .entry(room_id)
+                .or_default()
+                .insert(RoomInfoNotableUpdateReasons::DISPLAY_NAME);
+        }
+    }
+}

crates/matrix-sdk-base/src/response_processors/room/display_name.rs

@@ -17,6 +17,7 @@ use tokio::sync::broadcast::Sender;
 
 use crate::{store::ambiguity_map::AmbiguityCache, RequestedRequiredStates, RoomInfoNotableUpdate};
 
+pub mod display_name;
 pub mod msc4186;
 pub mod sync_v2;
 

crates/matrix-sdk-base/src/response_processors/room/mod.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,
                 );