Simplify test and add platformdispatcher test

shell/common/engine_unittests.cc

@@ -582,6 +582,7 @@ TEST_F(EngineTest, AnimatorSubmitWarmUpImplicitView) {
   EXPECT_CALL(delegate_, GetPlatformMessageHandler)
       .WillOnce(ReturnRef(platform_message_handler));
 
+  fml::AutoResetWaitableEvent continuation_ready_latch;
   fml::AutoResetWaitableEvent draw_latch;
   EXPECT_CALL(animator_delegate, OnAnimatorDraw)
       .WillOnce(Invoke([&draw_latch](
@@ -594,17 +595,14 @@ TEST_F(EngineTest, AnimatorSubmitWarmUpImplicitView) {
         draw_latch.Signal();
       }));
   EXPECT_CALL(animator_delegate, OnAnimatorBeginFrame)
-      .WillRepeatedly(Invoke([&engine_context](fml::TimePoint frame_target_time,
-                                               uint64_t frame_number) {
-        engine_context->EngineTaskSync([&](Engine& engine) {
-          engine.BeginFrame(frame_target_time, frame_number);
-        });
-      }));
-
-  static fml::AutoResetWaitableEvent continuation_ready_latch;
-  continuation_ready_latch.Reset();
-  AddNativeCallback("NotifyNative",
-                    [](auto args) { continuation_ready_latch.Signal(); });
+      .WillRepeatedly(
+          Invoke([&engine_context, &continuation_ready_latch](
+                     fml::TimePoint frame_target_time, uint64_t frame_number) {
+            continuation_ready_latch.Signal();
+            engine_context->EngineTaskSync([&](Engine& engine) {
+              engine.BeginFrame(frame_target_time, frame_number);
+            });
+          }));
 
   std::unique_ptr<Animator> animator;
   PostSync(task_runners_.GetUITaskRunner(),
@@ -619,12 +617,15 @@ TEST_F(EngineTest, AnimatorSubmitWarmUpImplicitView) {
   engine_context = EngineContext::Create(delegate_, settings_, task_runners_,
                                          std::move(animator));
 
-  auto configuration = RunConfiguration::InferFromSettings(settings_);
-  configuration.SetEntrypoint("renderWarmUpImplicitViewAfterMetricsChanged");
-  engine_context->Run(std::move(configuration));
+  engine_context->EngineTaskSync(
+      [](Engine& engine) { engine.ScheduleFrame(true); });
 
   continuation_ready_latch.Wait();
 
+  auto configuration = RunConfiguration::InferFromSettings(settings_);
+  configuration.SetEntrypoint("renderWarmUpImplicitView");
+  engine_context->Run(std::move(configuration));
+
   // Set metrics, which notifies the Dart isolate to render the views.
   engine_context->EngineTaskSync([](Engine& engine) {
     engine.AddView(kFlutterImplicitViewId, ViewportMetrics{1.0, 10, 10, 1, 0});

shell/common/fixtures/shell_test.dart

@@ -533,43 +533,29 @@ void testReportViewWidths() {
 }
 
 @pragma('vm:entry-point')
-void renderWarmUpImplicitViewAfterMetricsChanged() {
-  PlatformDispatcher.instance.onBeginFrame = (Duration beginTime) {
-    // Make sure onBeginFrame and onDrawFrame are not used later.
-    PlatformDispatcher.instance.onBeginFrame = null;
-    PlatformDispatcher.instance.onDrawFrame = null;
-    // Let the test know that a continuation is available.
-    notifyNative();
-  };
-
+void renderWarmUpImplicitView() {
   bool beginFrameDone = false;
 
-  // As soon as 2 views are added, render these views.
-  PlatformDispatcher.instance.onMetricsChanged = () {
-    PlatformDispatcher.instance.scheduleWarmUpFrame(
-      beginFrame: () {
-        expect(beginFrameDone, false);
-        beginFrameDone = true;
-      },
-      drawFrame: () {
-        expect(beginFrameDone, true);
-
-        final SceneBuilder builder = SceneBuilder();
-        final PictureRecorder recorder = PictureRecorder();
-        final Canvas canvas = Canvas(recorder);
-        canvas.drawPaint(Paint()..color = const Color(0xFFABCDEF));
-        final Picture picture = recorder.endRecording();
-        builder.addPicture(Offset.zero, picture);
-
-        final Scene scene = builder.build();
-        PlatformDispatcher.instance.implicitView!.render(scene);
-
-        scene.dispose();
-        picture.dispose();
-      },
-    );
-  };
+  PlatformDispatcher.instance.scheduleWarmUpFrame(
+    beginFrame: () {
+      expect(beginFrameDone, false);
+      beginFrameDone = true;
+    },
+    drawFrame: () {
+      expect(beginFrameDone, true);
 
-  // Schedule a frame to produce an Animator continuation.
-  PlatformDispatcher.instance.scheduleFrame();
+      final SceneBuilder builder = SceneBuilder();
+      final PictureRecorder recorder = PictureRecorder();
+      final Canvas canvas = Canvas(recorder);
+      canvas.drawPaint(Paint()..color = const Color(0xFFABCDEF));
+      final Picture picture = recorder.endRecording();
+      builder.addPicture(Offset.zero, picture);
+
+      final Scene scene = builder.build();
+      PlatformDispatcher.instance.implicitView!.render(scene);
+
+      scene.dispose();
+      picture.dispose();
+    },
+  );
 }

testing/dart/platform_dispatcher_test.dart

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'dart:async';
 import 'dart:ui';
 
 import 'package:litetest/litetest.dart';
@@ -46,4 +47,31 @@ void main() {
     expect(constraints.isSatisfiedBy(const Size(400, 500)), false);
     expect(constraints / 2, const ViewConstraints(minWidth: 50, maxWidth: 100, minHeight: 150, maxHeight: 200));
   });
+
+  test('scheduleWarmupFrame should call both callbacks and flush microtasks', () async {
+    bool microtaskFlushed = false;
+    bool beginFrameCalled = false;
+    final Completer<void> drawFrameCalled = Completer<void>();
+    PlatformDispatcher.instance.scheduleWarmUpFrame(beginFrame: () {
+      expect(microtaskFlushed, false);
+      expect(drawFrameCalled.isCompleted, false);
+      expect(beginFrameCalled, false);
+      beginFrameCalled = true;
+      scheduleMicrotask(() {
+        expect(microtaskFlushed, false);
+        expect(drawFrameCalled.isCompleted, false);
+        microtaskFlushed = true;
+      });
+      expect(microtaskFlushed, false);
+    }, drawFrame: () {
+      expect(beginFrameCalled, true);
+      expect(microtaskFlushed, true);
+      expect(drawFrameCalled.isCompleted, false);
+      drawFrameCalled.complete();
+    });
+    await drawFrameCalled.future;
+    expect(beginFrameCalled, true);
+    expect(drawFrameCalled.isCompleted, true);
+    expect(microtaskFlushed, true);
+  });
 }