fixup!

Author: Hywan

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

@@ -87,8 +87,8 @@ pub trait TryLock {
     ///
     /// Returns `Some(_)` to indicate the lock succeeded, `None` otherwise. The
     /// cross-process lock generation must be compared to the generation before
-    /// the call to see if the lock has been poisoned: a different generation
-    /// means the lock has been poisoned, i.e. taken by a different holder in
+    /// the call to see if the lock has been dirtied: a different generation
+    /// means the lock has been dirtied, i.e. taken by a different holder in
     /// the meantime.
     fn try_lock(
         &self,
@@ -165,7 +165,7 @@ where
 
     lock_generation: Arc<AtomicCrossProcessLockGeneration>,
 
-    is_poisoned: Arc<AtomicBool>,
+    is_dirty: Arc<AtomicBool>,
 }
 
 /// Amount of time a lease of the lock should last, in milliseconds.
@@ -208,26 +208,26 @@ where
             lock_generation: Arc::new(AtomicCrossProcessLockGeneration::new(
                 FIRST_CROSS_PROCESS_LOCK_GENERATION,
             )),
-            is_poisoned: Arc::new(AtomicBool::new(false)),
+            is_dirty: Arc::new(AtomicBool::new(false)),
         }
     }
 
-    /// Determine whether the cross-process lock is poisoned.
+    /// Determine whether the cross-process lock is dirtied.
     ///
-    /// If another process has taken the lock, then this lock becomes poisoned.
+    /// If another process has taken the lock, then this lock becomes dirty.
     /// You should not trust a `false` value for program correctness without
     /// additional synchronisation.
-    pub fn is_poisoned(&self) -> bool {
-        self.is_poisoned.load(Ordering::SeqCst)
+    pub fn is_dirty(&self) -> bool {
+        self.is_dirty.load(Ordering::SeqCst)
     }
 
-    /// Clear the poisoned state from this cross-process lock.
+    /// Clear the dirty state from this cross-process lock.
     ///
-    /// If the cross-process lock is poisoned, it will remain poisoned until
-    /// this method is called. This allows recovering from a poisoned
-    /// state and marking that it has recovered.
-    pub fn clear_poison(&self) {
-        self.is_poisoned.store(false, Ordering::SeqCst);
+    /// If the cross-process lock is dirtied, it will remain dirtied until
+    /// this method is called. This allows recovering from a dirty state and
+    /// marking that it has recovered.
+    pub fn clear_dirty(&self) {
+        self.is_dirty.store(false, Ordering::SeqCst);
         self.lock_generation.store(NO_CROSS_PROCESS_LOCK_GENERATION, Ordering::SeqCst);
     }
 
@@ -261,19 +261,19 @@ where
         {
             match self.lock_generation.swap(new_generation, Ordering::SeqCst) {
                 // If there was no lock generation, it means this is the first time the lock is
-                // acquired. It cannot be poisoned.
+                // acquired. It cannot be dirty.
                 NO_CROSS_PROCESS_LOCK_GENERATION => {
                     trace!(?new_generation, "Setting the lock generation for the first time");
                 }
 
-                // This was NOT the same generation, the lock has been poisoned!
+                // This was NOT the same generation, the lock has been dirtied!
                 previous_generation if previous_generation != new_generation => {
                     warn!(
                         ?previous_generation,
                         ?new_generation,
-                        "The lock has been acquired, but it's been poisoned!"
+                        "The lock has been acquired, but it's been dirtied!"
                     );
-                    self.is_poisoned.store(true, Ordering::SeqCst);
+                    self.is_dirty.store(true, Ordering::SeqCst);
                 }
 
                 // This was the same generation, no problem.
@@ -355,14 +355,14 @@ where
                                 "It's impossible to renew a lock lease that has not been acquired once"
                             ),
 
-                            // This was NOT the same generation, the lock has been poisoned!
+                            // This was NOT the same generation, the lock has been dirtied!
                             previous_generation if previous_generation != new_generation => {
                                 warn!(
                                     ?previous_generation,
                                     ?new_generation,
-                                    "The lock lease has been renewed, but it's been poisoned!"
+                                    "The lock lease has been renewed, but it's been dirtied!"
                                 );
-                                this.is_poisoned.store(true, Ordering::SeqCst);
+                                this.is_dirty.store(true, Ordering::SeqCst);
 
                                 // Exit the loop.
                                 break;