remove calls of WithPointerTransferOriginal from bins and elements since it was a possible source of mem leaks

TODO: other usages include base_src/sink/transform push_src and URI handler

gst/gst_bin_exports.go

@@ -10,96 +10,119 @@ import (
 	"github.com/go-gst/go-glib/glib"
 )
 
-func cbWrapBin(bin *C.GstBin) *Bin {
-	return wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-}
-
-func cbWrapElement(elem *C.GstElement) *Element {
-	return wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-}
-
 //export goGstBinAddElement
-func goGstBinAddElement(bin *C.GstBin, element *C.GstElement) C.gboolean {
+func goGstBinAddElement(bin *C.GstBin, child *C.GstElement) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		caller := obj.(interface {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-			AddElement(self *Bin, element *Element) bool
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-		})
+
-		ret = caller.AddElement(wrapBin(gobj), cbWrapElement(element))
+	gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
+
+	caller := subclass.(interface {
+		AddElement(self *Bin, element *Element) bool
 	})
+	ret = caller.AddElement(goBin, gochild)
+
 	return gboolean(ret)
 }
 
 //export goGstBinDeepElementAdded
 func goGstBinDeepElementAdded(bin *C.GstBin, subbin *C.GstBin, child *C.GstElement) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		caller := obj.(interface {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-			DeepElementAdded(self *Bin, subbin *Bin, child *Element)
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-		})
+
-		caller.DeepElementAdded(wrapBin(gobj), cbWrapBin(subbin), cbWrapElement(child))
+	gosubbin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(subbin))})
+	gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
+
+	caller := subclass.(interface {
+		DeepElementAdded(self *Bin, subbin *Bin, child *Element)
 	})
+	caller.DeepElementAdded(goBin, gosubbin, gochild)
 }
 
 //export goGstBinDeepElementRemoved
 func goGstBinDeepElementRemoved(bin *C.GstBin, subbin *C.GstBin, child *C.GstElement) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-		caller := obj.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-			DeepElementRemoved(self *Bin, subbin *Bin, child *Element)
+
-		})
+	gosubbin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(subbin))})
-		caller.DeepElementRemoved(wrapBin(gobj), cbWrapBin(subbin), cbWrapElement(child))
+	gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
+
+	caller := subclass.(interface {
+		DeepElementRemoved(self *Bin, subbin *Bin, child *Element)
 	})
+	caller.DeepElementRemoved(goBin, gosubbin, gochild)
 }
 
 //export goGstBinDoLatency
 func goGstBinDoLatency(bin *C.GstBin) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		caller := obj.(interface {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-			DoLatency(self *Bin) bool
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-		})
+
-		ret = caller.DoLatency(wrapBin(gobj))
+	caller := subclass.(interface {
+		DoLatency(self *Bin) bool
 	})
+	ret = caller.DoLatency(goBin)
+
 	return gboolean(ret)
 }
 
 //export goGstBinElementAdded
 func goGstBinElementAdded(bin *C.GstBin, child *C.GstElement) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		caller := obj.(interface {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-			ElementAdded(self *Bin, child *Element)
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-		})
+
-		caller.ElementAdded(wrapBin(gobj), cbWrapElement(child))
+	gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
+
+	caller := subclass.(interface {
+		ElementAdded(self *Bin, child *Element)
 	})
+	caller.ElementAdded(goBin, gochild)
 }
 
 //export goGstBinElementRemoved
 func goGstBinElementRemoved(bin *C.GstBin, child *C.GstElement) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		caller := obj.(interface {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-			ElementRemoved(self *Bin, child *Element)
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-		})
+
-		caller.ElementRemoved(wrapBin(gobj), cbWrapElement(child))
+	gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
+
+	caller := subclass.(interface {
+		ElementRemoved(self *Bin, child *Element)
 	})
+	caller.ElementRemoved(goBin, gochild)
 }
 
 //export goGstBinHandleMessage
 func goGstBinHandleMessage(bin *C.GstBin, message *C.GstMessage) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-		caller := obj.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-			HandleMessage(self *Bin, msg *Message)
+
-		})
+	caller := subclass.(interface {
-		caller.HandleMessage(wrapBin(gobj), wrapMessage(message))
+		HandleMessage(self *Bin, msg *Message)
 	})
+	caller.HandleMessage(goBin, wrapMessage(message))
 }
 
 //export goGstBinRemoveElement
-func goGstBinRemoveElement(bin *C.GstBin, element *C.GstElement) C.gboolean {
+func goGstBinRemoveElement(bin *C.GstBin, child *C.GstElement) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		caller := obj.(interface {
+	goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
-			RemoveElement(self *Bin, child *Element) bool
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
-		})
+
-		ret = caller.RemoveElement(wrapBin(gobj), cbWrapElement(element))
+	gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
+
+	caller := subclass.(interface {
+		RemoveElement(self *Bin, child *Element) bool
 	})
+	ret = caller.RemoveElement(goBin, gochild)
+
 	return gboolean(ret)
 }

gst/gst_element_exports.go

@@ -15,73 +15,85 @@ import (
 //export goGstElementClassChangeState
 func goGstElementClassChangeState(elem *C.GstElement, change C.GstStateChange) C.GstStateChangeReturn {
 	var ret StateChangeReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		iface := obj.(interface {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-			ChangeState(*Element, StateChange) StateChangeReturn
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		})
+
-		ret = iface.ChangeState(wrapElement(gobj), StateChange(change))
+	iface := subclass.(interface {
+		ChangeState(*Element, StateChange) StateChangeReturn
 	})
+	ret = iface.ChangeState(goElem, StateChange(change))
+
 	return C.GstStateChangeReturn(ret)
 }
 
 //export goGstElementClassGetState
 func goGstElementClassGetState(elem *C.GstElement, state, pending *C.GstState, timeout C.GstClockTime) C.GstStateChangeReturn {
 	var ret StateChangeReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-			GetState(*Element, time.Duration) (ret StateChangeReturn, current, pending State) // should this be a ClockTime?
+
-		})
+	iface := subclass.(interface {
-		var cur, pend State
+		GetState(*Element, time.Duration) (ret StateChangeReturn, current, pending State) // should this be a ClockTime?
-		ret, cur, pend = iface.GetState(wrapElement(gobj), time.Duration(timeout)*time.Nanosecond)
-		if ret != StateChangeFailure {
-			*state = C.GstState(cur)
-			*pending = C.GstState(pend)
-		}
 	})
+	var cur, pend State
+	ret, cur, pend = iface.GetState(goElem, time.Duration(timeout)*time.Nanosecond)
+	if ret != StateChangeFailure {
+		*state = C.GstState(cur)
+		*pending = C.GstState(pend)
+	}
+
 	return C.GstStateChangeReturn(ret)
 }
 
 //export goGstElementClassNoMorePads
 func goGstElementClassNoMorePads(elem *C.GstElement) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ NoMorePads(*Element) })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		iface.NoMorePads(wrapElement(gobj))
+
-	})
+	iface := subclass.(interface{ NoMorePads(*Element) })
+	iface.NoMorePads(goElem)
 }
 
 //export goGstElementClassPadAdded
 func goGstElementClassPadAdded(elem *C.GstElement, pad *C.GstPad) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ PadAdded(*Element, *Pad) })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		iface.PadAdded(wrapElement(gobj), wrapPad(toGObject(unsafe.Pointer(pad))))
+
-	})
+	iface := subclass.(interface{ PadAdded(*Element, *Pad) })
+	iface.PadAdded(goElem, wrapPad(toGObject(unsafe.Pointer(pad))))
 }
 
 //export goGstElementClassPadRemoved
 func goGstElementClassPadRemoved(elem *C.GstElement, pad *C.GstPad) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ PadRemoved(*Element, *Pad) })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		iface.PadRemoved(wrapElement(gobj), wrapPad(toGObject(unsafe.Pointer(pad))))
+
-	})
+	iface := subclass.(interface{ PadRemoved(*Element, *Pad) })
+	iface.PadRemoved(goElem, wrapPad(toGObject(unsafe.Pointer(pad))))
 }
 
 //export goGstElementClassPostMessage
 func goGstElementClassPostMessage(elem *C.GstElement, msg *C.GstMessage) C.gboolean {
 	var ret C.gboolean
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ PostMessage(*Element, *Message) bool })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		ret = gboolean(iface.PostMessage(wrapElement(gobj), wrapMessage(msg)))
+
-	})
+	iface := subclass.(interface{ PostMessage(*Element, *Message) bool })
+	ret = gboolean(iface.PostMessage(goElem, wrapMessage(msg)))
+
 	return ret
 }
 
 //export goGstElementClassProvideClock
 func goGstElementClassProvideClock(elem *C.GstElement) *C.GstClock {
 	var clock *Clock
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ ProvideClock(*Element) *Clock })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		clock = iface.ProvideClock(wrapElement(gobj))
+
-	})
+	iface := subclass.(interface{ ProvideClock(*Element) *Clock })
+	clock = iface.ProvideClock(goElem)
+
 	if clock == nil {
 		return nil
 	}
@@ -91,35 +103,41 @@ func goGstElementClassProvideClock(elem *C.GstElement) *C.GstClock {
 //export goGstElementClassQuery
 func goGstElementClassQuery(elem *C.GstElement, query *C.GstQuery) C.gboolean {
 	var ret C.gboolean
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ Query(*Element, *Query) bool })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		ret = gboolean(iface.Query(wrapElement(gobj), wrapQuery(query)))
+
-	})
+	iface := subclass.(interface{ Query(*Element, *Query) bool })
+	ret = gboolean(iface.Query(goElem, wrapQuery(query)))
+
 	return ret
 }
 
 //export goGstElementClassReleasePad
 func goGstElementClassReleasePad(elem *C.GstElement, pad *C.GstPad) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ ReleasePad(*Element, *Pad) })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		iface.ReleasePad(wrapElement(gobj), wrapPad(toGObject(unsafe.Pointer(pad))))
+
-	})
+	iface := subclass.(interface{ ReleasePad(*Element, *Pad) })
+	iface.ReleasePad(goElem, wrapPad(toGObject(unsafe.Pointer(pad))))
 }
 
 //export goGstElementClassRequestNewPad
 func goGstElementClassRequestNewPad(elem *C.GstElement, templ *C.GstPadTemplate, name *C.gchar, caps *C.GstCaps) *C.GstPad {
 	var pad *Pad
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		iface := obj.(interface {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-			RequestNewPad(self *Element, templ *PadTemplate, name string, caps *Caps) *Pad
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		})
+
-		pad = iface.RequestNewPad(
+	iface := subclass.(interface {
-			wrapElement(gobj),
+		RequestNewPad(self *Element, templ *PadTemplate, name string, caps *Caps) *Pad
-			wrapPadTemplate(toGObject(unsafe.Pointer(templ))),
-			C.GoString(name),
-			wrapCaps(caps),
-		)
 	})
+	pad = iface.RequestNewPad(
+		goElem,
+		wrapPadTemplate(toGObject(unsafe.Pointer(templ))),
+		C.GoString(name),
+		wrapCaps(caps),
+	)
+
 	if pad == nil {
 		return nil
 	}
@@ -129,57 +147,70 @@ func goGstElementClassRequestNewPad(elem *C.GstElement, templ *C.GstPadTemplate,
 //export goGstElementClassSendEvent
 func goGstElementClassSendEvent(elem *C.GstElement, event *C.GstEvent) C.gboolean {
 	var ret C.gboolean
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		iface := obj.(interface{ SendEvent(*Element, *Event) bool })
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		ret = gboolean(iface.SendEvent(wrapElement(gobj), wrapEvent(event)))
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-	})
+
+	iface := subclass.(interface{ SendEvent(*Element, *Event) bool })
+	ret = gboolean(iface.SendEvent(goElem, wrapEvent(event)))
+
 	return ret
 }
 
 //export goGstElementClassSetBus
 func goGstElementClassSetBus(elem *C.GstElement, bus *C.GstBus) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ SetBus(*Element, *Bus) })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		iface.SetBus(wrapElement(gobj), wrapBus(toGObject(unsafe.Pointer(bus))))
+
-	})
+	iface := subclass.(interface{ SetBus(*Element, *Bus) })
+	iface.SetBus(goElem, wrapBus(toGObject(unsafe.Pointer(bus))))
 }
 
 //export goGstElementClassSetClock
 func goGstElementClassSetClock(elem *C.GstElement, clock *C.GstClock) C.gboolean {
 	var ret C.gboolean
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		iface := obj.(interface{ SetClock(*Element, *Clock) bool })
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		ret = gboolean(iface.SetClock(wrapElement(gobj), wrapClock(toGObject(unsafe.Pointer(clock)))))
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-	})
+
+	iface := subclass.(interface{ SetClock(*Element, *Clock) bool })
+	ret = gboolean(iface.SetClock(goElem, wrapClock(toGObject(unsafe.Pointer(clock)))))
+
 	return ret
 }
 
 //export goGstElementClassSetContext
 func goGstElementClassSetContext(elem *C.GstElement, ctx *C.GstContext) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface{ SetContext(*Element, *Context) })
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		iface.SetContext(wrapElement(gobj), wrapContext(ctx))
+
-	})
+	iface := subclass.(interface{ SetContext(*Element, *Context) })
+	iface.SetContext(goElem, wrapContext(ctx))
 }
 
 //export goGstElementClassSetState
 func goGstElementClassSetState(elem *C.GstElement, state C.GstState) C.GstStateChangeReturn {
 	var ret C.GstStateChangeReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+
-		iface := obj.(interface {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-			SetState(*Element, State) StateChangeReturn
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-		})
+
-		ret = C.GstStateChangeReturn(iface.SetState(wrapElement(gobj), State(state)))
+	iface := subclass.(interface {
+		SetState(*Element, State) StateChangeReturn
 	})
+	ret = C.GstStateChangeReturn(iface.SetState(goElem, State(state)))
+
 	return ret
 }
 
 //export goGstElementClassStateChanged
 func goGstElementClassStateChanged(elem *C.GstElement, old, new, pending C.GstState) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
-		iface := obj.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
-			StateChanged(self *Element, old, new, pending State)
+
-		})
+	iface := subclass.(interface {
-		iface.StateChanged(wrapElement(gobj), State(old), State(new), State(pending))
+		StateChanged(self *Element, old, new, pending State)
 	})
+	iface.StateChanged(goElem, State(old), State(new), State(pending))
+
 }