Prevent exception being thrown on hasScrolledBody (#31485)

Convert scheduling to use `scheduleMicrotask` instead of `Timer.run`

packages/flutter/lib/src/scheduler/binding.dart

@@ -763,12 +763,21 @@ mixin SchedulerBinding on BindingBase, ServicesBinding {
     _warmUpFrame = true;
     Timeline.startSync('Warm-up frame');
     final bool hadScheduledFrame = _hasScheduledFrame;
-    // We use timers here to ensure that microtasks flush in between.
-    Timer.run(() {
+    final Completer<void> _warmUpFrameCompleter = Completer<void>();
+
+    // Lock events so touch events etc don't insert themselves until the
+    // scheduled frame has finished.
+    lockEvents(() async {
+      await _warmUpFrameCompleter.future;
+      Timeline.finishSync();
+    });
+
+    // We use scheduleMicrotask here to ensure that microtasks flush in between.
+    scheduleMicrotask(() {
       assert(_warmUpFrame);
       handleBeginFrame(null);
-    });
-    Timer.run(() {
+
+      scheduleMicrotask(() {
         assert(_warmUpFrame);
         handleDrawFrame();
         // We call resetEpoch after this frame so that, in the hot reload case,
@@ -781,15 +790,10 @@ mixin SchedulerBinding on BindingBase, ServicesBinding {
         // then skipping every frame and finishing in the new time.
         resetEpoch();
         _warmUpFrame = false;
+        _warmUpFrameCompleter.complete();
         if (hadScheduledFrame)
           scheduleFrame();
       });
-
-    // Lock events so touch events etc don't insert themselves until the
-    // scheduled frame has finished.
-    lockEvents(() async {
-      await endOfFrame;
-      Timeline.finishSync();
     });
   }
 

packages/flutter/test/scheduler/scheduler_test.dart

@@ -19,6 +19,26 @@ class TestStrategy {
   }
 }
 
+List<VoidCallback> runWithMicrotaskQueueSpy(VoidCallback callback) {
+  final List<VoidCallback> microtaskQueue = <VoidCallback>[];
+  runZoned<void>(
+    () {
+      callback();
+    },
+    zoneSpecification: ZoneSpecification(
+      scheduleMicrotask: (Zone self, ZoneDelegate parent, Zone zone, void f()) {
+        // Don't actually run the tasks, just record that it was scheduled.
+        microtaskQueue.add(f);
+        self.parent.scheduleMicrotask(() {
+          f();
+          microtaskQueue.remove(f);
+        });
+      },
+    ),
+  );
+  return microtaskQueue;
+}
+
 void main() {
   SchedulerBinding scheduler;
   setUpAll(() {
@@ -92,27 +112,27 @@ void main() {
   });
 
   test('2 calls to scheduleWarmUpFrame just schedules it once', () {
-    final List<VoidCallback> timerQueueTasks = <VoidCallback>[];
-    bool taskExecuted = false;
-    runZoned<void>(
-      () {
-        // Run it twice without processing the queued tasks.
+    final List<VoidCallback> microtaskQueue = runWithMicrotaskQueueSpy(() {
       scheduler.scheduleWarmUpFrame();
       scheduler.scheduleWarmUpFrame();
+    });
+
+    // scheduleWarmUpFrame scheduled 1 microtask
+    expect(microtaskQueue.length, 1);
+  });
+
+  test('Tasks are not executed before scheduleWarmUpFrame finishes', () async {
+    bool taskExecuted = false;
+    final List<VoidCallback> microtaskQueue = runWithMicrotaskQueueSpy(() {
         scheduler.scheduleTask(() { taskExecuted = true; }, Priority.touch);
-      },
-      zoneSpecification: ZoneSpecification(
-        createTimer: (Zone self, ZoneDelegate parent, Zone zone, Duration duration, void f()) {
-          // Don't actually run the tasks, just record that it was scheduled.
-          timerQueueTasks.add(f);
-          return null;
-        },
-      ),
-    );
+        Timer.run(() { taskExecuted = true; });
+        scheduler.scheduleWarmUpFrame();
+    });
+
+    expect(microtaskQueue.isNotEmpty, true);
+    await scheduler.endOfFrame;
 
-    // scheduleWarmUpFrame scheduled 2 Timers, scheduleTask scheduled 0 because
-    // events are locked.
-    expect(timerQueueTasks.length, 2);
+    expect(scheduler.schedulerPhase, SchedulerPhase.idle);
     expect(taskExecuted, false);
   });
 }