f rebase

Author: TheBlueMatt

lightning/src/util/wakers.rs

@@ -30,26 +30,26 @@ use std::pin::Pin;
 
 /// Used to signal to one of many waiters that the condition they're waiting on has happened.
 pub(crate) struct Notifier {
-	persist_pending: Mutex<(bool, Option<Arc<Mutex<FutureState>>>)>,
-	persistence_condvar: Condvar,
+	notify_pending: Mutex<(bool, Option<Arc<Mutex<FutureState>>>)>,
+	condvar: Condvar,
 }
 
 impl Notifier {
 	pub(crate) fn new() -> Self {
 		Self {
-			persist_pending: Mutex::new((false, None)),
-			persistence_condvar: Condvar::new(),
+			notify_pending: Mutex::new((false, None)),
+			condvar: Condvar::new(),
 		}
 	}
 
 	pub(crate) fn wait(&self) {
 		loop {
-			let mut guard = self.persist_pending.lock().unwrap();
+			let mut guard = self.notify_pending.lock().unwrap();
 			if guard.0 {
 				guard.0 = false;
 				return;
 			}
-			guard = self.persistence_condvar.wait(guard).unwrap();
+			guard = self.condvar.wait(guard).unwrap();
 			let result = guard.0;
 			if result {
 				guard.0 = false;
@@ -62,12 +62,12 @@ impl Notifier {
 	pub(crate) fn wait_timeout(&self, max_wait: Duration) -> bool {
 		let current_time = Instant::now();
 		loop {
-			let mut guard = self.persist_pending.lock().unwrap();
+			let mut guard = self.notify_pending.lock().unwrap();
 			if guard.0 {
 				guard.0 = false;
 				return true;
 			}
-			guard = self.persistence_condvar.wait_timeout(guard, max_wait).unwrap().0;
+			guard = self.condvar.wait_timeout(guard, max_wait).unwrap().0;
 			// Due to spurious wakeups that can happen on `wait_timeout`, here we need to check if the
 			// desired wait time has actually passed, and if not then restart the loop with a reduced wait
 			// time. Note that this logic can be highly simplified through the use of
@@ -88,40 +88,40 @@ impl Notifier {
 
 	/// Wake waiters, tracking that persistence needs to occur.
 	pub(crate) fn notify(&self) {
-		let mut persistence_lock = self.persist_pending.lock().unwrap();
-		persistence_lock.0 = true;
-		if let Some(future_state) = persistence_lock.1.take() {
+		let mut lock = self.notify_pending.lock().unwrap();
+		lock.0 = true;
+		if let Some(future_state) = lock.1.take() {
 			future_state.lock().unwrap().complete();
 		}
-		mem::drop(persistence_lock);
-		self.persistence_condvar.notify_all();
+		mem::drop(lock);
+		self.condvar.notify_all();
 	}
 
 	/// Gets a [`Future`] that will get woken up with any waiters
 	pub(crate) fn get_future(&self) -> Future {
-		let mut persistence_lock = self.persist_pending.lock().unwrap();
-		if persistence_lock.0 {
+		let mut lock = self.notify_pending.lock().unwrap();
+		if lock.0 {
 			Future {
 				state: Arc::new(Mutex::new(FutureState {
 					callbacks: Vec::new(),
 					complete: false,
 				}))
 			}
-		} else if let Some(existing_state) = &persistence_lock.1 {
+		} else if let Some(existing_state) = &lock.1 {
 			Future { state: Arc::clone(&existing_state) }
 		} else {
 			let state = Arc::new(Mutex::new(FutureState {
 				callbacks: Vec::new(),
 				complete: false,
 			}));
-			persistence_lock.1 = Some(Arc::clone(&state));
+			lock.1 = Some(Arc::clone(&state));
 			Future { state }
 		}
 	}
 
 	#[cfg(any(test, feature = "_test_utils"))]
 	pub fn needs_persist(&self) -> bool {
-		self.persist_pending.lock().unwrap().0
+		self.notify_pending.lock().unwrap().0
 	}
 }
 
@@ -214,9 +214,9 @@ mod tests {
 		let exit_thread_clone = exit_thread.clone();
 		thread::spawn(move || {
 			loop {
-				let mut persistence_lock = thread_notifier.persist_pending.lock().unwrap();
-				persistence_lock.0 = true;
-				thread_notifier.persistence_condvar.notify_all();
+				let mut lock = thread_notifier.notify_pending.lock().unwrap();
+				lock.0 = true;
+				thread_notifier.condvar.notify_all();
 
 				if exit_thread_clone.load(Ordering::SeqCst) {
 					break