Store allocation size to re-create layout (#41)

Author: DoumanAsh

src/raw.rs

@@ -40,7 +40,7 @@ fn invalid_data() -> ErrorCode {
 }
 
 #[inline(always)]
-fn free_dc(data: HDC) {
+fn free_dc(data: HDC, _: usize) {
     unsafe {
         ReleaseDC(ptr::null_mut(), data);
     }
@@ -738,7 +738,7 @@ pub fn get_bitmap(out: &mut alloc::vec::Vec<u8>) -> SysResult<usize> {
     let img_size = header.bmiHeader.biSizeImage as usize;
     let out_before = out.len();
 
-    let dc = crate::utils::Scope(unsafe { GetDC(ptr::null_mut()) }, free_dc);
+    let dc = crate::utils::Scope(unsafe { GetDC(ptr::null_mut()) }, free_dc, 0);
     let mut buffer = alloc::vec![0; img_size];
 
     if unsafe { GetDIBits(dc.0, clipboard_data.as_ptr() as _, 0, bitmap.bmHeight as _, buffer.as_mut_ptr() as _, header_storage.get() as _, DIB_RGB_COLORS) } == 0 {
@@ -829,7 +829,7 @@ fn set_bitmap_inner(data: &[u8], clear: EmptyFn) -> SysResult<()> {
         return Err(ErrorCode::new_system(ERROR_INCORRECT_SIZE as _));
     }
 
-    let dc = crate::utils::Scope(unsafe { GetDC(ptr::null_mut()) }, free_dc);
+    let dc = crate::utils::Scope(unsafe { GetDC(ptr::null_mut()) }, free_dc, 0);
 
     let handle = unsafe {
         CreateDIBitmap(dc.0, &info_header as _, CBM_INIT, bitmap.as_ptr() as _, &info_header as *const _ as *const BITMAPINFO, DIB_RGB_COLORS)

src/utils.rs

@@ -22,36 +22,37 @@ pub fn unlikely_last_error() -> ErrorCode {
 }
 
 #[inline]
-fn noop(_: *mut c_void) {
+fn noop(_: *mut c_void, _: usize) {
 }
 
 #[inline]
-fn free_rust_mem(data: *mut c_void) {
+fn free_rust_mem(data: *mut c_void, size: usize) {
+    let layout = alloc::alloc::Layout::array::<u8>(size).unwrap_or(BYTES_LAYOUT);
     unsafe {
-        alloc::alloc::dealloc(data as _, BYTES_LAYOUT)
+        alloc::alloc::dealloc(data as _, layout)
     }
 }
 
 #[inline]
-fn unlock_data(data: *mut c_void) {
+fn unlock_data(data: *mut c_void, _: usize) {
     unsafe {
         sys::GlobalUnlock(data);
     }
 }
 
 #[inline]
-fn free_global_mem(data: *mut c_void) {
+fn free_global_mem(data: *mut c_void, _: usize) {
     unsafe {
         sys::GlobalFree(data);
     }
 }
 
-pub struct Scope<T: Copy>(pub T, pub fn(T));
+pub struct Scope<T: Copy>(pub T, pub fn(T, usize), pub usize);
 
 impl<T: Copy> Drop for Scope<T> {
     #[inline(always)]
     fn drop(&mut self) {
-        (self.1)(self.0)
+        (self.1)(self.0, self.2)
     }
 }
 
@@ -67,7 +68,7 @@ impl RawMem {
         if mem.is_null() {
             Err(unlikely_last_error())
         } else {
-            Ok(Self(Scope(mem as _, free_rust_mem)))
+            Ok(Self(Scope(mem as _, free_rust_mem, size)))
         }
     }
 
@@ -78,21 +79,26 @@ impl RawMem {
             if mem.is_null() {
                 Err(unlikely_last_error())
             } else {
-                Ok(Self(Scope(mem, free_global_mem)))
+                Ok(Self(Scope(mem, free_global_mem, size)))
             }
         }
     }
 
     #[inline(always)]
     pub fn from_borrowed(ptr: ptr::NonNull<c_void>) -> Self {
-        Self(Scope(ptr.as_ptr(), noop))
+        Self(Scope(ptr.as_ptr(), noop, 0))
     }
 
     #[inline(always)]
     pub fn get(&self) -> *mut c_void {
         (self.0).0
     }
 
+    #[inline(always)]
+    pub fn size(&self) -> usize {
+        (self.0).2
+    }
+
     #[inline(always)]
     pub fn release(self) {
         mem::forget(self)
@@ -104,7 +110,7 @@ impl RawMem {
         };
 
         match ptr::NonNull::new(ptr) {
-            Some(ptr) => Ok((ptr, Scope(self.get(), unlock_data))),
+            Some(ptr) => Ok((ptr, Scope(self.get(), unlock_data, self.size()))),
             None => Err(ErrorCode::last_system()),
         }
     }