From fb86fc2744a5235c3e1b2d809d32b60be44c6200 Mon Sep 17 00:00:00 2001
From: Matt Corallo <git@bluematt.me>
Date: Thu, 30 Mar 2023 23:35:07 +0000
Subject: [PATCH] DRY the event handling in `ChannelManager`

In the coming commits we'll add some additional complexity to the
event handling flows, so best to DRY them up before we get there.
---
 lightning/src/ln/channelmanager.rs | 78 +++++++++++++-----------------
 1 file changed, 34 insertions(+), 44 deletions(-)

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 3748c5688..5f315b8fd 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -1623,6 +1623,36 @@ macro_rules! handle_new_monitor_update {
 	}
 }
 
+macro_rules! process_events_body {
+	($self: expr, $event_to_handle: expr, $handle_event: expr) => {
+		// We'll acquire our total consistency lock until the returned future completes so that
+		// we can be sure no other persists happen while processing events.
+		let _read_guard = $self.total_consistency_lock.read().unwrap();
+
+		let mut result = NotifyOption::SkipPersist;
+
+		// TODO: This behavior should be documented. It's unintuitive that we query
+		// ChannelMonitors when clearing other events.
+		if $self.process_pending_monitor_events() {
+			result = NotifyOption::DoPersist;
+		}
+
+		let pending_events = mem::replace(&mut *$self.pending_events.lock().unwrap(), vec![]);
+		if !pending_events.is_empty() {
+			result = NotifyOption::DoPersist;
+		}
+
+		for event in pending_events {
+			$event_to_handle = event;
+			$handle_event;
+		}
+
+		if result == NotifyOption::DoPersist {
+			$self.persistence_notifier.notify();
+		}
+	}
+}
+
 impl<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, L: Deref> ChannelManager<M, T, ES, NS, SP, F, R, L>
 where
 	M::Target: chain::Watch<<SP::Target as SignerProvider>::Signer>,
@@ -5720,30 +5750,8 @@ where
 	pub async fn process_pending_events_async<Future: core::future::Future, H: Fn(Event) -> Future>(
 		&self, handler: H
 	) {
-		// We'll acquire our total consistency lock until the returned future completes so that
-		// we can be sure no other persists happen while processing events.
-		let _read_guard = self.total_consistency_lock.read().unwrap();
-
-		let mut result = NotifyOption::SkipPersist;
-
-		// TODO: This behavior should be documented. It's unintuitive that we query
-		// ChannelMonitors when clearing other events.
-		if self.process_pending_monitor_events() {
-			result = NotifyOption::DoPersist;
-		}
-
-		let pending_events = mem::replace(&mut *self.pending_events.lock().unwrap(), vec![]);
-		if !pending_events.is_empty() {
-			result = NotifyOption::DoPersist;
-		}
-
-		for event in pending_events {
-			handler(event).await;
-		}
-
-		if result == NotifyOption::DoPersist {
-			self.persistence_notifier.notify();
-		}
+		let mut ev;
+		process_events_body!(self, ev, { handler(ev).await });
 	}
 }
 
@@ -5825,26 +5833,8 @@ where
 	/// An [`EventHandler`] may safely call back to the provider in order to handle an event.
 	/// However, it must not call [`Writeable::write`] as doing so would result in a deadlock.
 	fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler {
-		PersistenceNotifierGuard::optionally_notify(&self.total_consistency_lock, &self.persistence_notifier, || {
-			let mut result = NotifyOption::SkipPersist;
-
-			// TODO: This behavior should be documented. It's unintuitive that we query
-			// ChannelMonitors when clearing other events.
-			if self.process_pending_monitor_events() {
-				result = NotifyOption::DoPersist;
-			}
-
-			let pending_events = mem::replace(&mut *self.pending_events.lock().unwrap(), vec![]);
-			if !pending_events.is_empty() {
-				result = NotifyOption::DoPersist;
-			}
-
-			for event in pending_events {
-				handler.handle_event(event);
-			}
-
-			result
-		});
+		let mut ev;
+		process_events_body!(self, ev, handler.handle_event(ev));
 	}
 }
 
-- 
2.39.5