Fix shaper segfault (#633)

* `managedString` might be inlined and garbage collected before the beginning of JNI call

* add other missed `reachabilityBarrier`s

skiko/src/commonMain/kotlin/org/jetbrains/skia/Bitmap.kt

@@ -70,10 +70,13 @@ class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
      */
     fun swap(other: Bitmap) {
         Stats.onNativeCall()
-        _nSwap(_ptr, getPtr(other))
-        _imageInfo = null
-        reachabilityBarrier(this)
-        reachabilityBarrier(other)
+        try {
+            _nSwap(_ptr, getPtr(other))
+            _imageInfo = null
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(other)
+        }
     }
 
     override val imageInfo: ImageInfo
@@ -685,6 +688,7 @@ class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(pixelRef)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/Canvas.kt

@@ -57,8 +57,12 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
 
     fun drawPoint(x: Float, y: Float, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawPoint(_ptr, x, y, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawPoint(_ptr, x, y, getPtr(paint))
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
+        }
         return this
     }
 
@@ -118,10 +122,14 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawPoints(coords: FloatArray, paint: Paint): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawPoints(_ptr, 0 /* SkCanvas::PointMode::kPoints_PointMode */, coords.size, toInterop(coords), getPtr(paint))
+        try {
+            interopScope {
+                _nDrawPoints(_ptr, 0 /* SkCanvas::PointMode::kPoints_PointMode */, coords.size, toInterop(coords), getPtr(paint))
+            }
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -177,10 +185,14 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawLines(coords: FloatArray, paint: Paint): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawPoints(_ptr, 1 /* SkCanvas::PointMode::kLines_PointMode */, coords.size, toInterop(coords),getPtr(paint))
+        try {
+            interopScope {
+                _nDrawPoints(_ptr, 1 /* SkCanvas::PointMode::kLines_PointMode */, coords.size, toInterop(coords),getPtr(paint))
+            }
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -234,17 +246,25 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawPolygon(coords: FloatArray, paint: Paint): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawPoints(_ptr, 2 /* SkCanvas::PointMode::kPolygon_PointMode */, coords.size, toInterop(coords), getPtr(paint))
+        try {
+            interopScope {
+                _nDrawPoints(_ptr, 2 /* SkCanvas::PointMode::kPolygon_PointMode */, coords.size, toInterop(coords), getPtr(paint))
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
     fun drawLine(x0: Float, y0: Float, x1: Float, y1: Float, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawLine(_ptr, x0, y0, x1, y1, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawLine(_ptr, x0, y0, x1, y1, getPtr(paint))
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
@@ -259,62 +279,86 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         paint: Paint
     ): Canvas {
         Stats.onNativeCall()
-        _nDrawArc(_ptr, left, top, right, bottom, startAngle, sweepAngle, includeCenter, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawArc(_ptr, left, top, right, bottom, startAngle, sweepAngle, includeCenter, getPtr(paint))
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
+        }
         return this
     }
 
     fun drawRect(r: Rect, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawRect(_ptr, r.left, r.top, r.right, r.bottom, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawRect(_ptr, r.left, r.top, r.right, r.bottom, getPtr(paint))
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
+        }
         return this
     }
 
     fun drawOval(r: Rect, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawOval(_ptr, r.left, r.top, r.right, r.bottom, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawOval(_ptr, r.left, r.top, r.right, r.bottom, getPtr(paint))
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
     fun drawCircle(x: Float, y: Float, radius: Float, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawOval(_ptr, x - radius, y - radius, x + radius, y + radius, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawOval(_ptr, x - radius, y - radius, x + radius, y + radius, getPtr(paint))
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
     fun drawRRect(r: RRect, paint: Paint): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawRRect(_ptr, r.left, r.top, r.right, r.bottom, toInterop(r.radii), r.radii.size, getPtr(paint))
+        try {
+            interopScope {
+                _nDrawRRect(_ptr, r.left, r.top, r.right, r.bottom, toInterop(r.radii), r.radii.size, getPtr(paint))
+            }
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
     fun drawDRRect(outer: RRect, inner: RRect, paint: Paint): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawDRRect(
-                _ptr,
-                outer.left,
-                outer.top,
-                outer.right,
-                outer.bottom,
-                toInterop(outer.radii),
-                outer.radii.size,
-                inner.left,
-                inner.top,
-                inner.right,
-                inner.bottom,
-                toInterop(inner.radii),
-                inner.radii.size,
-                getPtr(paint)
-            )
+        try {
+            interopScope {
+                _nDrawDRRect(
+                    _ptr,
+                    outer.left,
+                    outer.top,
+                    outer.right,
+                    outer.bottom,
+                    toInterop(outer.radii),
+                    outer.radii.size,
+                    inner.left,
+                    inner.top,
+                    inner.right,
+                    inner.bottom,
+                    toInterop(inner.radii),
+                    inner.radii.size,
+                    getPtr(paint)
+                )
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -346,9 +390,13 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
 
     fun drawPath(path: Path, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawPath(_ptr, getPtr(path), getPtr(paint))
-        reachabilityBarrier(path)
-        reachabilityBarrier(paint)
+        try {
+            _nDrawPath(_ptr, getPtr(path), getPtr(paint))
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(path)
+            reachabilityBarrier(paint)
+        }
         return this
     }
 
@@ -417,71 +465,91 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         strict: Boolean
     ): Canvas {
         Stats.onNativeCall()
-        _nDrawImageRect(
-            _ptr,
-            getPtr(image),
-            src.left,
-            src.top,
-            src.right,
-            src.bottom,
-            dst.left,
-            dst.top,
-            dst.right,
-            dst.bottom,
-            samplingMode._packedInt1(),
-            samplingMode._packedInt2(),
-            getPtr(paint),
-            strict
-        )
-        reachabilityBarrier(image)
-        reachabilityBarrier(paint)
+        try {
+            _nDrawImageRect(
+                _ptr,
+                getPtr(image),
+                src.left,
+                src.top,
+                src.right,
+                src.bottom,
+                dst.left,
+                dst.top,
+                dst.right,
+                dst.bottom,
+                samplingMode._packedInt1(),
+                samplingMode._packedInt2(),
+                getPtr(paint),
+                strict
+            )
+        } finally {
+            reachabilityBarrier(image)
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
     fun drawImageNine(image: Image, center: IRect, dst: Rect, filterMode: FilterMode, paint: Paint?): Canvas {
         Stats.onNativeCall()
-        _nDrawImageNine(
-            _ptr,
-            getPtr(image),
-            center.left,
-            center.top,
-            center.right,
-            center.bottom,
-            dst.left,
-            dst.top,
-            dst.right,
-            dst.bottom,
-            filterMode.ordinal,
-            getPtr(paint)
-        )
-        reachabilityBarrier(image)
-        reachabilityBarrier(paint)
+        try {
+            _nDrawImageNine(
+                _ptr,
+                getPtr(image),
+                center.left,
+                center.top,
+                center.right,
+                center.bottom,
+                dst.left,
+                dst.top,
+                dst.right,
+                dst.bottom,
+                filterMode.ordinal,
+                getPtr(paint)
+            )
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(image)
+            reachabilityBarrier(paint)
+        }
         return this
     }
 
     fun drawRegion(r: Region, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawRegion(_ptr, getPtr(r), getPtr(paint))
-        reachabilityBarrier(r)
-        reachabilityBarrier(paint)
+        try {
+            _nDrawRegion(_ptr, getPtr(r), getPtr(paint))
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(r)
+            reachabilityBarrier(paint)
+        }
         return this
     }
 
     fun drawString(s: String, x: Float, y: Float, font: Font?, paint: Paint): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawString(_ptr, toInterop(s), x, y, getPtr(font), getPtr(paint))
+        try {
+            interopScope {
+                _nDrawString(_ptr, toInterop(s), x, y, getPtr(font), getPtr(paint))
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(font)
+            reachabilityBarrier(paint)
         }
-        reachabilityBarrier(font)
-        reachabilityBarrier(paint)
         return this
     }
 
     fun drawTextBlob(blob: TextBlob, x: Float, y: Float, paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawTextBlob(_ptr, getPtr(blob), x, y, getPtr(paint))
-        reachabilityBarrier(blob)
-        reachabilityBarrier(paint)
+        try {
+            _nDrawTextBlob(_ptr, getPtr(blob), x, y, getPtr(paint))
+        } finally {
+            reachabilityBarrier(blob)
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
@@ -492,8 +560,12 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
 
     fun drawPicture(picture: Picture, matrix: Matrix33? = null, paint: Paint? = null): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawPicture(_ptr, getPtr(picture), toInterop(matrix?.mat), getPtr(paint))
+        try {
+            interopScope {
+                _nDrawPicture(_ptr, getPtr(picture), toInterop(matrix?.mat), getPtr(paint))
+            }
+        } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(picture)
             reachabilityBarrier(paint)
         }
@@ -535,21 +607,25 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         require(colors == null || colors.size == positions.size) { "Expected colors.length == positions.length, got: " + colors!!.size + " != " + positions.size }
         require(texCoords == null || texCoords.size == positions.size) { "Expected texCoords.length == positions.length, got: " + texCoords!!.size + " != " + positions.size }
         Stats.onNativeCall()
-        interopScope {
-            _nDrawVertices(
-                _ptr,
-                0 /* kTriangles_VertexMode */,
-                positions.size,
-                toInterop(Point.flattenArray(positions)),
-                toInterop(colors),
-                toInterop(Point.flattenArray(texCoords)),
-                indices?.size ?: 0,
-                toInterop(indices),
-                blendMode.ordinal,
-                getPtr(paint)
-            )
+        try {
+            interopScope {
+                _nDrawVertices(
+                    _ptr,
+                    0 /* kTriangles_VertexMode */,
+                    positions.size,
+                    toInterop(Point.flattenArray(positions)),
+                    toInterop(colors),
+                    toInterop(Point.flattenArray(texCoords)),
+                    indices?.size ?: 0,
+                    toInterop(indices),
+                    blendMode.ordinal,
+                    getPtr(paint)
+                )
+            }
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -587,21 +663,25 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         require(colors == null || colors.size == positions.size) { "Expected colors.length == positions.length, got: " + colors!!.size + " != " + positions.size }
         require(texCoords == null || texCoords.size == positions.size) { "Expected texCoords.length == positions.length, got: " + texCoords!!.size + " != " + positions.size }
         Stats.onNativeCall()
-        interopScope {
-            _nDrawVertices(
-                _ptr,
-                1 /* kTriangleStrip_VertexMode */,
-                positions.size,
-                toInterop(Point.flattenArray(positions)),
-                toInterop(colors),
-                toInterop(Point.flattenArray(texCoords)),
-                indices?.size ?: 0,
-                toInterop(indices),
-                blendMode.ordinal,
-                getPtr(paint)
-            )
+        try {
+            interopScope {
+                _nDrawVertices(
+                    _ptr,
+                    1 /* kTriangleStrip_VertexMode */,
+                    positions.size,
+                    toInterop(Point.flattenArray(positions)),
+                    toInterop(colors),
+                    toInterop(Point.flattenArray(texCoords)),
+                    indices?.size ?: 0,
+                    toInterop(indices),
+                    blendMode.ordinal,
+                    getPtr(paint)
+                )
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -639,21 +719,25 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         require(colors == null || colors.size == positions.size) { "Expected colors.length == positions.length, got: " + colors!!.size + " != " + positions.size }
         require(texCoords == null || texCoords.size == positions.size) { "Expected texCoords.length == positions.length, got: " + texCoords!!.size + " != " + positions.size }
         Stats.onNativeCall()
-        interopScope {
-            _nDrawVertices(
-                _ptr,
-                2 /* kTriangleFan_VertexMode */,
-                positions.size,
-                toInterop(Point.flattenArray(positions)),
-                toInterop(colors),
-                toInterop(Point.flattenArray(texCoords)),
-                indices?.size ?: 0,
-                toInterop(indices),
-                blendMode.ordinal,
-                getPtr(paint)
-            )
+        try {
+            interopScope {
+                _nDrawVertices(
+                    _ptr,
+                    2 /* kTriangleFan_VertexMode */,
+                    positions.size,
+                    toInterop(Point.flattenArray(positions)),
+                    toInterop(colors),
+                    toInterop(Point.flattenArray(texCoords)),
+                    indices?.size ?: 0,
+                    toInterop(indices),
+                    blendMode.ordinal,
+                    getPtr(paint)
+                )
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -702,21 +786,25 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
             "Expected texCoords.length == positions.length, got: " + texCoords!!.size + " != " + positions.size
         }
         Stats.onNativeCall()
-        interopScope {
-            _nDrawVertices(
-                _ptr,
-                vertexMode.ordinal,
-                points,
-                toInterop(positions),
-                toInterop(colors),
-                toInterop(texCoords),
-                indices?.size ?: 0,
-                toInterop(indices),
-                blendMode.ordinal,
-                getPtr(paint)
-            )
+        try {
+            interopScope {
+                _nDrawVertices(
+                    _ptr,
+                    vertexMode.ordinal,
+                    points,
+                    toInterop(positions),
+                    toInterop(colors),
+                    toInterop(texCoords),
+                    indices?.size ?: 0,
+                    toInterop(indices),
+                    blendMode.ordinal,
+                    getPtr(paint)
+                )
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(paint)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -766,17 +854,21 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
         require(colors.size == 4) { "Expected colors.length == 4, got: " + colors.size }
         require(texCoords == null || texCoords.size == 4) { "Expected texCoords.length == 4, got: " + texCoords!!.size }
         Stats.onNativeCall()
-        interopScope {
-            _nDrawPatch(
-                _ptr,
-                toInterop(Point.flattenArray(cubics)),
-                toInterop(colors),
-                toInterop(Point.flattenArray(texCoords)),
-                blendMode.ordinal,
-                getPtr(paint)
-            )
+        try {
+            interopScope {
+                _nDrawPatch(
+                    _ptr,
+                    toInterop(Point.flattenArray(cubics)),
+                    toInterop(colors),
+                    toInterop(Point.flattenArray(texCoords)),
+                    blendMode.ordinal,
+                    getPtr(paint)
+                )
+            }
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
         }
-        reachabilityBarrier(paint)
         return this
     }
 
@@ -837,23 +929,35 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
      */
     fun drawDrawable(drawable: Drawable, matrix: Matrix33?): Canvas {
         Stats.onNativeCall()
-        interopScope {
-            _nDrawDrawable(_ptr, getPtr(drawable), toInterop(matrix?.mat))
+        try {
+            interopScope {
+                _nDrawDrawable(_ptr, getPtr(drawable), toInterop(matrix?.mat))
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(drawable)
         }
-        reachabilityBarrier(drawable)
         return this
     }
 
     fun clear(color: Int): Canvas {
         Stats.onNativeCall()
-        _nClear(_ptr, color)
+        try {
+            _nClear(_ptr, color)
+        } finally {
+            reachabilityBarrier(this)
+        }
         return this
     }
 
     fun drawPaint(paint: Paint): Canvas {
         Stats.onNativeCall()
-        _nDrawPaint(_ptr, getPtr(paint))
-        reachabilityBarrier(paint)
+        try {
+            _nDrawPaint(_ptr, getPtr(paint))
+        } finally {
+            reachabilityBarrier(paint)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
@@ -939,8 +1043,12 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
 
     fun clipPath(p: Path, mode: ClipMode, antiAlias: Boolean): Canvas {
         Stats.onNativeCall()
-        _nClipPath(_ptr, getPtr(p), mode.ordinal, antiAlias)
-        reachabilityBarrier(p)
+        try {
+            _nClipPath(_ptr, getPtr(p), mode.ordinal, antiAlias)
+        } finally {
+            reachabilityBarrier(p)
+            reachabilityBarrier(this)
+        }
         return this
     }
 
@@ -958,8 +1066,12 @@ open class Canvas internal constructor(ptr: NativePointer, managed: Boolean, int
 
     fun clipRegion(r: Region, mode: ClipMode): Canvas {
         Stats.onNativeCall()
-        _nClipRegion(_ptr, getPtr(r), mode.ordinal)
-        reachabilityBarrier(r)
+        try {
+            _nClipRegion(_ptr, getPtr(r), mode.ordinal)
+        } finally {
+            reachabilityBarrier(r)
+            reachabilityBarrier(this)
+        }
         return this
     }
 

skiko/src/commonMain/kotlin/org/jetbrains/skia/Codec.kt

@@ -141,6 +141,7 @@ class Codec internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHo
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(bitmap)
         }
     }
@@ -198,6 +199,7 @@ class Codec internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHo
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(bitmap)
         }
     }
@@ -256,6 +258,7 @@ class Codec internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHo
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(bitmap)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/Drawable.kt

@@ -58,6 +58,7 @@ abstract class Drawable : Managed(Drawable_nMake(), _FinalizerHolder.PTR) {
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(canvas)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/Font.kt

@@ -315,6 +315,7 @@ class Font : Managed {
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(typeface)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/Image.kt

@@ -110,8 +110,7 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
         fun makeFromBitmap(bitmap: Bitmap): Image {
             return try {
                 Stats.onNativeCall()
-                val ptr =
-                    _nMakeFromBitmap(getPtr(bitmap))
+                val ptr = _nMakeFromBitmap(getPtr(bitmap))
                 if (ptr == NullPointer) throw RuntimeException("Failed to Image::makeFromBitmap $bitmap")
                 Image(ptr)
             } finally {
@@ -122,8 +121,7 @@ class Image internal constructor(ptr: NativePointer) : RefCnt(ptr), IHasImageInf
         fun makeFromPixmap(pixmap: Pixmap): Image {
             return try {
                 Stats.onNativeCall()
-                val ptr =
-                    _nMakeFromPixmap(getPtr(pixmap))
+                val ptr = _nMakeFromPixmap(getPtr(pixmap))
                 if (ptr == NullPointer) throw RuntimeException("Failed to Image::makeFromRaster $pixmap")
                 Image(ptr)
             } finally {

skiko/src/commonMain/kotlin/org/jetbrains/skia/ImageFilter.kt

@@ -128,9 +128,7 @@ class ImageFilter internal constructor(ptr: NativePointer) : RefCnt(ptr) {
                 Stats.onNativeCall()
                 ImageFilter(
                     _nMakeCompose(
-                        getPtr(
-                            outer
-                        ), getPtr(inner)
+                        getPtr(outer), getPtr(inner)
                     )
                 )
             } finally {

skiko/src/commonMain/kotlin/org/jetbrains/skia/Paint.kt

@@ -215,6 +215,7 @@ class Paint : Managed {
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(colorSpace)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/PaintFilterCanvas.kt

@@ -7,7 +7,7 @@ import org.jetbrains.skia.impl.Library.Companion.staticLoad
  * A utility proxy base class for implementing draw/paint filters.
  */
 abstract class PaintFilterCanvas(private val canvas: Canvas, unrollDrawable: Boolean) :
-    Canvas(PaintFilterCanvas_nMake(getPtr(canvas), unrollDrawable), true, canvas) {
+    Canvas(makePaintFilterCanvas(canvas, unrollDrawable), true, canvas) {
     companion object {
         init {
             staticLoad()
@@ -34,8 +34,19 @@ abstract class PaintFilterCanvas(private val canvas: Canvas, unrollDrawable: Boo
      */
     init {
         Stats.onNativeCall()
-        doInit(_ptr)
-        Stats.onNativeCall()
+        try {
+            doInit(_ptr)
+        } finally {
+            reachabilityBarrier(this)
+        }
+    }
+}
+
+private fun makePaintFilterCanvas(canvas: Canvas, unrollDrawable: Boolean): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        PaintFilterCanvas_nMake(getPtr(canvas), unrollDrawable)
+    } finally {
         reachabilityBarrier(canvas)
     }
 }

skiko/src/commonMain/kotlin/org/jetbrains/skia/Path.kt

@@ -724,6 +724,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             Path_nSwap(_ptr, getPtr(other))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(other)
         }
     }
@@ -1751,6 +1752,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(src)
         }
     }
@@ -1794,6 +1796,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(src)
         }
     }
@@ -1838,6 +1841,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(src)
         }
     }
@@ -1857,6 +1861,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             _nReverseAddPath(_ptr, getPtr(src))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(src)
         }
     }
@@ -1884,6 +1889,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             _nOffset(_ptr, dx, dy, getPtr(dst))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(dst)
         }
     }
@@ -1946,6 +1952,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(dst)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/PathMeasure.kt

@@ -3,6 +3,20 @@ package org.jetbrains.skia
 import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
 
+private fun makePath(
+    path: Path?,
+    forceClosed: Boolean,
+    resScale: Float
+): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        _nMakePath(getPtr(path), forceClosed, resScale)
+    } finally {
+        Stats.onNativeCall()
+        reachabilityBarrier(path)
+    }
+}
+
 class PathMeasure internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHolder.PTR) {
     companion object {
         init {
@@ -10,9 +24,7 @@ class PathMeasure internal constructor(ptr: NativePointer) : Managed(ptr, _Final
         }
     }
 
-    constructor() : this(PathMeasure_nMake()) {
-        Stats.onNativeCall()
-    }
+    constructor() : this(PathMeasure_nMake())
     /**
      *
      * Initialize the pathmeasure with the specified path. The parts of the path that are needed
@@ -34,10 +46,7 @@ class PathMeasure internal constructor(ptr: NativePointer) : Managed(ptr, _Final
         path: Path?,
         forceClosed: Boolean = false,
         resScale: Float = 1f
-    ) : this(_nMakePath(getPtr(path), forceClosed, resScale)) {
-        Stats.onNativeCall()
-        reachabilityBarrier(path)
-    }
+    ) : this(makePath(path, forceClosed, resScale))
 
     /**
      * Reset the pathmeasure with the specified path. The parts of the path that are needed
@@ -49,6 +58,7 @@ class PathMeasure internal constructor(ptr: NativePointer) : Managed(ptr, _Final
             _nSetPath(_ptr, getPtr(path), forceClosed)
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(path)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/Picture.kt

@@ -81,6 +81,7 @@ class Picture internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(canvas)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/RuntimeEffect.kt

@@ -32,8 +32,14 @@ class RuntimeEffect internal constructor(ptr: NativePointer) : RefCnt(ptr) {
         val childrenPtrs = NativePointerArray(childCount)
         for (i in 0 until childCount) childrenPtrs[i] = getPtr(children!![i])
         val matrix = localMatrix?.mat
-        return interopScope {
-            Shader(_nMakeShader(_ptr, getPtr(uniforms), toInterop(childrenPtrs), childCount, toInterop(matrix)))
+        return try {
+            interopScope {
+                Shader(_nMakeShader(_ptr, getPtr(uniforms), toInterop(childrenPtrs), childCount, toInterop(matrix)))
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(uniforms)
+            reachabilityBarrier(children)
         }
     }
 }

skiko/src/commonMain/kotlin/org/jetbrains/skia/RuntimeShaderBuilder.kt

@@ -103,15 +103,25 @@ class RuntimeShaderBuilder internal constructor(ptr: NativePointer) : Managed(pt
 
     fun child(name: String, shader: Shader) {
         Stats.onNativeCall()
-        interopScope {
-            _nChildShader(_ptr, toInterop(name), getPtr(shader))
+        try {
+            interopScope {
+                _nChildShader(_ptr, toInterop(name), getPtr(shader))
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(shader)
         }
     }
 
     fun child(name: String, colorFilter: ColorFilter) {
         Stats.onNativeCall()
-        interopScope {
-            _nChildColorFilter(_ptr, toInterop(name), getPtr(colorFilter))
+        try {
+            interopScope {
+                _nChildColorFilter(_ptr, toInterop(name), getPtr(colorFilter))
+            }
+        } finally {
+            reachabilityBarrier(this)
+            reachabilityBarrier(colorFilter)
         }
     }
 }

skiko/src/commonMain/kotlin/org/jetbrains/skia/ShadowUtils.kt

@@ -4,6 +4,7 @@ import org.jetbrains.skia.impl.Library.Companion.staticLoad
 import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.impl.NativePointer
 import org.jetbrains.skia.impl.getPtr
+import org.jetbrains.skia.impl.reachabilityBarrier
 
 object ShadowUtils {
     /**
@@ -39,20 +40,25 @@ object ShadowUtils {
         var flags = 0
         if (transparentOccluder) flags = flags or 1
         if (geometricOnly) flags = flags or 2
-        _nDrawShadow(
-            getPtr(canvas),
-            getPtr(path),
-            zPlaneParams.x,
-            zPlaneParams.y,
-            zPlaneParams.z,
-            lightPos.x,
-            lightPos.y,
-            lightPos.z,
-            lightRadius,
-            ambientColor,
-            spotColor,
-            flags
-        )
+        try {
+            _nDrawShadow(
+                getPtr(canvas),
+                getPtr(path),
+                zPlaneParams.x,
+                zPlaneParams.y,
+                zPlaneParams.z,
+                lightPos.x,
+                lightPos.y,
+                lightPos.z,
+                lightRadius,
+                ambientColor,
+                spotColor,
+                flags
+            )
+        } finally {
+            reachabilityBarrier(canvas)
+            reachabilityBarrier(path)
+        }
     }
 
     /**

skiko/src/commonMain/kotlin/org/jetbrains/skia/Surface.kt

@@ -689,6 +689,7 @@ class Surface : RefCnt {
             Surface(ptr)
         } finally {
             reachabilityBarrier(this)
+            reachabilityBarrier(imageInfo.colorInfo.colorSpace)
         }
     }
 

skiko/src/commonMain/kotlin/org/jetbrains/skia/TextBlobBuilder.kt

@@ -91,6 +91,7 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(font)
         }
     }
@@ -143,6 +144,7 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(font)
         }
     }
@@ -191,6 +193,7 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(font)
         }
     }
@@ -217,6 +220,7 @@ class TextBlobBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _F
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(font)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/FontCollection.kt

@@ -30,6 +30,7 @@ class FontCollection internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             _nSetAssetFontManager(_ptr, getPtr(fontMgr), NullPointer)
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(fontMgr)
         }
     }
@@ -44,6 +45,7 @@ class FontCollection internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(fontMgr)
         }
     }
@@ -54,6 +56,7 @@ class FontCollection internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             _nSetTestFontManager(_ptr, getPtr(fontMgr), NullPointer)
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(fontMgr)
         }
     }
@@ -74,6 +77,7 @@ class FontCollection internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(fontMgr)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/Paragraph.kt

@@ -91,6 +91,7 @@ class Paragraph internal constructor(ptr: NativePointer, text: ManagedString?) :
             _nPaint(_ptr, getPtr(canvas), x, y)
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(canvas)
         }
     }
@@ -213,6 +214,7 @@ class Paragraph internal constructor(ptr: NativePointer, text: ManagedString?) :
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(_text)
         }
     }
@@ -231,6 +233,7 @@ class Paragraph internal constructor(ptr: NativePointer, text: ManagedString?) :
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(paint)
             reachabilityBarrier(_text)
         }
@@ -250,6 +253,7 @@ class Paragraph internal constructor(ptr: NativePointer, text: ManagedString?) :
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(paint)
             reachabilityBarrier(_text)
         }

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/ParagraphBuilder.kt

@@ -6,7 +6,7 @@ import org.jetbrains.skia.ExternalSymbolName
 import org.jetbrains.skia.impl.*
 
 class ParagraphBuilder(style: ParagraphStyle?, fc: FontCollection?) :
-    Managed(_nMake(getPtr(style), getPtr(fc)), _FinalizerHolder.PTR) {
+    Managed(makeParagraphBuilder(style, fc), _FinalizerHolder.PTR) {
     companion object {
         init {
             staticLoad()
@@ -26,14 +26,22 @@ class ParagraphBuilder(style: ParagraphStyle?, fc: FontCollection?) :
 
     fun popStyle(): ParagraphBuilder {
         Stats.onNativeCall()
-        _nPopStyle(_ptr, NullPointer)
+        try {
+            _nPopStyle(_ptr, NullPointer)
+        } finally {
+            reachabilityBarrier(this)
+        }
         return this
     }
 
     fun addText(text: String): ParagraphBuilder {
         Stats.onNativeCall()
-        interopScope {
-            _nAddText(_ptr, toInterop(text))
+        try {
+            interopScope {
+                _nAddText(_ptr, toInterop(text))
+            }
+        } finally {
+            reachabilityBarrier(this)
         }
         if (_text == null) _text = ManagedString(text) else _text!!.append(text)
         return this
@@ -66,9 +74,16 @@ class ParagraphBuilder(style: ParagraphStyle?, fc: FontCollection?) :
     internal object _FinalizerHolder {
         val PTR = ParagraphBuilder_nGetFinalizer()
     }
+}
 
-    init {
-        Stats.onNativeCall()
+private fun makeParagraphBuilder(
+    style: ParagraphStyle?,
+    fc: FontCollection?
+): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        _nMake(getPtr(style), getPtr(fc))
+    } finally {
         reachabilityBarrier(style)
         reachabilityBarrier(fc)
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/TextStyle.kt

@@ -80,6 +80,7 @@ class TextStyle internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(paint)
         }
     }
@@ -105,6 +106,7 @@ class TextStyle internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(paint)
         }
     }
@@ -363,6 +365,7 @@ class TextStyle internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             )
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(typeface)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/TypefaceFontProvider.kt

@@ -30,6 +30,7 @@ class TypefaceFontProvider : FontMgr(TypefaceFontProvider_nMake()) {
             }
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(typeface)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/shaper/FontMgrRunIterator.kt

@@ -11,9 +11,24 @@ import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.impl.getPtr
 import org.jetbrains.skia.impl.reachabilityBarrier
 
+private fun makeHbIcuScriptRunIterator(
+    text: ManagedString,
+    font: Font,
+    opts: ShapingOptions
+): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        _nMake(getPtr(text), getPtr(font), getPtr(opts.fontMgr), opts._booleanPropsToInt())
+    } finally {
+        reachabilityBarrier(text)
+        reachabilityBarrier(font)
+        reachabilityBarrier(opts.fontMgr)
+    }
+}
+
 class FontMgrRunIterator(text: ManagedString, manageText: Boolean, font: Font, opts: ShapingOptions) :
     ManagedRunIterator<FontRun?>(
-        _nMake(getPtr(text), getPtr(font), getPtr(opts.fontMgr), opts._booleanPropsToInt()), text, manageText
+        makeHbIcuScriptRunIterator(text, font, opts), text, manageText
     ) {
     companion object {
         init {
@@ -36,13 +51,6 @@ class FontMgrRunIterator(text: ManagedString, manageText: Boolean, font: Font, o
         }
     }
 
-    init {
-        Stats.onNativeCall()
-        reachabilityBarrier(text)
-        reachabilityBarrier(font)
-        reachabilityBarrier(opts)
-    }
-
     override fun remove() {
         TODO("Not yet implemented")
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/shaper/HbIcuScriptRunIterator.kt

@@ -10,9 +10,7 @@ import org.jetbrains.skia.impl.getPtr
 import org.jetbrains.skia.impl.reachabilityBarrier
 
 class HbIcuScriptRunIterator(text: ManagedString, manageText: Boolean) : ManagedRunIterator<ScriptRun?>(
-    _nMake(
-        getPtr(text)
-    ), text, manageText
+    makeHbIcuScriptRunIterator(text), text, manageText
 ) {
     companion object {
         init {
@@ -31,16 +29,19 @@ class HbIcuScriptRunIterator(text: ManagedString, manageText: Boolean) : Managed
         }
     }
 
-    init {
-        Stats.onNativeCall()
-        reachabilityBarrier(text)
-    }
-
     override fun remove() {
         TODO("Not yet implemented")
     }
 }
 
+private fun makeHbIcuScriptRunIterator(text: ManagedString): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        _nMake(getPtr(text))
+    } finally {
+        reachabilityBarrier(text)
+    }
+}
 
 @ExternalSymbolName("org_jetbrains_skia_shaper_HbIcuScriptRunIterator__1nMake")
 private external fun _nMake(textPtr: NativePointer): NativePointer

skiko/src/commonMain/kotlin/org/jetbrains/skia/shaper/IcuBidiRunIterator.kt

@@ -9,8 +9,18 @@ import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.impl.getPtr
 import org.jetbrains.skia.impl.reachabilityBarrier
 
+private fun makeIcuBidiRunIterator(text: ManagedString, bidiLevel: Int): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        _nMake(getPtr(text), bidiLevel)
+    } finally {
+        reachabilityBarrier(text)
+    }
+}
+
+
 class IcuBidiRunIterator(text: ManagedString, manageText: Boolean, bidiLevel: Int) : ManagedRunIterator<BidiRun?>(
-    _nMake(getPtr(text), bidiLevel), text, manageText
+    makeIcuBidiRunIterator(text, bidiLevel), text, manageText
 ) {
     companion object {
         init {
@@ -29,11 +39,6 @@ class IcuBidiRunIterator(text: ManagedString, manageText: Boolean, bidiLevel: In
         }
     }
 
-    init {
-        Stats.onNativeCall()
-        reachabilityBarrier(text)
-    }
-
     override fun remove() {
         TODO("Not yet implemented")
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/shaper/Shaper.kt

@@ -193,18 +193,20 @@ class Shaper internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
     fun shapeLine(text: String?, font: Font?, opts: ShapingOptions): TextLine {
         return try {
             Stats.onNativeCall()
-            val managedString = ManagedString(text)
-            interopScope {
-                TextLine(
-                    _nShapeLine(
-                        _ptr,
-                        managedString._ptr,
-                        getPtr(font),
-                        optsFeaturesLen = opts.features?.size ?: 0,
-                        optsFeatures = arrayOfFontFeaturesToInterop(opts.features),
-                        optsBooleanProps = opts._booleanPropsToInt()
+            ManagedString(text).use { managedString ->
+                interopScope {
+                    TextLine(
+                        _nShapeLine(
+                            _ptr,
+                            managedString._ptr,
+                            getPtr(font),
+                            optsFeaturesLen = opts.features?.size ?: 0,
+                            optsFeatures = arrayOfFontFeaturesToInterop(opts.features),
+                            optsBooleanProps = opts._booleanPropsToInt()
+                        )
                     )
-                )
+                }
+
             }
         } finally {
             reachabilityBarrier(this)

skiko/src/commonMain/kotlin/org/jetbrains/skia/shaper/TextBlobBuilderRunHandler.kt

@@ -73,6 +73,7 @@ class TextBlobBuilderRunHandler<T> internal constructor(
     }
 
     init {
+        // TODO [pavel.sergeev] what `manageText` == false is actually mean?
         _text = if (manageText) text else null
         reachabilityBarrier(text)
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/skottie/Animation.kt

@@ -20,7 +20,11 @@ class Animation internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
 
         fun makeFromData(data: Data): Animation {
             Stats.onNativeCall()
-            val ptr = _nMakeFromData(getPtr(data))
+            val ptr = try {
+                _nMakeFromData(getPtr(data))
+            } finally {
+                reachabilityBarrier(data)
+            }
             require(ptr != NullPointer) { "Failed to create Animation from data." }
             return Animation(ptr)
         }
@@ -103,6 +107,7 @@ class Animation internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             _nRender(_ptr, getPtr(canvas), dst.left, dst.top, dst.right, dst.bottom, flags)
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(canvas)
         }
     }
@@ -132,6 +137,7 @@ class Animation internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             _nSeek(_ptr, t, getPtr(ic))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(ic)
         }
     }
@@ -171,6 +177,7 @@ class Animation internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             _nSeekFrame(_ptr, t, getPtr(ic))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(ic)
         }
     }
@@ -202,6 +209,7 @@ class Animation internal constructor(ptr: NativePointer) : Managed(ptr, _Finaliz
             _nSeekFrameTime(_ptr, t, getPtr(ic))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(ic)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/skottie/AnimationBuilder.kt

@@ -39,6 +39,7 @@ class AnimationBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _
             _nSetFontManager(_ptr, getPtr(fontMgr))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(fontMgr)
         }
     }
@@ -53,6 +54,7 @@ class AnimationBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _
             _nSetLogger(_ptr, getPtr(logger))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(logger)
         }
     }
@@ -76,6 +78,7 @@ class AnimationBuilder internal constructor(ptr: NativePointer) : Managed(ptr, _
             require(ptr != NullPointer) { "Failed to create Animation from data" }
             Animation(ptr)
         } finally {
+            reachabilityBarrier(data)
             reachabilityBarrier(this)
         }
     }

skiko/src/commonMain/kotlin/org/jetbrains/skia/svg/SVGCanvas.kt

@@ -6,6 +6,7 @@ import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.ExternalSymbolName
 import org.jetbrains.skia.impl.NativePointer
 import org.jetbrains.skia.impl.getPtr
+import org.jetbrains.skia.impl.reachabilityBarrier
 
 object SVGCanvas {
     /**
@@ -40,14 +41,18 @@ object SVGCanvas {
      */
     fun make(bounds: Rect, out: WStream, convertTextToPaths: Boolean, prettyXML: Boolean): Canvas {
         Stats.onNativeCall()
-        val ptr = SVGCanvas_nMake(
-            bounds.left,
-            bounds.top,
-            bounds.right,
-            bounds.bottom,
-            getPtr(out),
-            0 or (if (convertTextToPaths) 1 else 0) or if (prettyXML) 0 else 2
-        )
+        val ptr = try {
+            SVGCanvas_nMake(
+                bounds.left,
+                bounds.top,
+                bounds.right,
+                bounds.bottom,
+                getPtr(out),
+                0 or (if (convertTextToPaths) 1 else 0) or if (prettyXML) 0 else 2
+            )
+        } finally {
+            reachabilityBarrier(out)
+        }
         return Canvas(ptr, true, out)
     }
 

skiko/src/commonMain/kotlin/org/jetbrains/skia/svg/SVGDOM.kt

@@ -5,6 +5,15 @@ import org.jetbrains.skia.*
 import org.jetbrains.skia.ExternalSymbolName
 import org.jetbrains.skia.impl.*
 
+private fun makeSVGDOM(data: Data): NativePointer {
+    Stats.onNativeCall()
+    return try {
+        SVGDOM_nMakeFromData(getPtr(data))
+    } finally {
+        reachabilityBarrier(data)
+    }
+}
+
 class SVGDOM internal constructor(ptr: NativePointer) : RefCnt(ptr) {
     companion object {
         init {
@@ -12,10 +21,7 @@ class SVGDOM internal constructor(ptr: NativePointer) : RefCnt(ptr) {
         }
     }
 
-    constructor(data: Data) : this(SVGDOM_nMakeFromData(getPtr(data))) {
-        Stats.onNativeCall()
-        reachabilityBarrier(data)
-    }
+    constructor(data: Data) : this(makeSVGDOM(data))
 
     val root: SVGSVG?
         get() = try {
@@ -54,6 +60,7 @@ class SVGDOM internal constructor(ptr: NativePointer) : RefCnt(ptr) {
             SVGDOM_nRender(_ptr, getPtr(canvas))
             this
         } finally {
+            reachabilityBarrier(this)
             reachabilityBarrier(canvas)
         }
     }

skiko/src/jvmMain/kotlin/org/jetbrains/skia/shaper/Shaper.jvm.kt

@@ -5,6 +5,7 @@ import org.jetbrains.skia.ManagedString
 import org.jetbrains.skia.impl.InteropPointer
 import org.jetbrains.skia.impl.getPtr
 import org.jetbrains.skia.impl.interopScope
+import org.jetbrains.skia.impl.reachabilityBarrier
 
 internal actual fun Shaper.doShape(
     textUtf8: ManagedString,
@@ -16,19 +17,24 @@ internal actual fun Shaper.doShape(
     width: Float,
     runHandler: RunHandler
 ) {
-    interopScope {
-        Shaper_nShape(
-            _ptr,
-            getPtr(textUtf8),
-            fontIter as InteropPointer,
-            bidiIter as InteropPointer,
-            scriptIter as InteropPointer,
-            langIter as InteropPointer,
-            optsFeaturesLen = opts.features?.size ?: 0,
-            optsFeaturesIntArray = arrayOfFontFeaturesToInterop(opts.features),
-            optsBooleanProps = opts._booleanPropsToInt(),
-            width = width,
-            runHandler = runHandler as InteropPointer
-        )
+    try {
+        interopScope {
+            Shaper_nShape(
+                _ptr,
+                getPtr(textUtf8),
+                fontIter as InteropPointer,
+                bidiIter as InteropPointer,
+                scriptIter as InteropPointer,
+                langIter as InteropPointer,
+                optsFeaturesLen = opts.features?.size ?: 0,
+                optsFeaturesIntArray = arrayOfFontFeaturesToInterop(opts.features),
+                optsBooleanProps = opts._booleanPropsToInt(),
+                width = width,
+                runHandler = runHandler as InteropPointer
+            )
+        }
+    } finally {
+        reachabilityBarrier(this)
+        reachabilityBarrier(textUtf8)
     }
 }
\ No newline at end of file