Return RoomEvents from decryption methods

Previously, these methods returned `SyncRoomEvent`s instead, even though
the decrypted events are required to contain a room_id field (in order
for the server to not to be able to change these). As a side effect,
glue code which adds a room_id to the `SyncRoomEvent` to convert it to a
`RoomEvent` is be removed in some places.

When a `SyncRoomEvent` is required (such as in code handling sync
responses), the `From` implementation of `SyncRoomEvent` can be used.

Author: ftilde

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

@@ -422,7 +422,7 @@ impl BaseClient {
                                 if let Ok(decrypted) =
                                     olm.decrypt_room_event(encrypted, room_id).await
                                 {
-                                    event = decrypted;
+                                    event = decrypted.into();
                                 }
                             }
                         }

crates/matrix-sdk-crypto/src/machine.rs

@@ -22,7 +22,7 @@ use std::{
 
 use dashmap::DashMap;
 use matrix_sdk_common::{
-    deserialized_responses::{AlgorithmInfo, EncryptionInfo, SyncRoomEvent, VerificationState},
+    deserialized_responses::{AlgorithmInfo, EncryptionInfo, RoomEvent, VerificationState},
     locks::Mutex,
     uuid::Uuid,
 };
@@ -1100,7 +1100,7 @@ impl OlmMachine {
         room_id: &RoomId,
         event: &SyncRoomEncryptedEvent,
         content: &MegolmV1AesSha2Content,
-    ) -> MegolmResult<SyncRoomEvent> {
+    ) -> MegolmResult<RoomEvent> {
         if let Some(session) = self
             .store
             .get_inbound_group_session(room_id, &content.sender_key, &content.session_id)
@@ -1120,9 +1120,8 @@ impl OlmMachine {
                         sender_key = session.sender_key(),
                         "Successfully decrypted a room event"
                     );
-                    let event = e.into_full_event(room_id.to_owned());
 
-                    if let AnyRoomEvent::Message(e) = event {
+                    if let AnyRoomEvent::Message(e) = e {
                         self.verification_machine.receive_any_event(&e).await?;
                     }
                 }
@@ -1141,7 +1140,7 @@ impl OlmMachine {
             let encryption_info =
                 self.get_encryption_info(&session, &event.sender, &content.device_id).await?;
 
-            Ok(SyncRoomEvent { encryption_info: Some(encryption_info), event: decrypted_event })
+            Ok(RoomEvent { encryption_info: Some(encryption_info), event: decrypted_event })
         } else {
             self.key_request_machine
                 .create_outgoing_key_request(room_id, &content.sender_key, &content.session_id)
@@ -1162,7 +1161,7 @@ impl OlmMachine {
         &self,
         event: &SyncRoomEncryptedEvent,
         room_id: &RoomId,
-    ) -> MegolmResult<SyncRoomEvent> {
+    ) -> MegolmResult<RoomEvent> {
         match &event.content.scheme {
             EncryptedEventScheme::MegolmV1AesSha2(c) => {
                 match self.decrypt_megolm_v1_event(room_id, event, c).await {
@@ -1577,8 +1576,8 @@ pub(crate) mod test {
                 encrypted::ToDeviceRoomEncryptedEventContent,
                 message::{MessageType, RoomMessageEventContent},
             },
-            AnyMessageEventContent, AnySyncMessageEvent, AnySyncRoomEvent, AnyToDeviceEvent,
-            AnyToDeviceEventContent, SyncMessageEvent, ToDeviceEvent, Unsigned,
+            AnyMessageEvent, AnyMessageEventContent, AnyRoomEvent, AnyToDeviceEvent,
+            AnyToDeviceEventContent, MessageEvent, SyncMessageEvent, ToDeviceEvent, Unsigned,
         },
         room_id,
         serde::Raw,
@@ -2045,7 +2044,7 @@ pub(crate) mod test {
         let decrypted_event =
             bob.decrypt_room_event(&event, room_id).await.unwrap().event.deserialize().unwrap();
 
-        if let AnySyncRoomEvent::Message(AnySyncMessageEvent::RoomMessage(SyncMessageEvent {
+        if let AnyRoomEvent::Message(AnyMessageEvent::RoomMessage(MessageEvent {
             sender,
             content,
             ..

crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs

@@ -38,7 +38,7 @@ use ruma::{
             encrypted::{EncryptedEventScheme, SyncRoomEncryptedEvent},
             history_visibility::HistoryVisibility,
         },
-        AnySyncRoomEvent,
+        AnyRoomEvent,
     },
     serde::Raw,
     DeviceKeyAlgorithm, EventEncryptionAlgorithm, RoomId,
@@ -346,7 +346,7 @@ impl InboundGroupSession {
     pub(crate) async fn decrypt(
         &self,
         event: &SyncRoomEncryptedEvent,
-    ) -> MegolmResult<(Raw<AnySyncRoomEvent>, u32)> {
+    ) -> MegolmResult<(Raw<AnyRoomEvent>, u32)> {
         let content = match &event.content.scheme {
             EncryptedEventScheme::MegolmV1AesSha2(c) => c,
             _ => return Err(EventError::UnsupportedAlgorithm.into()),
@@ -389,7 +389,7 @@ impl InboundGroupSession {
             }
         }
 
-        Ok((serde_json::from_value::<Raw<AnySyncRoomEvent>>(decrypted_value)?, message_index))
+        Ok((serde_json::from_value::<Raw<AnyRoomEvent>>(decrypted_value)?, message_index))
     }
 }
 

crates/matrix-sdk-crypto/src/olm/mod.rs

@@ -70,7 +70,7 @@ pub(crate) mod test {
         events::{
             forwarded_room_key::ToDeviceForwardedRoomKeyEventContent,
             room::message::{Relation, Replacement, RoomMessageEventContent},
-            AnySyncMessageEvent, AnySyncRoomEvent,
+            AnyMessageEvent, AnyRoomEvent, AnySyncMessageEvent, AnySyncRoomEvent,
         },
         room_id, user_id, DeviceId, UserId,
     };
@@ -281,9 +281,7 @@ pub(crate) mod test {
 
         let decrypted = inbound.decrypt(&event).await?.0;
 
-        if let AnySyncRoomEvent::Message(AnySyncMessageEvent::RoomMessage(e)) =
-            decrypted.deserialize()?
-        {
+        if let AnyRoomEvent::Message(AnyMessageEvent::RoomMessage(e)) = decrypted.deserialize()? {
             assert_matches!(e.content.relates_to, Some(Relation::Replacement(_)));
         } else {
             panic!("Invalid event type")

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

@@ -687,9 +687,7 @@ impl Client {
     pub(crate) async fn decrypt_room_event(
         &self,
         event: &AnyRoomEvent,
-    ) -> serde_json::Result<RoomEvent> {
-        use ruma::serde::JsonObject;
-
+    ) -> RoomEvent {
         if let Some(machine) = self.olm_machine().await {
             if let AnyRoomEvent::Message(event) = event {
                 if let AnyMessageEvent::RoomEncrypted(_) = event {
@@ -699,23 +697,15 @@ impl Client {
 
                     if let AnySyncMessageEvent::RoomEncrypted(e) = event {
                         if let Ok(decrypted) = machine.decrypt_room_event(&e, room_id).await {
-                            let mut full_event = decrypted.event.deserialize_as::<JsonObject>()?;
-                            full_event.insert("room_id".to_owned(), serde_json::to_value(room_id)?);
-
-                            let event =
-                                Raw::from_json(serde_json::value::to_raw_value(&full_event)?);
-                            let encryption_info = decrypted.encryption_info;
-
-                            // Return decrypted room event
-                            return Ok(RoomEvent { event, encryption_info });
+                            return decrypted;
                         }
                     }
                 }
             }
         }
 
         // Fallback to still-encrypted room event
-        Ok(RoomEvent { event: Raw::new(event)?, encryption_info: None })
+        RoomEvent { event: Raw::new(event).expect("AnyRoomEvent serialization should not fail"), encryption_info: None }
     }
 
     /// Query the server for users device keys.

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

@@ -182,7 +182,7 @@ impl Common {
         for event in http_response.chunk {
             #[cfg(feature = "encryption")]
             let event = match event.deserialize() {
-                Ok(event) => self.client.decrypt_room_event(&event).await?,
+                Ok(event) => self.client.decrypt_room_event(&event).await,
                 Err(_) => {
                     // "Broken" messages (i.e., those that cannot be deserialized) are
                     // returned unchanged so that the caller can handle them individually.
@@ -205,7 +205,7 @@ impl Common {
         let event = self.client.send(request, None).await?.event.deserialize()?;
 
         #[cfg(feature = "encryption")]
-        return Ok(self.client.decrypt_room_event(&event).await?);
+        return Ok(self.client.decrypt_room_event(&event).await);
 
         #[cfg(not(feature = "encryption"))]
         return Ok(RoomEvent { event: Raw::new(&event)?, encryption_info: None });