Spend the time before a traversal only in the frame after the one measured

With disableIdleMountItemFrameCallbackRearmAndroid on, the frame callback
stops re-arming once nothing is left to mount, and the sleep a slice had
measured after the last frame waited for the next burst's first frame,
which spent it before its traversal however many vsyncs had passed. The
measured time now lapses once a frame interval has passed since it was
measured, so only the frame right after the measured one spends it.

Author: YevheniiKotyrlo

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/PreMountItemsBetweenFrames.kt

@@ -28,7 +28,8 @@ import com.facebook.react.common.SystemClock
  * frame's draw until the render thread takes the frame, and the frame leaves no time after it. A
  * frame then pre-mounts before its traversal for as long as the last frame's UI thread slept after
  * its callbacks, less one slice and at most half a frame: the work shortens that sleep instead of
- * delaying the frame, and a frame that no longer sleeps ends it.
+ * delaying the frame, and a frame that no longer sleeps ends it. A vsync that passes with no frame
+ * callback, as while the callback is not re-armed with nothing to mount, ends it too.
  */
 internal class PreMountItemsBetweenFrames(
     private val dispatcher: MountItemDispatcher,
@@ -38,12 +39,13 @@ internal class PreMountItemsBetweenFrames(
     exceptionHandler: JSExceptionHandler,
 ) {
   private var nextFrameNanos: Long = 0L
-  private var halfFrameNanos: Long = SIXTY_HERTZ_FRAME_NANOS / 2
+  private var frameIntervalNanos: Long = SIXTY_HERTZ_FRAME_NANOS
   private var isSliceQueued: Boolean = false
   private var isFrameSleepUnmeasured: Boolean = false
   private var callbacksEndNanos: Long = 0L
   private var callbacksEndThreadCpuNanos: Long = 0L
   private var beforeTraversalBudgetNanos: Long = 0L
+  private var beforeTraversalBudgetMeasuredAtNanos: Long = 0L
   private var preMountedBeforeTraversalNanos: Long = 0L
   private val slice: Runnable =
       object : GuardedRunnable(exceptionHandler) {
@@ -53,7 +55,10 @@ internal class PreMountItemsBetweenFrames(
         }
       }
 
-  /** Pre-mounts before this frame's traversal for the budget the last frame's sleep left it. */
+  /**
+   * Pre-mounts before this frame's traversal for the budget the last frame's sleep left it, unless
+   * a vsync has passed since that sleep was measured.
+   */
   @UiThread
   @ThreadConfined(UI)
   fun preMountBeforeTraversal() {
@@ -64,6 +69,9 @@ internal class PreMountItemsBetweenFrames(
       return
     }
     val startNanos = SystemClock.nanoTime()
+    if (startNanos - beforeTraversalBudgetMeasuredAtNanos > frameIntervalNanos) {
+      return
+    }
     dispatcher.dispatchPreMountItemsUntil(startNanos + budgetNanos)
     preMountedBeforeTraversalNanos = SystemClock.nanoTime() - startNanos
   }
@@ -72,9 +80,8 @@ internal class PreMountItemsBetweenFrames(
   @UiThread
   @ThreadConfined(UI)
   fun scheduleAfterFrame(frameTimeNanos: Long) {
-    val frameIntervalNanos = frameIntervalSource.frameIntervalNanos() ?: SIXTY_HERTZ_FRAME_NANOS
+    frameIntervalNanos = frameIntervalSource.frameIntervalNanos() ?: SIXTY_HERTZ_FRAME_NANOS
     nextFrameNanos = frameTimeNanos + frameIntervalNanos
-    halfFrameNanos = frameIntervalNanos / 2
     if (dispatcher.hasPreMountItems() || preMountedBeforeTraversalNanos > 0L) {
       callbacksEndNanos = SystemClock.nanoTime()
       callbacksEndThreadCpuNanos = threadCpuClock.threadCpuTimeNanos()
@@ -97,23 +104,24 @@ internal class PreMountItemsBetweenFrames(
    * callbacks and its end, plus what it pre-mounted before its traversal, which that sleep
    * absorbed, less one slice. A frame that slept less than half a slice gets none.
    */
-  private fun measureBeforeTraversalBudget(): Long {
+  private fun measureBeforeTraversalBudget(nowNanos: Long): Long {
     val threadCpuNanos = threadCpuClock.threadCpuTimeNanos()
     if (threadCpuNanos < 0L || callbacksEndThreadCpuNanos < 0L) {
       return 0L
     }
-    val asleepNanos =
-        (SystemClock.nanoTime() - callbacksEndNanos) - (threadCpuNanos - callbacksEndThreadCpuNanos)
+    val asleepNanos = (nowNanos - callbacksEndNanos) - (threadCpuNanos - callbacksEndThreadCpuNanos)
     if (asleepNanos < SLICE_NANOS / 2) {
       return 0L
     }
-    return minOf(halfFrameNanos, asleepNanos + preMountedBeforeTraversalNanos - SLICE_NANOS)
+    return minOf(frameIntervalNanos / 2, asleepNanos + preMountedBeforeTraversalNanos - SLICE_NANOS)
   }
 
   private fun runSlice() {
     if (isFrameSleepUnmeasured) {
       isFrameSleepUnmeasured = false
-      beforeTraversalBudgetNanos = measureBeforeTraversalBudget()
+      beforeTraversalBudgetMeasuredAtNanos = SystemClock.nanoTime()
+      beforeTraversalBudgetNanos =
+          measureBeforeTraversalBudget(beforeTraversalBudgetMeasuredAtNanos)
     }
     if (dispatcher.hasMountItems()) {
       dispatcher.tryDispatchMountItems()

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/fabric/mounting/PreMountItemsBetweenFramesTest.kt

@@ -390,6 +390,27 @@ class PreMountItemsBetweenFramesTest {
     assertThat(runFrame(frames[2], MILLISECOND_NANOS)).isEqualTo(9)
   }
 
+  @Test
+  fun aFrameAfterVsyncsWithNoFrameCallbackLeavesItsTraversalAlone() {
+    displayFrameIntervalNanos = SIXTY_HERTZ_FRAME_NANOS
+    val frames = (0 until 2).map { frame -> FIRST_FRAME_NANOS + frame * SIXTY_HERTZ_FRAME_NANOS }
+    queuePreMountItems(count = 9)
+    runFrame(frames[0], MILLISECOND_NANOS, renderThreadReadyAtNanos = frames[1])
+    runBetweenFrames()
+    runFrame(
+        frames[1],
+        MILLISECOND_NANOS,
+        renderThreadReadyAtNanos = frames[1] + SIXTY_HERTZ_FRAME_NANOS,
+    )
+    runBetweenFrames()
+
+    // With nothing left to mount, the frame callback stops re-arming, and the next burst's first
+    // frame comes ten vsyncs later: the sleep measured before them says nothing about its frame.
+    queuePreMountItems(count = 9)
+
+    assertThat(runFrame(frames[1] + 11 * SIXTY_HERTZ_FRAME_NANOS, MILLISECOND_NANOS)).isZero()
+  }
+
   @Test
   fun framesThatKeepWaitingQueueNothingOnceTheItemsRunOut() {
     displayFrameIntervalNanos = SIXTY_HERTZ_FRAME_NANOS