From 3db1c9266335f9301f11efd86b7dc533c7e0039d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Sun, 1 Apr 2018 12:12:27 +0300
Subject: [PATCH] Use ptr::NonNull in various places

---
 gst-plugin/src/base_sink.rs      | 26 +++++++++++++-------------
 gst-plugin/src/base_src.rs       | 30 +++++++++++++++---------------
 gst-plugin/src/base_transform.rs | 26 +++++++++++++-------------
 gst-plugin/src/bin.rs            |  6 +++---
 gst-plugin/src/element.rs        | 12 ++++++------
 gst-plugin/src/lib.rs            |  9 ++++++---
 gst-plugin/src/object.rs         | 31 +++++++++++++++++--------------
 7 files changed, 73 insertions(+), 67 deletions(-)

diff --git a/gst-plugin/src/base_sink.rs b/gst-plugin/src/base_sink.rs
index 2f7f7de1..2edc53c2 100644
--- a/gst-plugin/src/base_sink.rs
+++ b/gst-plugin/src/base_sink.rs
@@ -306,7 +306,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib()
 }
@@ -321,7 +321,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib()
 }
@@ -337,7 +337,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let buffer = gst::BufferRef::from_ptr(buffer);
 
     panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
@@ -356,7 +356,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let buffer = gst::BufferRef::from_ptr(buffer);
 
     panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
@@ -375,7 +375,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let list = gst::BufferListRef::from_ptr(list);
 
     panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
@@ -394,7 +394,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let list = gst::BufferListRef::from_ptr(list);
 
     panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
@@ -413,7 +413,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let query = gst::QueryRef::from_mut_ptr(query_ptr);
 
     panic_to_error!(&wrap, &element.panicked, false, {
@@ -432,7 +432,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.event(&wrap, from_glib_full(event_ptr))
@@ -450,7 +450,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let filter = if filter.is_null() {
         None
     } else {
@@ -474,7 +474,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let caps = gst::CapsRef::from_ptr(caps);
 
     panic_to_error!(&wrap, &element.panicked, false, {
@@ -493,7 +493,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let caps = from_glib_full(caps);
 
     panic_to_error!(&wrap, &element.panicked, gst::Caps::new_empty(), {
@@ -511,7 +511,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.unlock(&wrap) }).to_glib()
 }
@@ -526,7 +526,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.unlock_stop(&wrap) }).to_glib()
 }
diff --git a/gst-plugin/src/base_src.rs b/gst-plugin/src/base_src.rs
index 3bdb0488..4da1aa71 100644
--- a/gst-plugin/src/base_src.rs
+++ b/gst-plugin/src/base_src.rs
@@ -377,7 +377,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib()
 }
@@ -392,7 +392,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib()
 }
@@ -407,7 +407,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.is_seekable(&wrap) }).to_glib()
 }
@@ -423,7 +423,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         match imp.get_size(&wrap) {
@@ -449,7 +449,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let buffer = gst::BufferRef::from_mut_ptr(buffer);
 
     panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
@@ -470,7 +470,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     // FIXME: Wrong signature in -sys bindings
     // https://github.com/sdroege/gstreamer-sys/issues/3
     let buffer_ptr = buffer_ptr as *mut *mut gst_ffi::GstBuffer;
@@ -497,7 +497,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.do_seek(&wrap, &mut from_glib_borrow(segment))
@@ -515,7 +515,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let query = gst::QueryRef::from_mut_ptr(query_ptr);
 
     panic_to_error!(&wrap, &element.panicked, false, {
@@ -534,7 +534,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.event(&wrap, &from_glib_none(event_ptr))
@@ -552,7 +552,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let filter = if filter.is_null() {
         None
     } else {
@@ -575,7 +575,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.negotiate(&wrap) }).to_glib()
 }
@@ -591,7 +591,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let caps = gst::CapsRef::from_ptr(caps);
 
     panic_to_error!(&wrap, &element.panicked, false, {
@@ -610,7 +610,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let caps = from_glib_full(caps);
 
     panic_to_error!(&wrap, &element.panicked, gst::Caps::new_empty(), {
@@ -628,7 +628,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.unlock(&wrap) }).to_glib()
 }
@@ -643,7 +643,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.unlock_stop(&wrap) }).to_glib()
 }
diff --git a/gst-plugin/src/base_transform.rs b/gst-plugin/src/base_transform.rs
index 989fbd2a..01743aaf 100644
--- a/gst-plugin/src/base_transform.rs
+++ b/gst-plugin/src/base_transform.rs
@@ -435,7 +435,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib()
 }
@@ -450,7 +450,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib()
 }
@@ -468,7 +468,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, gst::Caps::new_empty(), {
         let filter = if filter.is_null() {
@@ -499,7 +499,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, gst::Caps::new_empty(), {
         imp.fixate_caps(
@@ -523,7 +523,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.set_caps(&wrap, &from_glib_borrow(incaps), &from_glib_borrow(outcaps))
@@ -542,7 +542,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.accept_caps(&wrap, from_glib(direction), &from_glib_borrow(caps))
@@ -561,7 +561,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         BaseTransformImpl::query(
@@ -588,7 +588,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         match imp.transform_size(
@@ -619,7 +619,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         match imp.get_unit_size(&wrap, &from_glib_borrow(caps)) {
@@ -643,7 +643,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.sink_event(&wrap, from_glib_full(event))
@@ -661,7 +661,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.src_event(&wrap, from_glib_full(event))
@@ -680,7 +680,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
         imp.transform(
@@ -702,7 +702,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     // FIXME: Wrong signature in FFI
     let buf = buf as *mut gst_ffi::GstBuffer;
diff --git a/gst-plugin/src/bin.rs b/gst-plugin/src/bin.rs
index 1bbb5e54..66ba23da 100644
--- a/gst-plugin/src/bin.rs
+++ b/gst-plugin/src/bin.rs
@@ -162,7 +162,7 @@ where
     floating_reference_guard!(ptr);
     let bin = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*bin.imp;
+    let imp = bin.imp.as_ref();
 
     panic_to_error!(&wrap, &bin.panicked, false, {
         imp.add_element(&wrap, &from_glib_none(element))
@@ -180,7 +180,7 @@ where
     floating_reference_guard!(ptr);
     let bin = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*bin.imp;
+    let imp = bin.imp.as_ref();
 
     panic_to_error!(&wrap, &bin.panicked, false, {
         imp.remove_element(&wrap, &from_glib_none(element))
@@ -197,7 +197,7 @@ unsafe extern "C" fn bin_handle_message<T: BinBase>(
     floating_reference_guard!(ptr);
     let bin = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*bin.imp;
+    let imp = bin.imp.as_ref();
 
     panic_to_error!(&wrap, &bin.panicked, (), {
         imp.handle_message(&wrap, from_glib_full(message))
diff --git a/gst-plugin/src/element.rs b/gst-plugin/src/element.rs
index bfadaa6f..8a2000fa 100644
--- a/gst-plugin/src/element.rs
+++ b/gst-plugin/src/element.rs
@@ -242,7 +242,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     // *Never* fail downwards state changes, this causes bugs in GStreamer
     // and leads to crashes and deadlocks.
@@ -272,7 +272,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let caps = if caps.is_null() {
         None
     } else {
@@ -308,7 +308,7 @@ unsafe extern "C" fn element_release_pad<T: ElementBase>(
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, (), {
         imp.release_pad(&wrap, &from_glib_borrow(pad))
@@ -326,7 +326,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, false, {
         imp.send_event(&wrap, from_glib_full(event))
@@ -344,7 +344,7 @@ where
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
     let query = gst::QueryRef::from_mut_ptr(query);
 
     panic_to_error!(&wrap, &element.panicked, false, { imp.query(&wrap, query) }).to_glib()
@@ -360,7 +360,7 @@ unsafe extern "C" fn element_set_context<T: ElementBase>(
     floating_reference_guard!(ptr);
     let element = &*(ptr as *mut InstanceStruct<T>);
     let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
-    let imp = &*element.imp;
+    let imp = element.imp.as_ref();
 
     panic_to_error!(&wrap, &element.panicked, (), {
         imp.set_context(&wrap, &from_glib_borrow(context))
diff --git a/gst-plugin/src/lib.rs b/gst-plugin/src/lib.rs
index 26986bf9..72a2c6b7 100644
--- a/gst-plugin/src/lib.rs
+++ b/gst-plugin/src/lib.rs
@@ -22,6 +22,8 @@ pub extern crate glib;
 pub extern crate gstreamer as gst;
 extern crate gstreamer_base as gst_base;
 
+use std::ptr;
+
 macro_rules! callback_guard {
     () => (
         let _guard = ::glib::CallbackGuard::new();
@@ -34,13 +36,14 @@ macro_rules! floating_reference_guard {
     )
 }
 
-pub struct FloatingReferenceGuard(*mut gobject_ffi::GObject);
+pub struct FloatingReferenceGuard(ptr::NonNull<gobject_ffi::GObject>);
 
 impl FloatingReferenceGuard {
     pub unsafe fn new(obj: *mut gobject_ffi::GObject) -> Option<FloatingReferenceGuard> {
+        assert!(!obj.is_null());
         if gobject_ffi::g_object_is_floating(obj) != glib_ffi::GFALSE {
             gobject_ffi::g_object_ref_sink(obj);
-            Some(FloatingReferenceGuard(obj))
+            Some(FloatingReferenceGuard(ptr::NonNull::new_unchecked(obj)))
         } else {
             None
         }
@@ -50,7 +53,7 @@ impl FloatingReferenceGuard {
 impl Drop for FloatingReferenceGuard {
     fn drop(&mut self) {
         unsafe {
-            gobject_ffi::g_object_force_floating(self.0);
+            gobject_ffi::g_object_force_floating(self.0.as_ptr());
         }
     }
 }
diff --git a/gst-plugin/src/object.rs b/gst-plugin/src/object.rs
index 6a2b2363..316621b1 100644
--- a/gst-plugin/src/object.rs
+++ b/gst-plugin/src/object.rs
@@ -109,13 +109,13 @@ macro_rules! object_type_fns(
 #[repr(C)]
 pub struct InstanceStruct<T: ObjectType> {
     pub parent: T::GlibType,
-    pub imp: *const T::ImplType,
+    pub imp: ptr::NonNull<T::ImplType>,
     pub panicked: AtomicBool,
 }
 
 impl<T: ObjectType> InstanceStruct<T> {
     pub fn get_impl(&self) -> &T::ImplType {
-        unsafe { &*self.imp }
+        unsafe { self.imp.as_ref() }
     }
 
     pub unsafe fn get_class(&self) -> *const ClassStruct<T> {
@@ -126,14 +126,14 @@ impl<T: ObjectType> InstanceStruct<T> {
 #[repr(C)]
 pub struct ClassStruct<T: ObjectType> {
     pub parent: T::GlibClassType,
-    pub imp_static: *const Box<ImplTypeStatic<T>>,
-    pub parent_class: *const T::GlibClassType,
+    pub imp_static: ptr::NonNull<Box<ImplTypeStatic<T>>>,
+    pub parent_class: ptr::NonNull<T::GlibClassType>,
     pub interfaces_static: *const Vec<(glib_ffi::GType, glib_ffi::gpointer)>,
 }
 
 impl<T: ObjectType> ClassStruct<T> {
-    pub unsafe fn get_parent_class(&self) -> *const T::GlibClassType {
-        self.parent_class
+    pub fn get_parent_class(&self) -> *const T::GlibClassType {
+        self.parent_class.as_ptr()
     }
 }
 
@@ -289,9 +289,11 @@ unsafe extern "C" fn class_init<T: ObjectType>(
 
     {
         let klass = &mut *(klass as *mut ClassStruct<T>);
-        klass.parent_class = gobject_ffi::g_type_class_peek_parent(
+        let parent_class = gobject_ffi::g_type_class_peek_parent(
             klass as *mut _ as glib_ffi::gpointer,
-        ) as *const T::GlibClassType;
+        ) as *mut T::GlibClassType;
+        assert!(!parent_class.is_null());
+        klass.parent_class = ptr::NonNull::new_unchecked(parent_class);
         T::class_init(&ClassInitToken(()), klass);
     }
 }
@@ -300,8 +302,8 @@ unsafe extern "C" fn finalize<T: ObjectType>(obj: *mut gobject_ffi::GObject) {
     callback_guard!();
     let instance = &mut *(obj as *mut InstanceStruct<T>);
 
-    drop(Box::from_raw(instance.imp as *mut T::ImplType));
-    instance.imp = ptr::null_mut();
+    drop(Box::from_raw(instance.imp.as_ptr()));
+    instance.imp = ptr::NonNull::dangling();
 
     let klass = *(obj as *const glib_ffi::gpointer);
     let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
@@ -407,9 +409,10 @@ unsafe extern "C" fn sub_class_init<T: ObjectType>(
         gobject_klass.get_property = Some(sub_get_property::<T>);
     }
     {
+        assert!(!klass_data.is_null());
         let klass = &mut *(klass as *mut ClassStruct<T>);
-        let imp_static = klass_data as *const Box<ImplTypeStatic<T>>;
-        klass.imp_static = imp_static;
+        let imp_static = klass_data as *mut Box<ImplTypeStatic<T>>;
+        klass.imp_static = ptr::NonNull::new_unchecked(imp_static);
         klass.interfaces_static = Box::into_raw(Box::new(Vec::new()));
 
         (*imp_static).class_init(klass);
@@ -464,8 +467,8 @@ unsafe extern "C" fn sub_init<T: ObjectType>(
     let klass = &**(obj as *const *const ClassStruct<T>);
     let rs_instance: T = from_glib_borrow(obj as *mut InstanceStruct<T>);
 
-    let imp = (*klass.imp_static).new(&rs_instance);
-    instance.imp = Box::into_raw(Box::new(imp));
+    let imp = klass.imp_static.as_ref().new(&rs_instance);
+    instance.imp = ptr::NonNull::new_unchecked(Box::into_raw(Box::new(imp)));
 }
 
 pub fn register_type<T: ObjectType, I: ImplTypeStatic<T>>(imp: I) -> glib::Type {