sdk-ui: fix pinned events benchmark

Author: jmartinesp

benchmarks/benches/room_bench.rs

@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use matrix_sdk::{
@@ -157,7 +157,6 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
             .respond_with(move |r: &Request| {
                 let segments: Vec<&str> = r.url.path_segments().expect("Invalid path").collect();
                 let event_id_str = segments[6];
-                // let f = EventFactory::new().room(&room_id)
                 let event_id = EventId::parse(event_id_str).expect("Invalid event id in response");
                 let event = f
                     .text_msg(format!("Message {event_id_str}"))
@@ -170,9 +169,6 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
             })
             .mount(&server),
     );
-    // runtime.block_on(server.reset());
-
-    client.event_cache().subscribe().unwrap();
 
     let room = client.get_room(&room_id).expect("Room not found");
     assert!(!room.pinned_event_ids().is_empty());
@@ -184,6 +180,15 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
     group.throughput(Throughput::Elements(count as u64));
     group.sample_size(10);
 
+    let client = Arc::new(client);
+
+    {
+        let client = client.clone();
+        runtime.spawn_blocking(move || {
+            client.event_cache().subscribe().unwrap();
+        });
+    }
+
     group.bench_function(BenchmarkId::new("load_pinned_events", name), |b| {
         b.to_async(&runtime).iter(|| async {
             assert!(!room.pinned_event_ids().is_empty());
@@ -207,7 +212,6 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
     {
         let _guard = runtime.enter();
         runtime.block_on(server.reset());
-        drop(client);
         drop(server);
     }
 

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

@@ -17,6 +17,7 @@ use std::{fmt::Formatter, num::NonZeroUsize, sync::Arc};
 use futures_util::{future::join_all, FutureExt as _};
 use matrix_sdk::{
     config::RequestConfig, event_cache::paginator::PaginatorError, BoxFuture, Room,
+    SendOutsideWasm, SyncOutsideWasm,
 };
 use matrix_sdk_base::deserialized_responses::SyncTimelineEvent;
 use ruma::{EventId, MilliSecondsSinceUnixEpoch, OwnedEventId};
@@ -112,10 +113,10 @@ impl PinnedEventsLoader {
     }
 }
 
-pub trait PinnedEventsRoom {
+pub trait PinnedEventsRoom: SendOutsideWasm + SyncOutsideWasm {
     /// Load a single room event using the cache or network and any events
     /// related to it, if they are cached.
-    async fn load_event_with_relations<'a>(
+    fn load_event_with_relations<'a>(
         &'a self,
         event_id: &'a EventId,
         request_config: Option<RequestConfig>,
@@ -148,7 +149,7 @@ pub trait PinnedEventsRoom {
 }
 
 impl PinnedEventsRoom for Room {
-    async fn load_event_with_relations<'a>(
+    fn load_event_with_relations<'a>(
         &'a self,
         event_id: &'a EventId,
         request_config: Option<RequestConfig>,

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

@@ -319,7 +319,7 @@ impl PaginableRoom for TestRoomDataProvider {
 }
 
 impl PinnedEventsRoom for TestRoomDataProvider {
-    async fn load_event_with_relations<'a>(
+    fn load_event_with_relations<'a>(
         &'a self,
         _event_id: &'a EventId,
         _request_config: Option<RequestConfig>,

crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs

@@ -15,7 +15,10 @@ use matrix_sdk_ui::{
     timeline::{TimelineFocus, TimelineItemContent},
     Timeline,
 };
-use ruma::{event_id, owned_room_id, MilliSecondsSinceUnixEpoch, OwnedRoomId};
+use ruma::{
+    event_id, events::room::message::RoomMessageEventContentWithoutRelation, owned_room_id,
+    MilliSecondsSinceUnixEpoch, OwnedRoomId,
+};
 use serde_json::json;
 use stream_assert::assert_pending;
 use wiremock::MockServer;
@@ -402,7 +405,11 @@ async fn test_edited_events_are_reflected_in_sync() {
     test_helper.server.reset().await;
 
     let edited_event = f
-        .replacement_msg("edited message!", event_id!("$1"))
+        .text_msg("edited message!")
+        .edit(
+            event_id!("$1"),
+            RoomMessageEventContentWithoutRelation::text_plain("* edited message!"),
+        )
         .event_id(event_id!("$2"))
         .server_ts(MilliSecondsSinceUnixEpoch::now())
         .into_timeline();
@@ -425,7 +432,7 @@ async fn test_edited_events_are_reflected_in_sync() {
         assert_eq!(index, 1);
         match value.as_event().unwrap().content() {
             TimelineItemContent::Message(m) => {
-                assert_eq!(m.body(), "edited message!")
+                assert_eq!(m.body(), "* edited message!")
             }
             _ => panic!("Should be a message event"),
         }
@@ -547,7 +554,11 @@ async fn test_edited_events_survive_pinned_event_ids_change() {
     test_helper.server.reset().await;
 
     let edited_pinned_event = f
-        .replacement_msg("edited message!", event_id!("$1"))
+        .text_msg("* edited message!")
+        .edit(
+            event_id!("$1"),
+            RoomMessageEventContentWithoutRelation::text_plain("edited message!"),
+        )
         .event_id(event_id!("$2"))
         .server_ts(MilliSecondsSinceUnixEpoch::now())
         .into_timeline();

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

@@ -570,8 +570,9 @@ impl RoomEventCache {
 
     /// Save a single event in the event cache, for further retrieval with
     /// [`Self::event`].
-    // This doesn't insert the event into the linked chunk. In the future there'll
-    // be no distinction between the linked chunk and the separate cache.
+    // TODO: This doesn't insert the event into the linked chunk. In the future
+    // there'll be no distinction between the linked chunk and the separate
+    // cache. There is a discussion in https://github.com/matrix-org/matrix-rust-sdk/issues/3886.
     pub(crate) async fn save_event(&self, event: SyncTimelineEvent) {
         if let Some(event_id) = event.event_id() {
             let mut cache = self.inner.all_events_cache.write().await;
@@ -586,8 +587,9 @@ impl RoomEventCache {
     /// Save some events in the event cache, for further retrieval with
     /// [`Self::event`]. This function will save them using a single lock,
     /// as opposed to [`Self::save_event`].
-    // This doesn't insert the event into the linked chunk. In the future there'll
-    // be no distinction between the linked chunk and the separate cache.
+    // TODO: This doesn't insert the event into the linked chunk. In the future
+    // there'll be no distinction between the linked chunk and the separate
+    // cache. There is a discussion in https://github.com/matrix-org/matrix-rust-sdk/issues/3886.
     pub(crate) async fn save_events(&self, events: impl IntoIterator<Item = SyncTimelineEvent>) {
         let mut cache = self.inner.all_events_cache.write().await;
         for event in events {

crates/matrix-sdk/src/event_cache/paginator.rs

@@ -471,16 +471,16 @@ impl PaginableRoom for Room {
             match self.event_with_context(event_id, lazy_load_members, num_events, None).await {
                 Ok(result) => result,
 
-            Err(err) => {
-                // If the error was a 404, then the event wasn't found on the server;
-                // special case this to make it easy to react to
-                // such an error.
-                if let Some(error) = err.as_client_api_error() {
-                    if error.status_code == 404 {
-                        // Event not found
-                        return Err(PaginatorError::EventNotFound(event_id.to_owned()));
+                Err(err) => {
+                    // If the error was a 404, then the event wasn't found on the server;
+                    // special case this to make it easy to react to
+                    // such an error.
+                    if let Some(error) = err.as_client_api_error() {
+                        if error.status_code == 404 {
+                            // Event not found
+                            return Err(PaginatorError::EventNotFound(event_id.to_owned()));
+                        }
                     }
-                }
 
                     // Otherwise, just return a wrapped error.
                     return Err(PaginatorError::SdkError(Box::new(err)));