cleanups

crates/matrix-sdk-crypto/src/identities/device.rs

@@ -871,6 +871,7 @@ impl ReadOnlyDevice {
         }
     }
 
+    /// Return the device keys
     pub fn as_device_keys(&self) -> &DeviceKeys {
         &self.inner
     }

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

@@ -1299,14 +1299,14 @@ impl Account {
                 }
 
                 // We didn't find a matching session; try to create a new session.
-                // try to get our own stored device keys
+                // Try to get our own stored device keys.
                 let device_keys = store
                     .get_device(&self.user_id, &self.device_id)
                     .await
                     .unwrap_or(None)
                     .map(|read_only_device| read_only_device.as_device_keys().clone());
-                // if we don't have it stored, fall back to generating a fresh
-                // device keys from our own Account
+                // If we don't have our device keys stored, fall back to
+                // generating a fresh device keys from our own Account.
                 let device_keys = match device_keys {
                     Some(device_keys) => device_keys,
                     None => self.device_keys(),

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

@@ -309,7 +309,6 @@ mod tests {
         );
 
         let alice_device = ReadOnlyDevice::from_account(&alice);
-        // let bob_device = ReadOnlyDevice::from_account(&bob);
 
         let message = alice_session
             .encrypt(&alice_device, "m.dummy", ToDeviceDummyEventContent::new(), None)
@@ -338,7 +337,7 @@ mod tests {
             )
             .unwrap();
 
-        // check that the payload has the device keys
+        // Check that the encrypted payload has the device keys.
         let plaintext: Value = serde_json::from_str(&bob_session_result.plaintext).unwrap();
         assert_eq!(plaintext["device_keys"]["user_id"].as_str(), Some("@alice:localhost"));
     }

crates/matrix-sdk-crypto/src/session_manager/sessions.rs

@@ -514,6 +514,8 @@ impl SessionManager {
         let mut new_sessions: BTreeMap<&UserId, BTreeMap<&DeviceId, SessionInfo>> = BTreeMap::new();
         let mut store_transaction = self.store.transaction().await;
 
+        // Cache of our own device keys, so we only need to fetch it once, if
+        // we need it at all.
         let mut our_device_keys: Option<DeviceKeys> = None;
 
         for (user_id, user_devices) in &response.one_time_keys {
@@ -542,14 +544,15 @@ impl SessionManager {
                 let device_keys = match our_device_keys {
                     Some(ref device_keys) => device_keys.clone(),
                     None => {
+                        // Try to get our own stored device keys.
                         let device_keys = self
                             .store
                             .get_device(&account.user_id, &account.device_id)
                             .await
                             .unwrap_or(None)
                             .map(|read_only_device| read_only_device.as_device_keys().clone());
-                        // if we don't have it stored, fall back to generating a fresh
-                        // device keys from our own Account
+                        // If we don't have it stored, fall back to generating a fresh
+                        // device keys from our own Account.
                         let device_keys = match device_keys {
                             Some(device_keys) => device_keys,
                             None => account.device_keys(),

crates/matrix-sdk-indexeddb/src/crypto_store/mod.rs

@@ -540,9 +540,9 @@ impl IndexeddbCryptoStore {
         let account_info = self.get_static_account();
         let mut clear_caches = false;
         for device in device_changes.new.iter().chain(&device_changes.changed) {
-            // if our own device key changes, we need to clear the
-            // session cache because the sessions contain a copy of our
-            // device key
+            // If our own device key changes, we need to clear the session
+            // cache because the sessions contain a copy of our device key, and
+            // we want the sessions to use the new version.
             if account_info.clone().is_some_and(|info| {
                 info.user_id == device.user_id() && info.device_id == device.device_id()
             }) {
@@ -879,14 +879,14 @@ impl_crypto_store! {
     async fn get_sessions(&self, sender_key: &str) -> Result<Option<Arc<Mutex<Vec<Session>>>>> {
         let account_info = self.get_static_account().ok_or(CryptoStoreError::AccountUnset)?;
         if self.session_cache.get(sender_key).is_none() {
-            // try to get our own stored device keys
+            // Try to get our own stored device keys.
             let device_keys = self.get_device(&account_info.user_id, &account_info.device_id)
                 .await
                 .unwrap_or(None)
                 .map(|read_only_device| read_only_device.as_device_keys().clone());
 
-            // if we don't have it stored, fall back to generating a fresh
-            // device keys from our own Account
+            // If we don't have it stored, fall back to generating a fresh
+            // device keys from our own Account.
             let device_keys = match device_keys {
                 Some(device_keys) => device_keys,
                 None => {

crates/matrix-sdk-sqlite/src/crypto_store.rs

@@ -808,9 +808,9 @@ impl CryptoStore for SqliteCryptoStore {
 
                 let account_info = this.get_static_account();
                 for device in changes.devices.new.iter().chain(&changes.devices.changed) {
-                    // if our own device key changes, we need to clear the
+                    // If our own device key changes, we need to clear the
                     // session cache because the sessions contain a copy of our
-                    // device key
+                    // device key.
                     if account_info.clone().is_some_and(|info| {
                         info.user_id == device.user_id() && info.device_id == device.device_id()
                     }) {
@@ -923,15 +923,15 @@ impl CryptoStore for SqliteCryptoStore {
         let account_info = self.get_static_account().ok_or(Error::AccountUnset)?;
 
         if self.session_cache.get(sender_key).is_none() {
-            // try to get our own stored device keys
+            // Try to get our own stored device keys.
             let device_keys = self
                 .get_device(&account_info.user_id, &account_info.device_id)
                 .await
                 .unwrap_or(None)
                 .map(|read_only_device| read_only_device.as_device_keys().clone());
 
-            // if we don't have it stored, fall back to generating a fresh
-            // device keys from our own Account
+            // If we don't have it stored, fall back to generating a fresh
+            // device keys from our own Account.
             let device_keys = match device_keys {
                 Some(device_keys) => device_keys,
                 None => {