Synchronize edge-scroll cursor geometry after relayout

Refresh edge-scroll fractions from laid-out scroll positions and repaint when
they differ from the values used by the frame. Preserve the repaint when a
deferred settings refresh has already changed the model.

Cover DPR changes, viewport clamping, detached scroll axes and restoration
with the actual video and cursor widgets in Original and Custom modes.

Verified 87 native Flutter cursor tests on each of macOS and Linux, plus
17 Chrome Web cursor tests.

flutter/lib/desktop/pages/remote_page.dart

@@ -1173,6 +1173,7 @@ class _ImagePaintState extends State<ImagePaint> {
               child: child);
         });
     if (c.imageOverflow.isTrue && c.scrollStyle != ScrollStyle.scrollauto) {
+      _syncEdgeScrollAfterLayout(c);
       final paintWidth = c.getDisplayWidth() * s;
       final paintHeight = c.getDisplayHeight() * s;
       final paintSize = Size(paintWidth, paintHeight);
@@ -1217,6 +1218,16 @@ class _ImagePaintState extends State<ImagePaint> {
     }
   }
 
+  void _syncEdgeScrollAfterLayout(CanvasModel canvas) {
+    if (canvas.scrollStyle != ScrollStyle.scrolledge) return;
+    final renderedScroll = (canvas.scrollX, canvas.scrollY);
+    // Relayout can clamp or detach scroll positions without a scroll event.
+    SchedulerBinding.instance.addPostFrameCallback((_) {
+      if (!mounted) return;
+      canvas.updateEdgeScrollAfterLayout(renderedScroll);
+    });
+  }
+
   Widget _buildScrollbarNonTextureRender(
       ImageModel m, Size imageSize, double s) {
     return CustomPaint(

flutter/lib/models/model.dart

@@ -2702,6 +2702,14 @@ class CanvasModel with ChangeNotifier {
     notifyListeners();
   }
 
+  void updateEdgeScrollAfterLayout((double, double) renderedScroll) {
+    updateScrollPercent();
+    // A delayed refresh may already have changed the model without repainting.
+    if (renderedScroll != (_scrollX, _scrollY)) {
+      notifyListeners();
+    }
+  }
+
   panX(double dx) {
     _x += dx;
     if (isMobile) {

flutter/test/cursor_scroll_edge_test.dart

@@ -58,12 +58,29 @@ class _ScrollCanvas extends CanvasModel {
     resetOffset();
     imageOverflow.value = true;
   }
+  Size viewport = _viewport;
+  double imageScale = 1;
   @override
-  Size get size => _viewport;
+  Size get size => viewport;
+  @override
+  double get scale => imageScale;
+  @override
+  double get x => (size.width - getDisplayWidth() * scale) / 2;
+  @override
+  double get y => (size.height - getDisplayHeight() * scale) / 2;
   @override
   ScrollStyle get scrollStyle => ScrollStyle.scrolledge;
   @override
   final ViewStyle viewStyle;
+
+  void relayout(Size viewport, double dpr) {
+    this.viewport = viewport;
+    imageScale = 1 / dpr;
+    imageOverflow.value = viewport.width < getDisplayWidth() * scale ||
+        viewport.height < getDisplayHeight() * scale;
+    setScrollPercent(0, 0);
+    notifyListeners();
+  }
 }
 
 class _Cursor extends CursorModel {
@@ -127,6 +144,12 @@ void main() {
             (tester) => tester
                 .runAsync(() => _check(tester, (style, texture, frame, dpr))));
       }
+      for (final refreshBeforeLayout in [true, false]) {
+        testWidgets(
+            'ScrollEdge relayout $style texture=$texture early=$refreshBeforeLayout',
+            (tester) => tester.runAsync(() =>
+                _checkRelayout(tester, (style, texture, refreshBeforeLayout))));
+      }
     }
   }
 }
@@ -166,20 +189,83 @@ Future<void> _check(
     expect(vertical ? ffi.canvasModel.scrollY : ffi.canvasModel.scrollX,
         closeTo(scrolling.offset / (vertical ? frame.height : frame.width), 1e-9));
     await tester.pump();
-    final painter =
-        tester.widget<CustomPaint>(_paintOf(cursor)).painter! as ImagePainter;
-    final output = _Draw();
-    painter.paint(output, _viewport);
-    final hotspot = tester.getTopLeft(_paintOf(cursor)) +
-        output.position! +
-        _hotspot * output.factor;
-    final target = tester.getTopLeft(videoWidget) + pointer;
-    expect(hotspot.dx, closeTo(target.dx, 1e-9));
-    expect(hotspot.dy, closeTo(target.dy, 1e-9));
+    _expectAlignment(tester, ffi, videoWidget);
   }
   await tester.pumpWidget(const SizedBox.shrink());
 }
 
+Future<void> _checkRelayout(
+    WidgetTester tester, (String, bool, bool) testCase) async {
+  final (style, texture, refreshBeforeLayout) = testCase;
+  tester.view.devicePixelRatio = 1;
+  tester.view.physicalSize = _viewport;
+  addTearDown(tester.view.reset);
+  final video = await createTestImage(width: 400, height: 320);
+  final cursor = await createTestImage(width: 48, height: 64);
+  final ffi = _FFI(video, cursor,
+      texture: texture, style: style, position: const Offset(150.25, 120.75));
+  final canvas = ffi.canvasModel as _ScrollCanvas;
+  addTearDown(() {
+    canvas.scrollHorizontal.dispose();
+    canvas.scrollVertical.dispose();
+    canvas.dispose();
+    ffi.imageModel.dispose();
+    ffi.cursorModel.dispose();
+    video.dispose();
+    cursor.dispose();
+  });
+  await _mount(tester, ffi, 1);
+  canvas.performEdgeScroll(Vector2(20, 20));
+  await tester.pump();
+  final videoWidget = texture ? find.byType(Texture) : _paintOf(video);
+  _expectAlignment(tester, ffi, videoWidget);
+  for (final (viewport, dpr) in [
+    (const Size(160, 120), 2.0),
+    (const Size(195, 155), 2.0), // Clamp both existing scroll positions.
+    (const Size(240, 155), 2.0), // Detach the horizontal scroll controller.
+    (const Size(240, 200), 2.0), // No scrolling remains.
+    (_viewport, 1.0),
+  ]) {
+    tester.view.devicePixelRatio = dpr;
+    tester.view.physicalSize = viewport * dpr;
+    canvas.relayout(viewport, dpr);
+    // A settings refresh may run before layout or after the first cursor build.
+    if (refreshBeforeLayout) {
+      canvas.updateScrollPercent();
+    } else {
+      tester.binding.addPostFrameCallback((_) => canvas.updateScrollPercent());
+    }
+    await _mount(tester, ffi, dpr);
+    await tester.pumpAndSettle(const Duration(milliseconds: 16),
+        EnginePhase.sendSemanticsUpdate, const Duration(seconds: 1));
+    _expectAlignment(tester, ffi, videoWidget);
+  }
+  await tester.pumpWidget(const SizedBox.shrink());
+}
+
+void _expectAlignment(WidgetTester tester, FFI ffi, Finder videoWidget) {
+  final cursor = ffi.cursorModel;
+  final cursorWidget = _paintOf(cursor.image!);
+  final painter =
+      tester.widget<CustomPaint>(cursorWidget).painter! as ImagePainter;
+  final output = _Draw();
+  painter.paint(output, ffi.canvasModel.size);
+  final hotspot = tester.getTopLeft(cursorWidget) +
+      output.position! +
+      _hotspot * output.factor;
+  var videoOrigin = tester.getTopLeft(videoWidget);
+  final video = tester.widget(videoWidget);
+  if (video is CustomPaint) {
+    final drawnVideo = _Draw();
+    video.painter!.paint(drawnVideo, ffi.canvasModel.size);
+    videoOrigin += drawnVideo.position!;
+  }
+  final target =
+      videoOrigin + Offset(cursor.x, cursor.y) * ffi.canvasModel.scale;
+  expect(hotspot.dx, closeTo(target.dx, 1e-9));
+  expect(hotspot.dy, closeTo(target.dy, 1e-9));
+}
+
 Finder _paintOf(ui.Image image) => find.byWidgetPredicate((widget) =>
     widget is CustomPaint &&
     widget.painter is ImagePainter &&