mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/wda/frame_source.py

@@ -0,0 +1,325 @@
+"""A phone's live picture for the Mac app, whatever the connection."""
+
+import struct
+import subprocess
+import threading
+import time
+
+from .video import (
+    DEFAULT_QUALITY,
+    HEARTBEAT_SECONDS,
+    IDLE_GRACE_SECONDS,
+    MAX_FRAME_BYTES,
+    MAX_VIEWERS,
+    PEEK_WAIT_SECONDS,
+    VIDEO_DETAIL,
+    VideoUnavailable,
+    WdaVideo,
+    mjpeg_settings,
+)
+
+# A tile in the grid of phones: small and slow; the focused phone gets the chosen width and rate.
+TILE_WIDTH = 196
+TILE_FPS = 4
+TILE_QUALITY = .5
+# The full picture's width per detail level, as a share of FULL_WIDTH (the connection's own frame width).
+FULL_WIDTH = 590
+DETAIL_SCALE = {"low": .5, "medium": .75, "high": 1.0}
+DETAIL_QUALITY = {detail: VIDEO_DETAIL[detail]["mjpegServerScreenshotQuality"] / 100 for detail in VIDEO_DETAIL}
+# After a failed pull, wait this long before the next.
+RETRY_SECONDS = 1.0
+# A helper process that exits is started again after this long while someone watches.
+RESTART_SECONDS = 1.0
+# The frame width a helper process is asked for at each detail level (its JPEG quality is DETAIL_QUALITY).
+DETAIL_WIDTH = {"low": 360, "medium": 480, "high": 720}
+
+
+def streams(video):
+    """Whether ``video`` serves the live stream and tiles (WdaVideo, or a FrameRelay)."""
+    return isinstance(video, (WdaVideo, FrameRelay))
+
+
+class FrameRelay:
+    """WdaVideo's frame source interface over ``pull(width, quality, after)``: (jpeg, key), or None when unchanged."""
+
+    kind = "relay"
+
+    def __init__(self, pull=None, *, source="relay", quality=DEFAULT_QUALITY, clock=time.monotonic,
+                 sleep=time.sleep):
+        if pull is not None:
+            self.pull = pull
+        self.source_name = source
+        self.clock, self._sleep_for = clock, sleep
+        self.condition = threading.Condition()
+        self.viewers = set()
+        self.focused = set()
+        self.frame = None
+        self.sequence = 0
+        self.key = None
+        self.error = None
+        self.worker = None
+        self.closed = False
+        self.idle_since = None
+        self.frame_times = []
+        self.pulls = 0
+        self.set_quality(*quality)
+
+    def pull(self, width, quality, after):
+        raise NotImplementedError
+
+    def set_quality(self, fps, detail):
+        mjpeg_settings(fps, detail)  # validates both, as WDA's do
+        with self.condition:
+            self.target_fps = fps
+            self.width = int(FULL_WIDTH * DETAIL_SCALE[detail])
+            self.quality = DETAIL_QUALITY[detail]
+
+    def reduced_fps(self):
+        return None
+
+    def mode(self):
+        """(width, quality, fps) to pull at now: the chosen ones while a stream is focused, a tile's otherwise."""
+        with self.condition:
+            if self.focused:
+                return self.width, self.quality, self.target_fps
+            return TILE_WIDTH, TILE_QUALITY, TILE_FPS
+
+    def status(self):
+        with self.condition:
+            live = self.frame is not None and self.clock() - self.frame[4] < 3
+            return {"status": "live" if live else "starting" if self.viewers else "idle", "kind": self.kind,
+                    "sourceKind": self.source_name, "error": self.error, "viewers": len(self.viewers),
+                    "fps": round(self.fps(), 1), "targetFps": self.target_fps, "reducedFps": None, "linkLoad": None,
+                    "capturedAt": self.frame[3] if self.frame else None, "stream": "/api/device/stream"}
+
+    def fps(self):
+        now = self.clock()
+        return len([t for t in self.frame_times if now - t <= 2]) / 2
+
+    def subscribe(self, focus=True):
+        """A viewer. ``focus`` (a live stream) asks for the full picture; a peek is a tile."""
+        with self.condition:
+            if self.closed:
+                raise VideoUnavailable("Live video is shutting down")
+            if len(self.viewers) >= MAX_VIEWERS:
+                raise VideoUnavailable("Too many live viewers")
+            viewer = object()
+            self.viewers.add(viewer)
+            if focus:
+                self.focused.add(viewer)
+            self.idle_since = None
+            if self.worker is None or not self.worker.is_alive():
+                self.worker = threading.Thread(target=self._run, name=f"mobster-{self.kind}-video", daemon=True)
+                self.worker.start()
+            self.condition.notify_all()
+            return viewer
+
+    def unsubscribe(self, viewer):
+        with self.condition:
+            self.viewers.discard(viewer)
+            self.focused.discard(viewer)
+            if not self.viewers:
+                self.idle_since = self.clock()
+            self.condition.notify_all()
+
+    next_frame = WdaVideo.next_frame
+
+    def latest(self):
+        with self.condition:
+            return self.frame
+
+    def peek(self, wait=PEEK_WAIT_SECONDS):
+        """A current still picture (a tile): starts a stopped source at tile size and waits up to ``wait``."""
+        try:
+            viewer = self.subscribe(focus=False)
+        except VideoUnavailable:
+            return self.latest()
+        try:
+            deadline = self.clock() + wait
+            with self.condition:
+                while not self.closed and (self.frame is None or self.clock() - self.frame[4] > IDLE_GRACE_SECONDS):
+                    remaining = deadline - self.clock()
+                    if remaining <= 0:
+                        break
+                    self.condition.wait(remaining)
+                return self.frame
+        finally:
+            self.unsubscribe(viewer)
+
+    def paced_frames(self, viewer, rate=lambda: None, heartbeat=HEARTBEAT_SECONDS, timeout=10.0):
+        """WdaVideo.paced_frames: new frames at most ``rate()`` a second, the same one again every ``heartbeat``."""
+        sequence, sent_at, looked_at = 0, None, None
+        while True:
+            fps = rate()
+            if isinstance(fps, (int, float)) and fps > 0 and looked_at is not None:
+                wait = looked_at + 1 / fps - self.clock()
+                if wait > 0:
+                    self._sleep_for(wait)
+                    with self.condition:
+                        if self.closed or viewer not in self.viewers:
+                            return
+            frame = self.next_frame(viewer, sequence, timeout=min(timeout, heartbeat))
+            looked_at = self.clock()
+            if frame is None:
+                with self.condition:
+                    if self.closed or viewer not in self.viewers:
+                        return
+                    frame = self.frame
+                if frame is None or (sent_at is not None and looked_at - sent_at < heartbeat):
+                    continue
+            sequence, sent_at = frame[0], looked_at
+            yield frame
+
+    def close(self):
+        with self.condition:
+            self.closed = True
+            self.condition.notify_all()
+
+    def _should_run(self):
+        with self.condition:
+            if self.closed:
+                return False
+            if self.viewers:
+                return True
+            return self.idle_since is not None and self.clock() - self.idle_since < IDLE_GRACE_SECONDS
+
+    def publish(self, data, key, content_type="image/jpeg"):
+        now = self.clock()
+        with self.condition:
+            self.sequence += 1
+            self.key = key
+            self.frame = (self.sequence, content_type, data, int(time.time() * 1000), now, self.source_name)
+            self.error = None
+            self.frame_times = [t for t in self.frame_times if now - t <= 2] + [now]
+            self.condition.notify_all()
+
+    def _run(self):
+        last_mode = None
+        while self._should_run():
+            width, quality, fps = self.mode()
+            started = self.clock()
+            # A change of size needs a new picture even when the screen is still.
+            after = self.key if (width, quality) == last_mode else None
+            try:
+                pulled = self.pull(width, quality, after)
+                self.pulls += 1
+            except Exception as error:  # noqa: BLE001 -- reported in status; the viewer sees no new frame
+                with self.condition:
+                    self.error = str(error) or type(error).__name__
+                self._sleep_for(RETRY_SECONDS)
+                continue
+            last_mode = (width, quality)
+            if pulled is not None:
+                self.publish(*pulled)
+            else:
+                with self.condition:  # the same picture: it is still current
+                    if self.frame is not None:
+                        self.frame = self.frame[:4] + (self.clock(),) + self.frame[5:]
+            wait = 1 / fps - (self.clock() - started)
+            if wait > 0:
+                self._sleep_for(wait)
+
+
+def read_exact(stream, size):
+    """``size`` bytes from ``stream``, or None at its end."""
+    chunks, left = [], size
+    while left:
+        chunk = stream.read(left)
+        if not chunk:
+            return None
+        chunks.append(chunk)
+        left -= len(chunk)
+    return b"".join(chunks)
+
+
+def read_frames(stream):
+    """The JPEGs a helper writes: 4-byte big-endian length, then the bytes. Ends at the stream's end or a bad length."""
+    while True:
+        header = read_exact(stream, 4)
+        if header is None:
+            return
+        (length,) = struct.unpack(">I", header)
+        if not 0 < length <= MAX_FRAME_BYTES:
+            return
+        data = read_exact(stream, length)
+        if data is None:
+            return
+        yield data
+
+
+class ProcessFrameSource(WdaVideo):
+    """A frame source fed by a helper process. ``command_for(fps, detail)``: the helper's argv for a quality."""
+
+    kind = "process"
+
+    def __init__(self, command_for, *, source="process", on_activity=None, clock=time.monotonic,
+                 quality=DEFAULT_QUALITY, spawn=subprocess.Popen):
+        super().__init__("http://127.0.0.1:0", mjpeg_url=None, session=None, on_activity=on_activity, clock=clock,
+                         quality=quality, screenshot_fallback=False)
+        self.command_for = command_for
+        self.source_name = source
+        self.quality = tuple(quality)
+        self.spawn = spawn
+        self.process = None
+
+    def status(self):
+        value = super().status()
+        value.update(kind=self.kind, stream="/api/device/stream")
+        return value
+
+    def set_quality(self, fps, detail):
+        settings = mjpeg_settings(fps, detail)  # validates
+        with self.condition:
+            self.settings, self.quality = settings, (fps, detail)
+        self._stop_process()  # the loop starts it again at the new quality
+
+    def _configure(self):
+        return True
+
+    def _stop_process(self):
+        process, self.process = self.process, None
+        if process is None:
+            return
+        try:
+            process.terminate()
+            process.wait(timeout=2)
+        except Exception:  # noqa: BLE001 -- it is going away either way
+            try:
+                process.kill()
+            except Exception:  # noqa: BLE001
+                pass
+
+    def _run(self):
+        try:
+            while self._should_run():
+                try:
+                    fps, detail = self.quality
+                    self.process = self.spawn(list(self.command_for(fps, detail)), stdin=subprocess.PIPE,
+                                              stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+                    process = self.process
+                    for data in read_frames(process.stdout):
+                        self._publish("image/jpeg", data, self.source_name)
+                        if not self._should_run():
+                            break
+                    code = process.poll()
+                    with self.condition:
+                        if code not in (None, 0, -15):
+                            self.error = f"exited {code}"
+                except Exception as error:  # noqa: BLE001 -- reported in status, retried while watched
+                    with self.condition:
+                        self.error = type(error).__name__
+                finally:
+                    self._stop_process()
+                deadline = self.clock() + RESTART_SECONDS
+                while self._should_run() and self.clock() < deadline:
+                    time.sleep(.1)
+        finally:
+            with self.condition:
+                self.worker = None
+                self.frame = None
+                self.frame_times = []
+            self.on_activity(False)
+
+    def close(self):
+        super().close()
+        threading.Thread(target=self._stop_process, name="mobster-frames-stop", daemon=True).start()

mobile_agent/wda/frame_store.py

@@ -0,0 +1,115 @@
+"""Screens a run points at, kept beside the journal."""
+
+import io
+import os
+import re
+import shutil
+import threading
+import uuid
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from ..paths import write_private
+
+FRAME_ID = re.compile(r"f[0-9a-f]{10}")
+RUN_ID = re.compile(r"[a-f0-9]{12}")
+
+
+class FrameStore:
+    """Screens a run points at (steps, receipts, proof), as JPEGs no more than MAX_SIDE px on their long
+    side. A frame is kept in memory at once and downscaled, then written beside the journal, on one worker
+    thread: the agent never waits for an image. Without durable history frames live in memory only."""
+
+    MAX_SIDE = 480
+    MAX_PER_RUN = 400
+    MAX_MEMORY_RUNS = 4
+
+    def __init__(self, root=None):
+        self.root = Path(root) if root else None
+        self.memory = OrderedDict()  # run id -> {frame id: bytes (raw until processed)}
+        self.lock = threading.Lock()
+        self.worker = ThreadPoolExecutor(max_workers=1, thread_name_prefix="mobster-frames")
+
+    def put(self, run_id, data):
+        """Keep ``data`` (JPEG bytes) for ``run_id``; returns its frame id, or None when the run is full."""
+        frame_id = "f" + uuid.uuid4().hex[:10]
+        with self.lock:
+            frames = self.memory.setdefault(run_id, {})
+            self.memory.move_to_end(run_id)
+            if len(frames) >= self.MAX_PER_RUN:
+                return None
+            frames[frame_id] = bytes(data)
+            # Older runs' frames are on disk (or, without durable history, gone with the oldest runs).
+            while len(self.memory) > (self.MAX_MEMORY_RUNS if self.root is not None else 20):
+                self.memory.popitem(last=False)
+        self.worker.submit(self._process, run_id, frame_id)
+        return frame_id
+
+    @classmethod
+    def downscale(cls, data):
+        try:
+            from PIL import Image
+            image = Image.open(io.BytesIO(data))
+            if max(image.size) <= cls.MAX_SIDE and image.format == "JPEG":
+                return data
+            image = image.convert("RGB")
+            image.thumbnail((cls.MAX_SIDE, cls.MAX_SIDE))
+            out = io.BytesIO()
+            image.save(out, "JPEG", quality=72)
+            return out.getvalue()
+        except Exception:
+            return None
+
+    def _process(self, run_id, frame_id):
+        with self.lock:
+            raw = self.memory.get(run_id, {}).get(frame_id)
+        small = self.downscale(raw) if raw is not None else None
+        if small is None:
+            with self.lock:
+                self.memory.get(run_id, {}).pop(frame_id, None)
+            return
+        with self.lock:
+            if frame_id in self.memory.get(run_id, {}):
+                self.memory[run_id][frame_id] = small
+        if self.root is not None:
+            try:
+                # frames/ itself is 0700 too: mkdir's mode covers only the folder it names, not the parents it makes.
+                self.root.mkdir(parents=True, exist_ok=True, mode=0o700)
+                os.chmod(self.root, 0o700)
+                folder = self.root / run_id
+                folder.mkdir(exist_ok=True, mode=0o700)
+                write_private(folder / f"{frame_id}.jpg", small, binary=True)
+            except OSError:
+                pass
+
+    def get(self, run_id, frame_id):
+        if not FRAME_ID.fullmatch(frame_id or ""):
+            return None
+        with self.lock:
+            data = self.memory.get(run_id, {}).get(frame_id)
+        if data is not None:
+            small = self.downscale(data)
+            return small
+        if self.root is not None:
+            try:
+                return (self.root / run_id / f"{frame_id}.jpg").read_bytes()
+            except OSError:
+                return None
+        return None
+
+    def folder(self, run_id):
+        """Where a run's files are kept (its frames, its tape), or None without durable history or for an id that
+        is not a run's."""
+        return self.root / run_id if self.root is not None and RUN_ID.fullmatch(run_id or "") else None
+
+    def delete(self, run_id):
+        with self.lock:
+            self.memory.pop(run_id, None)
+        folder = self.folder(run_id)
+        if folder is not None:
+            # An in-flight downscale may still write its frame. Remove the directory after that worker finishes.
+            self.worker.submit(shutil.rmtree, folder, ignore_errors=True).result()
+
+    def close(self):
+        self.worker.shutdown(wait=True, cancel_futures=False)

mobile_agent/wda/gate.py

@@ -0,0 +1,163 @@
+"""WebDriverAgent patches: one gate for screen and accessibility captures, on for simulators and off for iPhones.
+
+WDA's MJPEG broadcaster asks XCTest for a screenshot on its own queue while a request asks for the
+app's accessibility snapshot. On iOSWorld simulators an app stopped answering snapshots after a
+scroll with the stream running, and stayed stuck until it was closed (scorezone-003, 10 Oct 2026).
+The gate keeps the two apart, unless the runner starts with ``MOBSTER_CAPTURE_GATE=off`` in its
+environment (``TEST_RUNNER_`` prefix through xcodebuild):
+
+- every accessibility snapshot (``-[XCAXClient_iOS requestSnapshotForElement:...]``, which /source,
+  element queries and attribute reads all go through) holds it, waiting at most
+  ``FBMobsterSnapshotGateWait`` seconds for it, then running without it, as upstream does;
+- every screenshot (``+[FBScreenshot takeInOriginalResolutionWithScreenID:...]``) holds it;
+- the MJPEG broadcaster waits for it at most one frame interval, then skips that frame.
+
+With ``off`` nothing is locked, and the runner behaves as upstream's.
+
+Measured cost, 10 Oct 2026, "Frontier Bench 1" simulator, 4 other simulators busy, ABBA, 8 rounds of
+60 back-to-back source reads each with the stream at 30 fps:
+- read p50 went from 66.5 to 93 ms (median of rounds), and p90 from 82.5 to 127.5 ms;
+- the stream went from 26.6 to 18.7 frames a second while reads ran.
+A broadcaster that skipped a busy frame at once, instead of waiting a frame interval, sent 1.9 frames
+a second instead of 9.6 (stream at 10 fps).
+
+Measured effect on the hang, 11 Oct 2026: the tuning loop's 4-simulator scripted harness (iOSWorld
+scorezone-003, a swipe then done, no model), off and on interleaved ABBA, 4 runs per simulator a round.
+Off, 10 of 64 runs hung (15.6%, 95% CI 8.7-26.4%). On, 2 of 64 did (3.1%, 0.9-10.7%; Fisher p = 0.03).
+On those simulators, reads cost 61.5 -> 80.5 ms at p50 and the stream ran at 22.6 instead of 27.4 fps.
+Upstream's own guard (the ``accessibilityDeadline`` session setting, 3 s) hung none of 32 runs the same way,
+but 4 failed at 79 s instead: the stuck app's main run loop did not answer, so its reads failed sooner.
+
+Measured on an iPhone, 11 Oct 2026: an iPhone 15 Pro on iOS 26.0.1 over USB, off and on interleaved ABBA.
+- 8 rounds of 2 x 60 back-to-back reads of Settings > General, the stream at 30 fps: read p50 went from
+  160 to 241.5 ms, p90 from 193.5 to 290 ms; the stream went from 19.2 to 14.7 frames a second.
+- A scripted swipe then read on YouTube Shorts, 40 runs a side: no read stalled either way (0 of 40,
+  95% CI 0-8.8%). With the gate off, 2 runs failed at once with a transport error (cause not recorded).
+  Read p50 went from 86 to 168 ms, and the swipe's from 1025 to 1509 ms.
+- 10 short tasks on Smart, 20 runs off and 12 on: 19 of 20 passed off, 10 of 10 graded on; the median
+  per-task difference was +0.29 s with the gate on.
+The phone paid the cost and showed no hang to prevent, so ``runner_env`` starts iPhone runners with
+the gate off and simulator runners with it on. ``MOBSTER_CAPTURE_GATE=on`` or ``off`` in Mobster's own
+environment overrides that for both.
+
+Applied with ``patches.WDA_PATCHES`` (anchored, idempotent edits on the pinned release).
+"""
+
+import os
+
+# What the runner reads (its environment, through xcodebuild's TEST_RUNNER_ prefix), and the override.
+RUNNER_VARIABLE = "TEST_RUNNER_MOBSTER_CAPTURE_GATE"
+OVERRIDE = "MOBSTER_CAPTURE_GATE"
+# Per device kind: on for simulators (10 of 64 scripted runs hung without it), off for iPhones (no hang in
+# 40 runs either way, 81.5 ms more per read with it). Measurements above.
+DEFAULTS = {"simulator": "on", "phone": "off"}
+WORDS = {"on": "on", "1": "on", "true": "on", "yes": "on", "off": "off", "0": "off", "false": "off", "no": "off"}
+
+
+def gate_for(kind, environ=None):
+    if kind not in DEFAULTS:
+        raise ValueError(f"A runner's device kind is one of {', '.join(sorted(DEFAULTS))}, not {kind!r}")
+    environ = os.environ if environ is None else environ
+    for name in (OVERRIDE, RUNNER_VARIABLE):
+        said = WORDS.get(str(environ.get(name) or "").strip().casefold())
+        if said:
+            return said
+    return DEFAULTS[kind]
+
+
+def runner_env(kind, environ=None):
+    """The runner's gate as xcodebuild passes it on; merge it last into every runner's environment."""
+    return {RUNNER_VARIABLE: gate_for(kind, environ)}
+
+SNAPSHOT_FILE = "WebDriverAgentLib/Categories/XCAXClient_iOS+FBSnapshotReqParams.m"
+SCREENSHOT_FILE = "WebDriverAgentLib/Utilities/FBScreenshot.m"
+MJPEG_FILE = "WebDriverAgentLib/Utilities/FBMjpegServer.m"
+
+GATE_DECLARATION = (
+    "// Mobster: one gate for screen and accessibility captures (XCAXClient_iOS+FBSnapshotReqParams.m).\n"
+    "NSRecursiveLock *FBMobsterCaptureGate(void);\n")
+
+GATE_DEFINITION = """// Mobster: one gate for screen and accessibility captures, unless the runner's environment has
+// MOBSTER_CAPTURE_GATE=off (then nil: nothing is locked). A snapshot holds it, waiting at most
+// FBMobsterSnapshotGateWait seconds, then running without it; a screenshot holds it; the MJPEG
+// broadcaster waits at most one frame interval for it, then skips that frame.
+static const NSTimeInterval FBMobsterSnapshotGateWait = 2.0;
+
+NSRecursiveLock *FBMobsterCaptureGate(void)
+{
+  static NSRecursiveLock *gate;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    if (![NSProcessInfo.processInfo.environment[@"MOBSTER_CAPTURE_GATE"] isEqualToString:@"off"]) {
+      gate = [NSRecursiveLock new];
+      gate.name = @"mobster.capture-gate";
+    }
+    [FBLogger logFmt:@"Mobster capture gate: %@", nil == gate ? @"off" : @"on"];
+  });
+  return gate;
+}
+
+static id swizzledRequestSnapshotForElement(id self, SEL _cmd, id element, id attributes,
+                                            id parameters, NSError **error)
+{
+  NSRecursiveLock *gate = FBMobsterCaptureGate();
+  BOOL held = nil != gate
+    && [gate lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:FBMobsterSnapshotGateWait]];
+  if (nil != gate && !held) {
+    [FBLogger log:@"Mobster: a snapshot ran without the capture gate after waiting for a screenshot"];
+  }
+  @try {
+    return FBMobsterUngatedSnapshot(self, _cmd, element, attributes, parameters, error);
+  } @finally {
+    if (held) {
+      [gate unlock];
+    }
+  }
+}
+
+"""
+
+PATCHES = (
+    # Snapshots: upstream's swizzle is renamed and wrapped by a gated one with its old name.
+    (SNAPSHOT_FILE,
+     "static id swizzledRequestSnapshotForElement(id self, SEL _cmd, id element, id attributes, id parameters, "
+     "NSError **error)\n{\n",
+     "static id FBMobsterUngatedSnapshot(id self, SEL _cmd, id element, id attributes, id parameters, "
+     "NSError **error)\n{\n"),
+    (SNAPSHOT_FILE,
+     "@implementation XCAXClient_iOS (FBSnapshotReqParams)\n",
+     GATE_DEFINITION + "@implementation XCAXClient_iOS (FBSnapshotReqParams)\n"),
+    # Screenshots hold the gate from the request until its reply or timeout.
+    (SCREENSHOT_FILE,
+     "#import \"XCUIScreen.h\"\n\nstatic const NSTimeInterval SCREENSHOT_TIMEOUT = 20.;\n",
+     "#import \"XCUIScreen.h\"\n\n" + GATE_DECLARATION + "\nstatic const NSTimeInterval SCREENSHOT_TIMEOUT = 20.;\n"),
+    (SCREENSHOT_FILE,
+     "  [proxy _XCT_requestScreenshot:screnshotRequest\n",
+     "  NSRecursiveLock *gate = FBMobsterCaptureGate();\n"
+     "  [gate lock];\n"
+     "  [proxy _XCT_requestScreenshot:screnshotRequest\n"),
+    (SCREENSHOT_FILE,
+     "  if (nil != error && nil != innerError) {\n    *error = innerError;\n  }\n  return screenshotData;\n",
+     "  [gate unlock];\n"
+     "  if (nil != error && nil != innerError) {\n    *error = innerError;\n  }\n  return screenshotData;\n"),
+    # The broadcaster waits one frame interval for a snapshot in flight, then skips the frame.
+    (MJPEG_FILE,
+     "static const char *QUEUE_NAME = \"JPEG Screenshots Provider Queue\";\n",
+     "static const char *QUEUE_NAME = \"JPEG Screenshots Provider Queue\";\n" + GATE_DECLARATION),
+    (MJPEG_FILE,
+     "  NSData *screenshotData = [FBScreenshot takeInOriginalResolutionWithScreenID:self.mainScreenID\n",
+     "  // Mobster: a frame waits for a snapshot in flight at most one frame interval, then is skipped.\n"
+     "  NSRecursiveLock *captureGate = FBMobsterCaptureGate();\n"
+     "  if (nil != captureGate && ![captureGate lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:\n"
+     "        (NSTimeInterval)timerInterval / NSEC_PER_SEC]]) {\n"
+     "    [self scheduleNextScreenshotWithInterval:timerInterval timeStarted:timeStarted];\n"
+     "    return;\n"
+     "  }\n"
+     "  NSData *screenshotData = [FBScreenshot takeInOriginalResolutionWithScreenID:self.mainScreenID\n"),
+    (MJPEG_FILE,
+     "                                                                      timeout:FRAME_TIMEOUT\n"
+     "                                                                        error:&error];\n",
+     "                                                                      timeout:FRAME_TIMEOUT\n"
+     "                                                                        error:&error];\n"
+     "  [captureGate unlock];\n"),
+)