Add MainContext checks to manual async functions

Author: bilelmoussaoui

gdk4/src/clipboard.rs

@@ -3,7 +3,7 @@
 use crate::{Clipboard, Texture};
 use glib::object::IsA;
 use glib::translate::*;
-use glib::{GString, ToValue};
+use glib::GString;
 use std::future;
 use std::pin::Pin;
 use std::ptr;
@@ -17,6 +17,16 @@ impl Clipboard {
         cancellable: Option<&impl IsA<gio::Cancellable>>,
         callback: Q,
     ) {
+        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<Q> = Box::new(callback);
         unsafe extern "C" fn read_async_trampoline<
             Q: FnOnce(Result<(gio::InputStream, GString), glib::Error>) + 'static,

gdk4/src/drop.rs

@@ -17,6 +17,16 @@ impl Drop {
         cancellable: Option<&impl IsA<gio::Cancellable>>,
         callback: Q,
     ) {
+        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<Q> = Box::new(callback);
         unsafe extern "C" fn read_async_trampoline<
             Q: FnOnce(Result<(gio::InputStream, GString), glib::Error>) + 'static,

gdk4/src/functions.rs

@@ -41,6 +41,16 @@ pub fn content_deserialize_async<R: FnOnce(Result<glib::Value, glib::Error>) + S
     callback: R,
 ) {
     assert_initialized_main_thread!();
+    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<R> = Box::new(callback);
     unsafe extern "C" fn content_deserialize_async_trampoline<
         R: FnOnce(Result<glib::Value, glib::Error>) + Send + 'static,
@@ -227,6 +237,15 @@ pub fn content_serialize_async<R: FnOnce(Result<(), glib::Error>) + Send + 'stat
     callback: R,
 ) {
     assert_initialized_main_thread!();
+    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<R> = Box::new(callback);
     unsafe extern "C" fn content_serialize_async_trampoline<
         R: FnOnce(Result<(), glib::Error>) + Send + 'static,

gdk4/src/subclass/content_provider.rs

@@ -61,7 +61,7 @@ pub trait ContentProviderImplExt: ObjectSubclass {
 
     fn parent_write_mime_type_async<
         Q: IsA<gio::Cancellable>,
-        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
     >(
         &self,
         provider: &Self::Type,
@@ -163,7 +163,7 @@ impl<T: ContentProviderImpl> ContentProviderImplExt for T {
 
     fn parent_write_mime_type_async<
         Q: IsA<gio::Cancellable>,
-        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
+        R: FnOnce(Result<(), glib::Error>) + 'static,
     >(
         &self,
         provider: &Self::Type,
@@ -174,6 +174,16 @@ impl<T: ContentProviderImpl> ContentProviderImplExt for T {
         callback: R,
     ) {
         unsafe {
+            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 data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GdkContentProviderClass;
             let f = (*parent_class)
@@ -186,7 +196,7 @@ impl<T: ContentProviderImpl> ContentProviderImplExt for T {
             let user_data: Box<(R, _)> = Box::new((callback, finish));
 
             unsafe extern "C" fn parent_write_mime_type_async_trampoline<
-                R: FnOnce(Result<(), glib::Error>) + Send + 'static,
+                R: FnOnce(Result<(), glib::Error>) + 'static,
             >(
                 source_object_ptr: *mut glib::gobject_ffi::GObject,
                 res: *mut gio::ffi::GAsyncResult,