Remove unnecessary Send bounds from GIO-style async functions

sdroege · bilelmoussaoui · commit 5af9f12972ee · 2022-01-28T19:21:18.000+01:00
diff --git a/gdk4/src/clipboard.rs b/gdk4/src/clipboard.rs
@@ -27,7 +27,8 @@ impl Clipboard {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box<Q> = Box::new(callback);
+        let user_data: Box<glib::thread_guard::ThreadGuard<Q>> =
+            Box::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn read_async_trampoline<
             Q: FnOnce(Result<(gio::InputStream, GString), glib::Error>) + 'static,
         >(
@@ -48,7 +49,9 @@ impl Clipboard {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box<Q> = Box::from_raw(user_data as *mut _);
+            let callback: Box<glib::thread_guard::ThreadGuard<Q>> =
+                Box::from_raw(user_data as *mut _);
+            let callback = callback.into_inner();
             callback(result);
         }
         let callback = read_async_trampoline::<Q>;
diff --git a/gdk4/src/drop.rs b/gdk4/src/drop.rs
@@ -27,7 +27,8 @@ impl Drop {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box<Q> = Box::new(callback);
+        let user_data: Box<glib::thread_guard::ThreadGuard<Q>> =
+            Box::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn read_async_trampoline<
             Q: FnOnce(Result<(gio::InputStream, GString), glib::Error>) + 'static,
         >(
@@ -48,7 +49,9 @@ impl Drop {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box<Q> = Box::from_raw(user_data as *mut _);
+            let callback: Box<glib::thread_guard::ThreadGuard<Q>> =
+                Box::from_raw(user_data as *mut _);
+            let callback = callback.into_inner();
             callback(result);
         }
         let callback = read_async_trampoline::<Q>;
diff --git a/gdk4/src/functions.rs b/gdk4/src/functions.rs
@@ -32,7 +32,7 @@ pub fn pango_layout_get_clip_region(
 }
 
 #[doc(alias = "gdk_content_deserialize_async")]
-pub fn content_deserialize_async<R: FnOnce(Result<glib::Value, glib::Error>) + Send + 'static>(
+pub fn content_deserialize_async<R: FnOnce(Result<glib::Value, glib::Error>) + 'static>(
     stream: &impl IsA<gio::InputStream>,
     mime_type: &str,
     type_: glib::types::Type,
@@ -51,9 +51,10 @@ pub fn content_deserialize_async<R: FnOnce(Result<glib::Value, glib::Error>) + S
         "Async operations only allowed if the thread is owning the MainContext"
     );
 
-    let user_data: Box<R> = Box::new(callback);
+    let user_data: Box<glib::thread_guard::ThreadGuard<R>> =
+        Box::new(glib::thread_guard::ThreadGuard::new(callback));
     unsafe extern "C" fn content_deserialize_async_trampoline<
-        R: FnOnce(Result<glib::Value, glib::Error>) + Send + 'static,
+        R: FnOnce(Result<glib::Value, glib::Error>) + 'static,
     >(
         _source_object: *mut glib::gobject_ffi::GObject,
         res: *mut gio::ffi::GAsyncResult,
@@ -67,7 +68,8 @@ pub fn content_deserialize_async<R: FnOnce(Result<glib::Value, glib::Error>) + S
         } else {
             Err(from_glib_full(error))
         };
-        let callback: Box<R> = Box::from_raw(user_data as *mut _);
+        let callback: Box<glib::thread_guard::ThreadGuard<R>> = Box::from_raw(user_data as *mut _);
+        let callback = callback.into_inner();
         callback(result);
     }
     let callback = content_deserialize_async_trampoline::<R>;
@@ -228,7 +230,7 @@ pub fn content_register_serializer<
 }
 
 #[doc(alias = "gdk_content_serialize_async")]
-pub fn content_serialize_async<R: FnOnce(Result<(), glib::Error>) + Send + 'static>(
+pub fn content_serialize_async<R: FnOnce(Result<(), glib::Error>) + 'static>(
     stream: &impl IsA<gio::OutputStream>,
     mime_type: &str,
     value: &glib::Value,
@@ -246,9 +248,10 @@ pub fn content_serialize_async<R: FnOnce(Result<(), glib::Error>) + Send + 'stat
         is_main_context_owner || has_acquired_main_context.is_some(),
         "Async operations only allowed if the thread is owning the MainContext"
     );
-    let user_data: Box<R> = Box::new(callback);
+    let user_data: Box<glib::thread_guard::ThreadGuard<R>> =
+        Box::new(glib::thread_guard::ThreadGuard::new(callback));
     unsafe extern "C" fn content_serialize_async_trampoline<
-        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
     >(
         _source_object: *mut glib::gobject_ffi::GObject,
         res: *mut gio::ffi::GAsyncResult,
@@ -261,7 +264,8 @@ pub fn content_serialize_async<R: FnOnce(Result<(), glib::Error>) + Send + 'stat
         } else {
             Err(from_glib_full(error))
         };
-        let callback: Box<R> = Box::from_raw(user_data as *mut _);
+        let callback: Box<glib::thread_guard::ThreadGuard<R>> = Box::from_raw(user_data as *mut _);
+        let callback = callback.into_inner();
         callback(result);
     }
     let callback = content_serialize_async_trampoline::<R>;
diff --git a/gdk4/src/subclass/content_provider.rs b/gdk4/src/subclass/content_provider.rs
@@ -193,7 +193,8 @@ impl<T: ContentProviderImpl> ContentProviderImplExt for T {
                 .write_mime_type_finish
                 .expect("no parent \"write_mime_type_finish\" implementation");
 
-            let user_data: Box<(R, _)> = Box::new((callback, finish));
+            let user_data: Box<(glib::thread_guard::ThreadGuard<R>, _)> =
+                Box::new((glib::thread_guard::ThreadGuard::new(callback), finish));
 
             unsafe extern "C" fn parent_write_mime_type_async_trampoline<
                 R: FnOnce(Result<(), glib::Error>) + 'static,
@@ -204,7 +205,7 @@ impl<T: ContentProviderImpl> ContentProviderImplExt for T {
             ) {
                 let mut error = std::ptr::null_mut();
                 let cb: Box<(
-                    R,
+                    glib::thread_guard::ThreadGuard<R>,
                     fn(
                         *mut ffi::GdkContentProvider,
                         *mut gio::ffi::GAsyncResult,
@@ -217,7 +218,8 @@ impl<T: ContentProviderImpl> ContentProviderImplExt for T {
                 } else {
                     Err(from_glib_full(error))
                 };
-                cb.0(result);
+                let cb = cb.0.into_inner();
+                cb(result);
             }
 
             let cancellable = cancellable.map(|p| p.as_ref());
diff --git a/gtk4/src/functions.rs b/gtk4/src/functions.rs
@@ -58,18 +58,27 @@ pub fn accelerator_parse_with_keycode(
 
 #[doc(alias = "gtk_show_uri_full")]
 #[doc(alias = "gtk_show_uri_full_finish")]
-pub fn show_uri_full<P: FnOnce(Result<(), glib::Error>) + Send + 'static>(
+pub fn show_uri_full<P: FnOnce(Result<(), glib::Error>) + 'static>(
     parent: Option<&impl IsA<Window>>,
     uri: &str,
     timestamp: u32,
     cancellable: Option<&impl IsA<gio::Cancellable>>,
     callback: P,
 ) {
     assert_initialized_main_thread!();
-    let user_data: Box_<P> = Box_::new(callback);
-    unsafe extern "C" fn show_uri_full_trampoline<
-        P: FnOnce(Result<(), glib::Error>) + Send + 'static,
-    >(
+    let main_context = glib::MainContext::ref_thread_default();
+    let is_main_context_owner = main_context.is_owner();
+    let has_acquired_main_context = (!is_main_context_owner)
+        .then(|| main_context.acquire().ok())
+        .flatten();
+    assert!(
+        is_main_context_owner || has_acquired_main_context.is_some(),
+        "Async operations only allowed if the thread is owning the MainContext"
+    );
+
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn show_uri_full_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
         parent_ptr: *mut glib::gobject_ffi::GObject,
         res: *mut gio::ffi::GAsyncResult,
         user_data: glib::ffi::gpointer,
@@ -81,7 +90,9 @@ pub fn show_uri_full<P: FnOnce(Result<(), glib::Error>) + Send + 'static>(
         } else {
             Err(from_glib_full(error))
         };
-        let callback: Box_<P> = Box_::from_raw(user_data as *mut _);
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback = callback.into_inner();
         callback(result);
     }
     let callback = show_uri_full_trampoline::<P>;
