fix(replay): Hold frame gate across emitLastScreenshot to prevent concurrent bitmap access

emitLastScreenshot runs on the main thread, so the downstream consumer queues
its bitmap read (JPEG compress) to the executor asynchronously. Without the
gate, the next capture tick's PixelCopy.request writes into the shared
screenshot while the queued read is still in flight. Submit the consumer call
to the executor so it runs inline on the worker thread while the gate is held,
same pattern as the masked capture path.

Also fixes the close-race test mock to return CompletedFuture instead of null,
matching the executor contract (same fix as inlineExecutor in cd3a7c0).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: romtsn

sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt

@@ -361,8 +361,27 @@ internal class PixelCopyStrategy(
   }
 
   override fun emitLastScreenshot() {
-    if (!frameInFlight.get() && lastCaptureSuccessful() && !screenshot.isRecycled) {
-      screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
+    if (!frameInFlight.compareAndSet(false, true)) {
+      return
+    }
+    if (!lastCaptureSuccessful() || screenshot.isRecycled) {
+      finishFrame()
+      return
+    }
+    // Submit to the executor so the downstream consumer's bitmap read (JPEG compress) runs inline
+    // on the worker thread while the gate is held, same as the masked capture path.
+    val submitted =
+      executor.submit(
+        ReplayRunnable("PixelCopyStrategy.emit") {
+          try {
+            screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
+          } finally {
+            finishFrame()
+          }
+        }
+      )
+    if (submitted == null) {
+      finishFrame()
     }
   }
 

sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt

@@ -141,7 +141,7 @@ class PixelCopyStrategyTest {
         // PixelCopyStrategy swallows the exception, so we have to capture it here and rethrow later
         failure.set(e)
       }
-      null
+      CompletedFuture
     }
 
     strategy = fixture.getSut(executor = executorThatClosesFirst)
@@ -229,6 +229,59 @@ class PixelCopyStrategyTest {
     verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
   }
 
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `emitLastScreenshot holds the frame gate until the emit task drains`() {
+    // emit submits the consumer call to the executor so the bitmap read (JPEG compress) runs
+    // inline on the worker thread while the gate is held — same pattern as the masked capture path.
+    // Invariant: while the emit task is still queued (gate held), a racing capture is dropped.
+    // Without the gate (old `if (!frameInFlight.get())`) that capture proceeds -> extra frame.
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val tasks = mutableListOf<Runnable>()
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).doAnswer {
+      tasks.add(it.arguments[0] as Runnable)
+      mock<Future<*>>()
+    }
+    val strategy = fixture.getSut(executor)
+
+    // Set up a successful last capture: capture -> queued mask task -> drain releases the gate.
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+    tasks.removeAll {
+      it.run()
+      true
+    }
+    verify(fixture.callback, times(1)).onScreenshotRecorded(any<Bitmap>())
+
+    // Emit takes the gate and queues the consumer task (still pending).
+    strategy.emitLastScreenshot()
+    // Callback hasn't fired yet — the task is queued, not drained.
+    verify(fixture.callback, times(1)).onScreenshotRecorded(any<Bitmap>())
+
+    // A capture racing in before the emit task drains must be dropped (gate held).
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+    verify(fixture.callback, times(1)).onScreenshotRecorded(any<Bitmap>())
+
+    // Drain the emit task -> callback fires, gate released -> captures resume.
+    tasks.removeAll {
+      it.run()
+      true
+    }
+    verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
+    captureStableFrame(strategy, root)
+    tasks.removeAll {
+      it.run()
+      true
+    }
+    verify(fixture.callback, times(3)).onScreenshotRecorded(any<Bitmap>())
+  }
+
   @Test
   @Config(shadows = [DeferredWindowPixelCopyShadow::class])
   fun `close defers cleanup until PixelCopy completes`() {