From 1adb063fbc4370edb80016532d0c79ca1b87bde2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Tue, 29 Jan 2019 18:22:05 +0200
Subject: [PATCH] Don't box closures twice for signal callback closures

---
 gstreamer-app/src/app_sink.rs       | 40 ++++++++++-------------------
 gstreamer-pbutils/src/discoverer.rs | 10 ++++----
 gstreamer-player/src/player.rs      | 37 +++++++++++++-------------
 gstreamer/src/bin.rs                | 14 +++++-----
 4 files changed, 46 insertions(+), 55 deletions(-)

diff --git a/gstreamer-app/src/app_sink.rs b/gstreamer-app/src/app_sink.rs
index d62779617..bff01b1ed 100644
--- a/gstreamer-app/src/app_sink.rs
+++ b/gstreamer-app/src/app_sink.rs
@@ -182,19 +182,12 @@ impl AppSink {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<
-                Box_<
-                    Fn(&AppSink) -> Result<gst::FlowSuccess, gst::FlowError>
-                        + Send
-                        + Sync
-                        + 'static,
-                >,
-            > = Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"new-sample\0".as_ptr() as *const _,
-                transmute(new_sample_trampoline as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(new_sample_trampoline::<F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
@@ -206,40 +199,35 @@ impl AppSink {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<
-                Box_<
-                    Fn(&AppSink) -> Result<gst::FlowSuccess, gst::FlowError>
-                        + Send
-                        + Sync
-                        + 'static,
-                >,
-            > = Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"new-preroll\0".as_ptr() as *const _,
-                transmute(new_preroll_trampoline as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(new_preroll_trampoline::<F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
 }
 
-unsafe extern "C" fn new_sample_trampoline(
+unsafe extern "C" fn new_sample_trampoline<
+    F: Fn(&AppSink) -> Result<gst::FlowSuccess, gst::FlowError> + Send + Sync + 'static,
+>(
     this: *mut ffi::GstAppSink,
     f: glib_ffi::gpointer,
 ) -> gst_ffi::GstFlowReturn {
-    let f: &&(Fn(&AppSink) -> Result<gst::FlowSuccess, gst::FlowError> + Send + Sync + 'static) =
-        transmute(f);
+    let f: &F = transmute(f);
     let ret: gst::FlowReturn = f(&from_glib_borrow(this)).into();
     ret.to_glib()
 }
 
-unsafe extern "C" fn new_preroll_trampoline(
+unsafe extern "C" fn new_preroll_trampoline<
+    F: Fn(&AppSink) -> Result<gst::FlowSuccess, gst::FlowError> + Send + Sync + 'static,
+>(
     this: *mut ffi::GstAppSink,
     f: glib_ffi::gpointer,
 ) -> gst_ffi::GstFlowReturn {
-    let f: &&(Fn(&AppSink) -> Result<gst::FlowSuccess, gst::FlowError> + Send + Sync + 'static) =
-        transmute(f);
+    let f: &F = transmute(f);
     let ret: gst::FlowReturn = f(&from_glib_borrow(this)).into();
     ret.to_glib()
 }
diff --git a/gstreamer-pbutils/src/discoverer.rs b/gstreamer-pbutils/src/discoverer.rs
index 7d074f286..d3aafed9e 100644
--- a/gstreamer-pbutils/src/discoverer.rs
+++ b/gstreamer-pbutils/src/discoverer.rs
@@ -53,18 +53,18 @@ impl Discoverer {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"notify::timeout\0".as_ptr() as *const _,
-                transmute(notify_timeout_trampoline::<Self> as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(notify_timeout_trampoline::<Self, F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
 }
 
-unsafe extern "C" fn notify_timeout_trampoline<P>(
+unsafe extern "C" fn notify_timeout_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
     this: *mut ffi::GstDiscoverer,
     _param_spec: glib_ffi::gpointer,
     f: glib_ffi::gpointer,
@@ -72,6 +72,6 @@ unsafe extern "C" fn notify_timeout_trampoline<P>(
     P: IsA<Discoverer>,
 {
     #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
-    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
+    let f: &F = transmute(f);
     f(&Discoverer::from_glib_borrow(this).unsafe_cast())
 }
diff --git a/gstreamer-player/src/player.rs b/gstreamer-player/src/player.rs
index 704a6c73c..3666ae9b8 100644
--- a/gstreamer-player/src/player.rs
+++ b/gstreamer-player/src/player.rs
@@ -57,13 +57,12 @@ impl Player {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<Box_<Fn(&Player, gst::ClockTime) + Send + 'static>> =
-                Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"duration-changed\0".as_ptr() as *const _,
-                transmute(duration_changed_trampoline as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(duration_changed_trampoline::<F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
@@ -73,13 +72,12 @@ impl Player {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<Box_<Fn(&Player, gst::ClockTime) + Send + 'static>> =
-                Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"position-updated\0".as_ptr() as *const _,
-                transmute(position_updated_trampoline as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(position_updated_trampoline::<F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
@@ -89,44 +87,47 @@ impl Player {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<Box_<Fn(&Player, gst::ClockTime) + Send + 'static>> =
-                Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"seek-done\0".as_ptr() as *const _,
-                transmute(seek_done_trampoline as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(seek_done_trampoline::<F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
 }
 
-unsafe extern "C" fn duration_changed_trampoline(
+unsafe extern "C" fn duration_changed_trampoline<
+    F: Fn(&Player, gst::ClockTime) + Send + 'static,
+>(
     this: *mut ffi::GstPlayer,
     object: u64,
     f: glib_ffi::gpointer,
 ) {
     #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
-    let f: &&(Fn(&Player, gst::ClockTime) + Send + 'static) = transmute(f);
+    let f: &F = transmute(f);
     f(&from_glib_borrow(this), gst::ClockTime(Some(object)))
 }
 
-unsafe extern "C" fn position_updated_trampoline(
+unsafe extern "C" fn position_updated_trampoline<
+    F: Fn(&Player, gst::ClockTime) + Send + 'static,
+>(
     this: *mut ffi::GstPlayer,
     object: u64,
     f: glib_ffi::gpointer,
 ) {
     #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
-    let f: &&(Fn(&Player, gst::ClockTime) + Send + Sync + 'static) = transmute(f);
+    let f: &F = transmute(f);
     f(&from_glib_borrow(this), gst::ClockTime(Some(object)))
 }
 
-unsafe extern "C" fn seek_done_trampoline(
+unsafe extern "C" fn seek_done_trampoline<F: Fn(&Player, gst::ClockTime) + Send + 'static>(
     this: *mut ffi::GstPlayer,
     object: u64,
     f: glib_ffi::gpointer,
 ) {
     #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
-    let f: &&(Fn(&Player, gst::ClockTime) + Send + 'static) = transmute(f);
+    let f: &F = transmute(f);
     f(&from_glib_borrow(this), gst::ClockTime(Some(object)))
 }
diff --git a/gstreamer/src/bin.rs b/gstreamer/src/bin.rs
index e0eee94bf..7f736d5f3 100644
--- a/gstreamer/src/bin.rs
+++ b/gstreamer/src/bin.rs
@@ -85,13 +85,12 @@ impl<O: IsA<Bin>> GstBinExtManual for O {
         f: F,
     ) -> SignalHandlerId {
         unsafe {
-            let f: Box_<Box_<Fn(&Self) -> Result<(), LoggableError> + Send + Sync + 'static>> =
-                Box_::new(Box_::new(f));
+            let f: Box_<F> = Box_::new(f);
             connect_raw(
                 self.as_ptr() as *mut _,
                 b"do-latency\0".as_ptr() as *const _,
-                transmute(do_latency_trampoline::<Self> as usize),
-                Box_::into_raw(f) as *mut _,
+                Some(transmute(do_latency_trampoline::<Self, F> as usize)),
+                Box_::into_raw(f),
             )
         }
     }
@@ -154,14 +153,17 @@ impl<O: IsA<Bin>> GstBinExtManual for O {
     }
 }
 
-unsafe extern "C" fn do_latency_trampoline<P>(
+unsafe extern "C" fn do_latency_trampoline<
+    P,
+    F: Fn(&P) -> Result<(), LoggableError> + Send + Sync + 'static,
+>(
     this: *mut ffi::GstBin,
     f: glib_ffi::gpointer,
 ) -> glib_ffi::gboolean
 where
     P: IsA<Bin>,
 {
-    let f: &&(Fn(&P) -> Result<(), LoggableError> + Send + Sync + 'static) = transmute(f);
+    let f: &F = transmute(f);
     match f(&Bin::from_glib_borrow(this).unsafe_cast()) {
         Ok(()) => true,
         Err(err) => {