feat(sdk) Remove delta_token from sliding sync.

Simplified sliding sync doesn't have `delta_token`. This patch removes
it. Note: even the current sliding sync proxy doesn't use it.

Author: Hywan

crates/matrix-sdk/src/sliding_sync/builder.rs

@@ -255,15 +255,17 @@ impl SlidingSyncBuilder {
         let restored_fields =
             restore_sliding_sync_state(&client, &self.storage_key, &lists).await?;
 
-        let (delta_token, pos) = if let Some(fields) = restored_fields {
+        let pos = if let Some(fields) = restored_fields {
             #[cfg(feature = "e2e-encryption")]
-            let pos = if self.share_pos { fields.pos } else { None };
+            if self.share_pos {
+                fields.pos
+            } else {
+                None
+            }
             #[cfg(not(feature = "e2e-encryption"))]
-            let pos = None;
-
-            (fields.delta_token, pos)
+            None
         } else {
-            (None, None)
+            None
         };
 
         #[cfg(feature = "e2e-encryption")]
@@ -289,7 +291,7 @@ impl SlidingSyncBuilder {
             lists,
             rooms,
 
-            position: Arc::new(AsyncMutex::new(SlidingSyncPositionMarkers { pos, delta_token })),
+            position: Arc::new(AsyncMutex::new(SlidingSyncPositionMarkers { pos })),
             // SAFETY: `unwrap` is safe because 20 is not zero.
             past_positions: StdRwLock::new(RingBuffer::new(NonZeroUsize::new(20).unwrap())),
 

crates/matrix-sdk/src/sliding_sync/cache.rs

@@ -88,10 +88,7 @@ pub(super) async fn store_sliding_sync_state(
     storage
         .set_custom_value(
             instance_storage_key.as_bytes(),
-            serde_json::to_vec(&FrozenSlidingSync::new(
-                position,
-                &*sliding_sync.inner.rooms.read().await,
-            ))?,
+            serde_json::to_vec(&FrozenSlidingSync::new(&*sliding_sync.inner.rooms.read().await))?,
         )
         .await?;
 
@@ -184,7 +181,6 @@ pub(super) async fn restore_sliding_sync_list(
 /// Fields restored during `restore_sliding_sync_state`.
 #[derive(Default)]
 pub(super) struct RestoredFields {
-    pub delta_token: Option<String>,
     pub to_device_token: Option<String>,
     pub pos: Option<String>,
     pub rooms: BTreeMap<OwnedRoomId, SlidingSyncRoom>,
@@ -223,20 +219,14 @@ pub(super) async fn restore_sliding_sync_state(
         .map(|custom_value| serde_json::from_slice::<FrozenSlidingSync>(&custom_value))
     {
         // `SlidingSync` has been found and successfully deserialized.
-        Some(Ok(FrozenSlidingSync {
-            to_device_since,
-            delta_token: frozen_delta_token,
-            rooms: frozen_rooms,
-        })) => {
+        Some(Ok(FrozenSlidingSync { to_device_since, rooms: frozen_rooms })) => {
             trace!("Successfully read the `SlidingSync` from the cache");
             // Only update the to-device token if we failed to read it from the crypto store
             // above.
             if restored_fields.to_device_token.is_none() {
                 restored_fields.to_device_token = to_device_since;
             }
 
-            restored_fields.delta_token = frozen_delta_token;
-
             #[cfg(feature = "e2e-encryption")]
             {
                 if let Some(olm_machine) = &*client.olm_machine().await {
@@ -478,11 +468,9 @@ mod tests {
         assert!(state_store.get_custom_value(full_storage_key.as_bytes()).await?.is_none());
 
         // Emulate some data to be cached.
-        let delta_token = "delta_token".to_owned();
         let pos = "pos".to_owned();
         {
             let mut position_guard = sliding_sync.inner.position.lock().await;
-            position_guard.delta_token = Some(delta_token.clone());
             position_guard.pos = Some(pos.clone());
 
             // Then, we can correctly cache the sliding sync instance.
@@ -496,7 +484,6 @@ mod tests {
             state_store.get_custom_value(full_storage_key.as_bytes()).await?,
             Some(bytes) => {
                 let deserialized: FrozenSlidingSync = serde_json::from_slice(&bytes)?;
-                assert_eq!(deserialized.delta_token, Some(delta_token.clone()));
                 assert!(deserialized.to_device_since.is_none());
             }
         );
@@ -509,7 +496,6 @@ mod tests {
             .expect("must have restored sliding sync fields");
 
         // After restoring, the delta token and to-device token could be read.
-        assert_eq!(restored_fields.delta_token.unwrap(), delta_token);
         assert_eq!(restored_fields.pos.unwrap(), pos);
 
         // Test the "migration" path: assume a missing to-device token in crypto store,
@@ -531,7 +517,6 @@ mod tests {
                 full_storage_key.as_bytes(),
                 serde_json::to_vec(&FrozenSlidingSync {
                     to_device_since: Some(to_device_token.clone()),
-                    delta_token: Some(delta_token.clone()),
                     rooms: vec![FrozenSlidingSyncRoom {
                         room_id: owned_room_id!("!r0:matrix.org"),
                         prev_batch: Some("t0ken".to_owned()),
@@ -547,7 +532,6 @@ mod tests {
 
         // After restoring, the delta token, the to-device since token, stream
         // position and rooms could be read from the state store.
-        assert_eq!(restored_fields.delta_token.unwrap(), delta_token);
         assert_eq!(restored_fields.to_device_token.unwrap(), to_device_token);
         assert_eq!(restored_fields.pos.unwrap(), pos);
         assert_eq!(restored_fields.rooms.len(), 1);

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

@@ -424,7 +424,6 @@ impl SlidingSync {
         //
         // Save the new position markers.
         position.pos = pos;
-        position.delta_token = sliding_sync_response.delta_token.clone();
 
         // Keep this position markers in memory, in case it pops from the server.
         let mut past_positions = self.inner.past_positions.write().unwrap();
@@ -448,15 +447,14 @@ impl SlidingSync {
             }
         }
 
-        // Collect the `pos` and `delta_token`.
+        // Collect the `pos`.
         //
         // Wait on the `position` mutex to be available. It means no request nor
         // response is running. The `position` mutex is released whether the response
         // has been fully handled successfully, in this case the `pos` is updated, or
         // the response handling has failed, in this case the `pos` hasn't been updated
         // and the same `pos` will be used for this new request.
         let mut position_guard = self.inner.position.clone().lock_owned().await;
-        let delta_token = position_guard.delta_token.clone();
 
         let to_device_enabled =
             self.inner.sticky.read().unwrap().data().extensions.to_device.enabled == Some(true);
@@ -493,7 +491,6 @@ impl SlidingSync {
 
         let mut request = assign!(v4::Request::new(), {
             conn_id: Some(self.inner.id.clone()),
-            delta_token,
             pos,
             timeout: Some(self.inner.poll_timeout),
             lists: requests_lists,
@@ -874,13 +871,6 @@ pub(super) struct SlidingSyncPositionMarkers {
     ///
     /// Should not be persisted.
     pos: Option<String>,
-
-    /// Server-provided opaque token that remembers what the last timeline and
-    /// state events stored by the client were.
-    ///
-    /// If `None`, the server will send the full information for all the lists
-    /// present in the request.
-    delta_token: Option<String>,
 }
 
 /// Frozen bits of a Sliding Sync that are stored in the *state* store.
@@ -889,20 +879,14 @@ struct FrozenSlidingSync {
     /// Deprecated: prefer storing in the crypto store.
     #[serde(skip_serializing_if = "Option::is_none")]
     to_device_since: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    delta_token: Option<String>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     rooms: Vec<FrozenSlidingSyncRoom>,
 }
 
 impl FrozenSlidingSync {
-    fn new(
-        position: &SlidingSyncPositionMarkers,
-        rooms: &BTreeMap<OwnedRoomId, SlidingSyncRoom>,
-    ) -> Self {
+    fn new(rooms: &BTreeMap<OwnedRoomId, SlidingSyncRoom>) -> Self {
         // The to-device token must be saved in the `FrozenCryptoSlidingSync` now.
         Self {
-            delta_token: position.delta_token.clone(),
             to_device_since: None,
             rooms: rooms
                 .iter()
@@ -1200,8 +1184,7 @@ mod tests {
 
         // FrozenSlidingSync doesn't contain the to_device_token anymore, as it's saved
         // in the crypto store since PR #2323.
-        let position_guard = sliding_sync.inner.position.lock().await;
-        let frozen = FrozenSlidingSync::new(&position_guard, &Default::default());
+        let frozen = FrozenSlidingSync::new(&*sliding_sync.inner.rooms.read().await);
         assert!(frozen.to_device_since.is_none());
 
         Ok(())