Add Owned::into_raw to relinquish ownership of an handle

crates/libs/core/src/handles.rs

@@ -2,7 +2,7 @@
 ///
 /// This is similar to the [`Drop`] trait, and may be used to implement [`Drop`], but allows handles
 /// to be dropped depending on context.
-pub trait Free {
+pub trait Free : Clone {
     /// Calls the handle's free function.
     ///
     /// # Safety
@@ -24,6 +24,14 @@ impl<T: Free> Owned<T> {
     pub unsafe fn new(x: T) -> Self {
         Self(x)
     }
+
+    /// Consumes the `Owned<T>` and relinquishes ownership of the handle.
+    /// The caller is now responsible for freeing the returned handle.
+    #[must_use = "losing the handle will leak it"]
+    pub fn into_raw(o: Self) -> T {
+        let o = core::mem::ManuallyDrop::new(o);
+        o.0.clone()
+    }
 }
 
 impl<T: Free> Drop for Owned<T> {

crates/tests/libs/core/tests/handles.rs

@@ -0,0 +1,47 @@
+use std::cell::Cell;
+use std::rc::Rc;
+
+use windows::core::Free;
+use windows::core::Owned;
+
+#[derive(Clone)]
+struct FreeCounter {
+    pub count: Rc<Cell<u32>>,
+}
+
+impl Free for FreeCounter {
+    unsafe fn free(&mut self) {
+        self.count.update(|c| c + 1);
+    }
+}
+
+#[test]
+fn into_raw() {
+    let free_count: Rc<Cell<u32>> = Rc::new(Cell::new(0));
+    let counter = FreeCounter {
+        count: free_count.clone(),
+    };
+
+    {
+        let owned = unsafe { Owned::new(counter) };
+        let _counter = Owned::into_raw(owned);
+        assert!(free_count.get() == 0);
+    }
+
+    assert!(free_count.get() == 0);
+}
+
+#[test]
+fn drop() {
+    let free_count: Rc<Cell<u32>> = Rc::new(Cell::new(0));
+    let counter = FreeCounter {
+        count: free_count.clone(),
+    };
+
+    {
+        let _owned = unsafe { Owned::new(counter) };
+        assert!(free_count.get() == 0);
+    }
+
+    assert!(free_count.get() == 1);
+}