gio: Use OwnedSocket / BorrowedSocket for Windows APIs on GSocket

cairo/src/surface.rs

@@ -78,14 +78,16 @@ impl Surface {
     #[doc(alias = "cairo_surface_get_mime_data")]
     #[doc(alias = "get_mime_data")]
     pub fn mime_data(&self, mime_type: &str) -> Option<Vec<u8>> {
-        let data_ptr: *mut u8 = ptr::null_mut();
+        let mut data_ptr: *mut u8 = ptr::null_mut();
         let mut length: c_ulong = 0;
+        // The function actually needs a mutable pointer
+        #[allow(clippy::unnecessary_mut_passed)]
         unsafe {
             let mime_type = CString::new(mime_type).unwrap();
             ffi::cairo_surface_get_mime_data(
                 self.to_raw_none(),
                 mime_type.as_ptr(),
-                &data_ptr,
+                &mut data_ptr,
                 &mut length,
             );
             if !data_ptr.is_null() && length != 0 {
@@ -99,15 +101,19 @@ impl Surface {
     #[doc(alias = "cairo_surface_get_mime_data")]
     #[doc(alias = "get_mime_data_raw")]
     pub unsafe fn mime_data_raw(&self, mime_type: &str) -> Option<&[u8]> {
-        let data_ptr: *mut u8 = ptr::null_mut();
+        let mut data_ptr: *mut u8 = ptr::null_mut();
         let mut length: c_ulong = 0;
         let mime_type = CString::new(mime_type).unwrap();
-        ffi::cairo_surface_get_mime_data(
-            self.to_raw_none(),
-            mime_type.as_ptr(),
-            &data_ptr,
-            &mut length,
-        );
+        // The function actually needs a mutable pointer
+        #[allow(clippy::unnecessary_mut_passed)]
+        {
+            ffi::cairo_surface_get_mime_data(
+                self.to_raw_none(),
+                mime_type.as_ptr(),
+                &mut data_ptr,
+                &mut length,
+            );
+        }
         if !data_ptr.is_null() && length != 0 {
             Some(slice::from_raw_parts(
                 data_ptr as *const u8,

gdk-pixbuf/src/pixbuf.rs

@@ -35,7 +35,7 @@ impl Pixbuf {
         let bits_per_sample = bits_per_sample as usize;
 
         let n_channels = if has_alpha { 4 } else { 3 };
-        let last_row_len = width * ((n_channels * bits_per_sample + 7) / 8);
+        let last_row_len = width * (n_channels * bits_per_sample).div_ceil(8);
 
         let mut data: Box<T> = Box::new(data);
 

gio/src/input_stream.rs

@@ -417,7 +417,7 @@ impl<T: IsA<InputStream>> InputStreamAsyncBufRead<T> {
 
     fn set_has_data(&mut self, buffer: Vec<u8>, valid: (usize, usize)) {
         match self.state {
-            State::Reading { .. } | State::Transitioning { .. } => {
+            State::Reading { .. } | State::Transitioning => {
                 self.state = State::HasData { buffer, valid }
             }
             _ => panic!("Invalid state"),

gio/src/socket.rs

@@ -3,7 +3,9 @@
 #[cfg(unix)]
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 #[cfg(windows)]
-use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
+use std::os::windows::io::{
+    AsRawSocket, AsSocket, BorrowedSocket, FromRawSocket, IntoRawSocket, OwnedSocket, RawSocket,
+};
 #[cfg(feature = "v2_60")]
 use std::time::Duration;
 use std::{cell::RefCell, marker::PhantomData, mem::transmute, pin::Pin, ptr};
@@ -27,22 +29,24 @@ impl Socket {
             if error.is_null() {
                 Ok(from_glib_full(ret))
             } else {
-                libc::close(fd);
+                let _ = OwnedFd::from_raw_fd(fd);
                 Err(from_glib_full(error))
             }
         }
     }
     #[cfg(windows)]
     #[cfg_attr(docsrs, doc(cfg(windows)))]
-    #[allow(clippy::missing_safety_doc)]
-    pub unsafe fn from_socket(socket: impl IntoRawSocket) -> Result<Socket, glib::Error> {
+    pub fn from_socket(socket: OwnedSocket) -> Result<Socket, glib::Error> {
         let socket = socket.into_raw_socket();
         let mut error = ptr::null_mut();
-        let ret = ffi::g_socket_new_from_fd(socket as i32, &mut error);
-        if error.is_null() {
-            Ok(from_glib_full(ret))
-        } else {
-            Err(from_glib_full(error))
+        unsafe {
+            let ret = ffi::g_socket_new_from_fd(socket as i32, &mut error);
+            if error.is_null() {
+                Ok(from_glib_full(ret))
+            } else {
+                let _ = OwnedSocket::from_raw_socket(socket);
+                Err(from_glib_full(error))
+            }
         }
     }
 }
@@ -74,6 +78,17 @@ impl AsRawSocket for Socket {
     }
 }
 
+#[cfg(windows)]
+#[cfg_attr(docsrs, doc(cfg(windows)))]
+impl AsSocket for Socket {
+    fn as_socket(&self) -> BorrowedSocket<'_> {
+        unsafe {
+            let raw_socket = self.as_raw_socket();
+            BorrowedSocket::borrow_raw(raw_socket)
+        }
+    }
+}
+
 #[doc(alias = "GInputVector")]
 #[repr(transparent)]
 #[derive(Debug)]
@@ -646,18 +661,16 @@ pub trait SocketExtManual: IsA<Socket> + Sized {
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[doc(alias = "get_fd")]
     #[doc(alias = "g_socket_get_fd")]
-    fn fd<T: FromRawFd>(&self) -> T {
-        unsafe { FromRawFd::from_raw_fd(ffi::g_socket_get_fd(self.as_ref().to_glib_none().0)) }
+    fn fd(&self) -> BorrowedFd<'_> {
+        self.as_ref().as_fd()
     }
 
     #[cfg(windows)]
     #[cfg_attr(docsrs, doc(cfg(windows)))]
     #[doc(alias = "get_socket")]
     #[doc(alias = "g_socket_get_fd")]
-    fn socket<T: FromRawSocket>(&self) -> T {
-        unsafe {
-            FromRawSocket::from_raw_socket(ffi::g_socket_get_fd(self.as_ref().to_glib_none().0) as _)
-        }
+    fn socket(&self) -> BorrowedSocket<'_> {
+        self.as_ref().as_socket()
     }
 
     #[doc(alias = "g_socket_create_source")]