chore: Move the cross-process lock enabling into a separate method

Author: poljar

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

@@ -300,17 +300,17 @@ impl Oidc {
     /// olm machine has been initialized.
     ///
     /// Must be called after `set_session_meta`.
-    async fn deferred_enable_cross_process_refresh_lock(&self) -> Result<()> {
+    async fn deferred_enable_cross_process_refresh_lock(&self) {
         let deferred_init_lock = self.ctx().deferred_cross_process_lock_init.lock().await;
 
         // Don't `take()` the value, so that subsequent calls to
         // `enable_cross_process_refresh_lock` will keep on failing if we've enabled the
         // lock at least once.
         let Some(lock_value) = deferred_init_lock.as_ref() else {
-            return Ok(());
+            return;
         };
 
-        // FIXME We shouldn't be using the crypto store for that! see also https://github.com/matrix-org/matrix-rust-sdk/issues/2472
+        // FIXME: We shouldn't be using the crypto store for that! see also https://github.com/matrix-org/matrix-rust-sdk/issues/2472
         let olm_machine_lock = self.client.olm_machine().await;
         let olm_machine =
             olm_machine_lock.as_ref().expect("there has to be an olm machine, hopefully?");
@@ -323,8 +323,6 @@ impl Oidc {
         // This method is guarded with the `deferred_cross_process_lock_init` lock held,
         // so this `set` can't be an error.
         let _ = self.ctx().cross_process_token_refresh_manager.set(manager);
-
-        Ok(())
     }
 
     /// The OpenID Connect authentication data.
@@ -708,7 +706,7 @@ impl Oidc {
         };
 
         self.client.set_session_meta(meta).await?;
-        self.deferred_enable_cross_process_refresh_lock().await?;
+        self.deferred_enable_cross_process_refresh_lock().await;
 
         self.client
             .inner
@@ -913,14 +911,23 @@ impl Oidc {
         // At this point the Olm machine has been set up.
 
         // Enable the cross-process lock for refreshes, if needs be.
-        self.deferred_enable_cross_process_refresh_lock().await?;
+        self.enable_cross_process_lock().await.map_err(OidcError::from)?;
+
+        #[cfg(feature = "e2e-encryption")]
+        self.client.encryption().run_initialization_tasks(None).await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn enable_cross_process_lock(
+        &self,
+    ) -> Result<(), CrossProcessRefreshLockError> {
+        // Enable the cross-process lock for refreshes, if needs be.
+        self.deferred_enable_cross_process_refresh_lock().await;
 
         if let Some(cross_process_manager) = self.ctx().cross_process_token_refresh_manager.get() {
             if let Some(tokens) = self.session_tokens() {
-                let mut cross_process_guard = cross_process_manager
-                    .spin_lock()
-                    .await
-                    .map_err(|err| crate::Error::Oidc(err.into()))?;
+                let mut cross_process_guard = cross_process_manager.spin_lock().await?;
 
                 if cross_process_guard.hash_mismatch {
                     // At this point, we're finishing a login while another process had written
@@ -932,16 +939,10 @@ impl Oidc {
                     );
                 }
 
-                cross_process_guard
-                    .save_in_memory_and_db(&tokens)
-                    .await
-                    .map_err(|err| crate::Error::Oidc(err.into()))?;
+                cross_process_guard.save_in_memory_and_db(&tokens).await?;
             }
         }
 
-        #[cfg(feature = "e2e-encryption")]
-        self.client.encryption().run_initialization_tasks(None).await;
-
         Ok(())
     }