Ensure awaitFrame() only awaits a single frame when used from the main looper

ui/kotlinx-coroutines-android/src/HandlerDispatcher.kt

@@ -185,22 +185,27 @@ private var choreographer: Choreographer? = null
 public suspend fun awaitFrame(): Long {
     // fast path when choreographer is already known
     val choreographer = choreographer
-    if (choreographer != null) {
-        return suspendCancellableCoroutine { cont ->
+    return if (choreographer != null) {
+        suspendCancellableCoroutine { cont ->
             postFrameCallback(choreographer, cont)
         }
+    } else {
+        awaitFrameSlowPath()
     }
-    // post into looper thread to figure it out
-    return suspendCancellableCoroutine { cont ->
-        Dispatchers.Main.dispatch(EmptyCoroutineContext, Runnable {
+}
+
+private suspend fun awaitFrameSlowPath(): Long = suspendCancellableCoroutine { cont ->
+    if (Looper.myLooper() === Looper.getMainLooper()) { // Check if we are already in the main looper thread
+        updateChoreographerAndPostFrameCallback(cont)
+    } else { // post into looper thread to figure it out
+        Dispatchers.Main.dispatch(cont.context, Runnable {
             updateChoreographerAndPostFrameCallback(cont)
         })
     }
 }
 
 private fun updateChoreographerAndPostFrameCallback(cont: CancellableContinuation<Long>) {
-    val choreographer = choreographer ?:
-    Choreographer.getInstance()!!.also { choreographer = it }
+    val choreographer = choreographer ?: Choreographer.getInstance()!!.also { choreographer = it }
     postFrameCallback(choreographer, cont)
 }
 

ui/kotlinx-coroutines-android/test/HandlerDispatcherTest.kt

@@ -109,16 +109,14 @@ class HandlerDispatcherTest : TestBase() {
         launch(Dispatchers.Main, start = CoroutineStart.UNDISPATCHED) {
             expect(1)
             awaitFrame()
-            expect(5)
+            expect(3)
         }
         expect(2)
         // Run choreographer detection
         mainLooper.runOneTask()
-        expect(3)
-        mainLooper.scheduler.advanceBy(50, TimeUnit.MILLISECONDS)
         expect(4)
-        mainLooper.scheduler.advanceBy(51, TimeUnit.MILLISECONDS)
-        finish(6)
+        mainLooper.scheduler.advanceBy(50, TimeUnit.MILLISECONDS)
+        finish(5)
     }
 
     private fun CoroutineScope.doTestAwaitWithDetectedChoreographer() {

ui/kotlinx-coroutines-javafx/build.gradle.kts

@@ -21,40 +21,3 @@ javafx {
     modules = listOf("javafx.controls")
     configuration = "javafx"
 }
-
-val JDK_18: String? by lazy {
-    System.getenv("JDK_18")
-}
-
-val checkJdk8 by tasks.registering {
-    // only fail w/o JDK_18 when actually trying to test, not during project setup phase
-    doLast {
-        if (JDK_18 == null) {
-            throw GradleException(
-                """
-                JDK_18 environment variable is not defined.
-                Can't run JDK 8 compatibility tests.
-                Please ensure JDK 8 is installed and that JDK_18 points to it.
-                """.trimIndent()
-            )
-        }
-    }
-}
-
-val jdk8Test by tasks.registering(Test::class) {
-    // Run these tests only during nightly stress test
-    onlyIf { project.properties["stressTest"] != null }
-
-    val test = tasks.test.get()
-
-    classpath = test.classpath
-    testClassesDirs = test.testClassesDirs
-    executable = "$JDK_18/bin/java"
-
-    dependsOn("compileTestKotlin")
-    dependsOn(checkJdk8)
-}
-
-tasks.build {
-    dependsOn(jdk8Test)
-}

ui/kotlinx-coroutines-javafx/src/JavaFxDispatcher.kt

@@ -34,22 +34,22 @@ public sealed class JavaFxDispatcher : MainCoroutineDispatcher(), Delay {
 
     /** @suppress */
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
-        val timeline = schedule(timeMillis, TimeUnit.MILLISECONDS) {
+        val timeline = schedule(timeMillis) {
             with(continuation) { resumeUndispatched(Unit) }
         }
         continuation.invokeOnCancellation { timeline.stop() }
     }
 
     /** @suppress */
     override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
-        val timeline = schedule(timeMillis, TimeUnit.MILLISECONDS) {
+        val timeline = schedule(timeMillis) {
             block.run()
         }
         return DisposableHandle { timeline.stop() }
     }
 
-    private fun schedule(time: Long, unit: TimeUnit, handler: EventHandler<ActionEvent>): Timeline =
-        Timeline(KeyFrame(Duration.millis(unit.toMillis(time).toDouble()), handler)).apply { play() }
+    private fun schedule(timeMillis: Long, handler: EventHandler<ActionEvent>): Timeline =
+        Timeline(KeyFrame(Duration.millis(timeMillis.toDouble()), handler)).apply { play() }
 }
 
 internal class JavaFxDispatcherFactory : MainDispatcherFactory {
@@ -97,7 +97,7 @@ public suspend fun awaitPulse(): Long = suspendCancellableCoroutine { cont ->
 }
 
 private class PulseTimer : AnimationTimer() {
-    val next = CopyOnWriteArrayList<CancellableContinuation<Long>>()
+    private val next = CopyOnWriteArrayList<CancellableContinuation<Long>>()
 
     override fun handle(now: Long) {
         val cur = next.toTypedArray()
@@ -116,6 +116,7 @@ internal fun initPlatform(): Boolean = PlatformInitializer.success
 
 // Lazily try to initialize JavaFx platform just once
 private object PlatformInitializer {
+    @JvmField
     val success = run {
         /*
          * Try to instantiate JavaFx platform in a way which works

ui/kotlinx-coroutines-swing/src/SwingDispatcher.kt

@@ -7,7 +7,6 @@ package kotlinx.coroutines.swing
 import kotlinx.coroutines.*
 import kotlinx.coroutines.internal.*
 import java.awt.event.*
-import java.util.concurrent.*
 import javax.swing.*
 import kotlin.coroutines.*
 
@@ -29,26 +28,22 @@ public sealed class SwingDispatcher : MainCoroutineDispatcher(), Delay {
 
     /** @suppress */
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
-        val timer = schedule(timeMillis, TimeUnit.MILLISECONDS, ActionListener {
+        val timer = schedule(timeMillis) {
             with(continuation) { resumeUndispatched(Unit) }
-        })
+        }
         continuation.invokeOnCancellation { timer.stop() }
     }
 
     /** @suppress */
     override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
-        val timer = schedule(timeMillis, TimeUnit.MILLISECONDS, ActionListener {
+        val timer = schedule(timeMillis) {
             block.run()
-        })
-        return object : DisposableHandle {
-            override fun dispose() {
-                timer.stop()
-            }
         }
+        return DisposableHandle { timer.stop() }
     }
 
-    private fun schedule(time: Long, unit: TimeUnit, action: ActionListener): Timer =
-        Timer(unit.toMillis(time).coerceAtMost(Int.MAX_VALUE.toLong()).toInt(), action).apply {
+    private fun schedule(timeMillis: Long, action: ActionListener): Timer =
+        Timer(timeMillis.coerceAtMost(Int.MAX_VALUE.toLong()).toInt(), action).apply {
             isRepeats = false
             start()
         }