macOs, Windows. draw in a background thread

fixes 1) and 3) in https://github.com/JetBrains/skiko/issues/76

also fixes slow event dispathing in Compose (it is because vsync blocked AWT thread)

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/SkiaLayer.kt

@@ -174,7 +174,7 @@ open class SkiaLayer(
     @Suppress("LeakingThis")
     private val fpsCounter = defaultFPSCounter(this)
 
-    open fun update(nanoTime: Long) {
+    internal fun update(nanoTime: Long) {
         check(!isDisposed)
         check(isEventDispatchThread())
 
@@ -208,14 +208,21 @@ open class SkiaLayer(
         }
     }
 
-    open fun draw() {
+    internal fun prepareDrawContext(): Boolean {
         check(!isDisposed)
         contextHandler?.apply {
             if (!initContext()) {
                 fallbackToNextApi()
-                return
+                return false
             }
             initCanvas()
+        }
+        return true
+    }
+
+    internal fun draw() {
+        check(!isDisposed)
+        contextHandler?.apply {
             clearCanvas()
             synchronized(pictureLock) {
                 val picture = picture

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/Direct3DRedrawer.kt

@@ -2,6 +2,7 @@ package org.jetbrains.skiko.redrawer
 
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.swing.Swing
+import kotlinx.coroutines.withContext
 import org.jetbrains.skija.BackendRenderTarget
 import org.jetbrains.skija.DirectContext
 import org.jetbrains.skiko.FrameDispatcher
@@ -14,13 +15,14 @@ internal class Direct3DRedrawer(
 ) : Redrawer {
 
     private var isDisposed = false
+    private var disposeLock = Any()
 
     private val frameDispatcher = FrameDispatcher(Dispatchers.Swing) {
         update(System.nanoTime())
         draw()
     }
 
-    override fun dispose() {
+    override fun dispose() = synchronized(disposeLock) {
         frameDispatcher.cancel()
         isDisposed = true
     }
@@ -32,16 +34,26 @@ internal class Direct3DRedrawer(
 
     override fun redrawImmediately() {
         check(!isDisposed)
-        update(System.nanoTime())
-        draw()
+        // TODO now we wait until previous layer.draw is finished. it ends only on the next vsync.
+        //  because of that we lose one frame on resize and can theoretically see very small white bars on the sides of the window
+        //  to avoid this we should be able to draw in two modes: with vsync and without.
+        frameDispatcher.scheduleFrame()
     }
 
     private fun update(nanoTime: Long) {
         layer.update(nanoTime)
     }
 
-    private fun draw() {
-        layer.draw()
+    private suspend fun draw() {
+        if (layer.prepareDrawContext()) {
+            withContext(Dispatchers.IO) {
+                synchronized(disposeLock) {
+                    if (!isDisposed) {
+                        layer.draw()
+                    }
+                }
+            }
+        }
     }
 
     fun makeContext(device: Long) = DirectContext(

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/LinuxOpenGLRedrawer.kt

@@ -49,7 +49,9 @@ internal class LinuxOpenGLRedrawer(
     }
 
     private fun draw() {
-        layer.draw()
+        if (layer.prepareDrawContext()) {
+            layer.draw()
+        }
     }
 
     companion object {

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/MacOsOpenGLRedrawer.kt

 package org.jetbrains.skiko.redrawer
 
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.swing.Swing
 import org.jetbrains.skiko.FrameDispatcher
 import org.jetbrains.skiko.SkiaLayer
@@ -11,7 +10,6 @@ import org.jetbrains.skiko.Task
 import org.jetbrains.skiko.useDrawingSurfacePlatformInfo
 import javax.swing.SwingUtilities.convertPoint
 import javax.swing.SwingUtilities.getRootPane
-import kotlin.system.measureNanoTime
 
 // Current implementation is fragile (it works in all tested cases, but we can't test everything)
 //
@@ -31,7 +29,9 @@ internal class MacOsOpenGLRedrawer(
     private val drawLayer = object : AWTGLLayer(containerLayerPtr, setNeedsDisplayOnBoundsChange = true) {
         override fun draw() = synchronized(drawLock) {
             if (!isDisposed) {
-                layer.draw()
+                if (layer.prepareDrawContext()) {
+                    layer.draw()
+                }
             }
         }
 

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/MetalRedrawer.kt

@@ -2,6 +2,7 @@ package org.jetbrains.skiko.redrawer
 
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.swing.Swing
+import kotlinx.coroutines.withContext
 import org.jetbrains.skija.BackendRenderTarget
 import org.jetbrains.skija.DirectContext
 import org.jetbrains.skiko.FrameDispatcher
@@ -16,6 +17,7 @@ internal class MetalRedrawer(
     private val properties: SkiaLayerProperties
 ) : Redrawer {
     private var isDisposed = false
+    private var disposeLock = Any()
     private val device = layer.backedLayer.useDrawingSurfacePlatformInfo(::createMetalDevice)
 
     private val frameDispatcher = FrameDispatcher(Dispatchers.Swing) {
@@ -23,7 +25,7 @@ internal class MetalRedrawer(
         draw()
     }
 
-    override fun dispose() {
+    override fun dispose() = synchronized(disposeLock) {
         frameDispatcher.cancel()
         disposeDevice(device)
         isDisposed = true
@@ -36,16 +38,37 @@ internal class MetalRedrawer(
 
     override fun redrawImmediately() {
         check(!isDisposed)
-        update(System.nanoTime())
-        draw()
+        // TODO now we wait until previous layer.draw is finished. it ends only on the next vsync.
+        //  because of that we lose one frame on resize and can theoretically see very small white bars on the sides of the window
+        //  to avoid this we should be able to draw in two modes: with vsync and without.
+        frameDispatcher.scheduleFrame()
     }
 
     private fun update(nanoTime: Long) {
         layer.update(nanoTime)
     }
 
-    private fun draw() {
-        layer.draw()
+    private suspend fun draw() {
+        if (layer.prepareDrawContext()) {
+            // 2,3 GHz 8-Core Intel Core i9
+            //
+            // Test1. 8 windows, multiple clocks, 800x600
+            //
+            // Executors.newSingleThreadExecutor().asCoroutineDispatcher(): 20 FPS, 130% CPU
+            // Dispatchers.IO: 58 FPS, 460% CPU
+            //
+            // Test2. 60 windows, single clock, 800x600
+            //
+            // Executors.newSingleThreadExecutor().asCoroutineDispatcher(): 50 FPS, 150% CPU
+            // Dispatchers.IO: 50 FPS, 200% CPU
+            withContext(Dispatchers.IO) {
+                synchronized(disposeLock) {
+                    if (!isDisposed) {
+                        layer.draw()
+                    }
+                }
+            }
+        }
     }
 
     override fun syncSize() {

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/SoftwareRedrawer.kt

@@ -11,7 +11,9 @@ internal class SoftwareRedrawer(
 
     private val frameDispatcher = FrameDispatcher(Dispatchers.Swing) {
         layer.update(System.nanoTime())
-        layer.draw()
+        if (layer.prepareDrawContext()) {
+            layer.draw()
+        }
     }
 
     override fun dispose() {
@@ -24,6 +26,8 @@ internal class SoftwareRedrawer(
 
     override fun redrawImmediately() {
         layer.update(System.nanoTime())
-        layer.draw()
+        if (layer.prepareDrawContext()) {
+            layer.draw()
+        }
     }
 }
\ No newline at end of file

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/WindowsOpenGLRedrawer.kt

@@ -53,7 +53,9 @@ internal class WindowsOpenGLRedrawer(
     }
 
     private fun draw() {
-        layer.draw()
+        if (layer.prepareDrawContext()) {
+            layer.draw()
+        }
     }
 
     private fun makeCurrent() = makeCurrent(device, context)