[framework] simplify raster widget, rename, combine painters (#109485)

packages/flutter/lib/src/cupertino/route.dart

@@ -342,7 +342,7 @@ class CupertinoPageRoute<T> extends PageRoute<T> with CupertinoRouteTransitionMi
     super.settings,
     this.maintainState = true,
     super.fullscreenDialog,
-    super.preferRasterization = true,
+    super.allowSnapshotting = true,
   }) : assert(builder != null),
        assert(maintainState != null),
        assert(fullscreenDialog != null) {
@@ -372,7 +372,7 @@ class CupertinoPageRoute<T> extends PageRoute<T> with CupertinoRouteTransitionMi
 class _PageBasedCupertinoPageRoute<T> extends PageRoute<T> with CupertinoRouteTransitionMixin<T> {
   _PageBasedCupertinoPageRoute({
     required CupertinoPage<T> page,
-    super.preferRasterization = true,
+    super.allowSnapshotting = true,
   }) : assert(page != null),
        super(settings: page) {
     assert(opaque);
@@ -419,7 +419,7 @@ class CupertinoPage<T> extends Page<T> {
     this.maintainState = true,
     this.title,
     this.fullscreenDialog = false,
-    this.preferRasterization = true,
+    this.allowSnapshotting = true,
     super.key,
     super.name,
     super.arguments,
@@ -440,12 +440,12 @@ class CupertinoPage<T> extends Page<T> {
   /// {@macro flutter.widgets.PageRoute.fullscreenDialog}
   final bool fullscreenDialog;
 
-  /// {@macro flutter.widgets.TransitionRoute.preferRasterization}
-  final bool preferRasterization;
+  /// {@macro flutter.widgets.TransitionRoute.allowSnapshotting}
+  final bool allowSnapshotting;
 
   @override
   Route<T> createRoute(BuildContext context) {
-    return _PageBasedCupertinoPageRoute<T>(page: this, preferRasterization: preferRasterization);
+    return _PageBasedCupertinoPageRoute<T>(page: this, allowSnapshotting: allowSnapshotting);
   }
 }
 

packages/flutter/lib/src/material/page.dart

@@ -39,7 +39,7 @@ class MaterialPageRoute<T> extends PageRoute<T> with MaterialRouteTransitionMixi
     super.settings,
     this.maintainState = true,
     super.fullscreenDialog,
-    super.preferRasterization = true,
+    super.allowSnapshotting = true,
   }) : assert(builder != null),
        assert(maintainState != null),
        assert(fullscreenDialog != null) {
@@ -158,7 +158,7 @@ class MaterialPage<T> extends Page<T> {
     required this.child,
     this.maintainState = true,
     this.fullscreenDialog = false,
-    this.preferRasterization = true,
+    this.allowSnapshotting = true,
     super.key,
     super.name,
     super.arguments,
@@ -176,12 +176,12 @@ class MaterialPage<T> extends Page<T> {
   /// {@macro flutter.widgets.PageRoute.fullscreenDialog}
   final bool fullscreenDialog;
 
-  /// {@macro flutter.widgets.TransitionRoute.preferRasterization}
-  final bool preferRasterization;
+  /// {@macro flutter.widgets.TransitionRoute.allowSnapshotting}
+  final bool allowSnapshotting;
 
   @override
   Route<T> createRoute(BuildContext context) {
-    return _PageBasedMaterialPageRoute<T>(page: this, preferRasterization: preferRasterization);
+    return _PageBasedMaterialPageRoute<T>(page: this, allowSnapshotting: allowSnapshotting);
   }
 }
 
@@ -192,7 +192,7 @@ class MaterialPage<T> extends Page<T> {
 class _PageBasedMaterialPageRoute<T> extends PageRoute<T> with MaterialRouteTransitionMixin<T> {
   _PageBasedMaterialPageRoute({
     required MaterialPage<T> page,
-    super.preferRasterization,
+    super.allowSnapshotting,
   }) : assert(page != null),
        super(settings: page) {
     assert(opaque);

packages/flutter/lib/src/material/page_transitions_theme.dart

@@ -156,7 +156,7 @@ class _ZoomPageTransition extends StatelessWidget {
   const _ZoomPageTransition({
     required this.animation,
     required this.secondaryAnimation,
-    required this.preferRasterization,
+    required this.allowSnapshotting,
     this.child,
   }) : assert(animation != null),
        assert(secondaryAnimation != null);
@@ -194,13 +194,12 @@ class _ZoomPageTransition extends StatelessWidget {
   ///    property when the [_ZoomPageTransition] is used as a page transition.
   final Animation<double> secondaryAnimation;
 
-  /// Whether the [RasterWidget] based-rasterized strategy for the zoom page transition
-  /// will be used.
+  /// Whether the [SnapshotWidget] will be used.
   ///
   /// Notably, this improves performance by disabling animations on both the outgoing and
   /// incoming route. This also implies that ink-splashes or similar animations will
   /// not animate during the transition.
-  final bool preferRasterization;
+  final bool allowSnapshotting;
 
   /// The widget below this widget in the tree.
   ///
@@ -219,7 +218,7 @@ class _ZoomPageTransition extends StatelessWidget {
       ) {
         return _ZoomEnterTransition(
           animation: animation,
-          preferRasterization: preferRasterization,
+          allowSnapshotting: allowSnapshotting,
           child: child,
         );
       },
@@ -230,7 +229,7 @@ class _ZoomPageTransition extends StatelessWidget {
       ) {
         return _ZoomExitTransition(
           animation: animation,
-          preferRasterization: preferRasterization,
+          allowSnapshotting: allowSnapshotting,
           reverse: true,
           child: child,
         );
@@ -244,7 +243,7 @@ class _ZoomPageTransition extends StatelessWidget {
         ) {
           return _ZoomEnterTransition(
             animation: animation,
-            preferRasterization: preferRasterization,
+            allowSnapshotting: allowSnapshotting,
             reverse: true,
             child: child,
           );
@@ -256,7 +255,7 @@ class _ZoomPageTransition extends StatelessWidget {
         ) {
           return _ZoomExitTransition(
             animation: animation,
-            preferRasterization: preferRasterization,
+            allowSnapshotting: allowSnapshotting,
             child: child,
           );
         },
@@ -270,14 +269,14 @@ class _ZoomEnterTransition extends StatefulWidget {
   const _ZoomEnterTransition({
     required this.animation,
     this.reverse = false,
-    required this.preferRasterization,
+    required this.allowSnapshotting,
     this.child,
   }) : assert(animation != null),
        assert(reverse != null);
 
   final Animation<double> animation;
   final Widget? child;
-  final bool preferRasterization;
+  final bool allowSnapshotting;
   final bool reverse;
 
   @override
@@ -285,10 +284,13 @@ class _ZoomEnterTransition extends StatefulWidget {
 }
 
 class _ZoomEnterTransitionState extends State<_ZoomEnterTransition> with _ZoomTransitionBase {
-  // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
-  bool get allowRasterization => !kIsWeb && widget.preferRasterization;
+  // See SnapshotWidget doc comment, this is disabled on web because the HTML backend doesn't
+  // support this functionality and the canvaskit backend uses a single thread for UI and raster
+  // work which diminishes the impact of this performance improvement.
+  @override
+  bool get useSnapshot => !kIsWeb && widget.allowSnapshotting;
 
-  late _ZoomEnterTransitionDelegate delegate;
+  late _ZoomEnterTransitionPainter delegate;
 
   static final Animatable<double> _fadeInTransition = Tween<double>(
     begin: 0.0,
@@ -327,7 +329,7 @@ class _ZoomEnterTransitionState extends State<_ZoomEnterTransition> with _ZoomTr
   @override
   void initState() {
     _updateAnimations();
-    delegate = _ZoomEnterTransitionDelegate(
+    delegate = _ZoomEnterTransitionPainter(
       reverse: widget.reverse,
       fade: fadeTransition,
       scale: scaleTransition,
@@ -343,7 +345,7 @@ class _ZoomEnterTransitionState extends State<_ZoomEnterTransition> with _ZoomTr
       oldWidget.animation.removeStatusListener(onAnimationStatusChange);
       _updateAnimations();
       delegate.dispose();
-      delegate = _ZoomEnterTransitionDelegate(
+      delegate = _ZoomEnterTransitionPainter(
         reverse: widget.reverse,
         fade: fadeTransition,
         scale: scaleTransition,
@@ -363,11 +365,10 @@ class _ZoomEnterTransitionState extends State<_ZoomEnterTransition> with _ZoomTr
 
   @override
   Widget build(BuildContext context) {
-    return RasterWidget(
-      delegate: delegate,
+    return SnapshotWidget(
+      painter: delegate,
       controller: controller,
-      fallback: delegate,
-      mode: allowRasterization ? RasterizeMode.enabled : RasterizeMode.fallback,
+      mode: SnapshotMode.permissive,
       child: widget.child,
     );
   }
@@ -377,13 +378,13 @@ class _ZoomExitTransition extends StatefulWidget {
   const _ZoomExitTransition({
     required this.animation,
     this.reverse = false,
-    required this.preferRasterization,
+    required this.allowSnapshotting,
     this.child,
   }) : assert(animation != null),
        assert(reverse != null);
 
   final Animation<double> animation;
-  final bool preferRasterization;
+  final bool allowSnapshotting;
   final bool reverse;
   final Widget? child;
 
@@ -392,10 +393,13 @@ class _ZoomExitTransition extends StatefulWidget {
 }
 
 class _ZoomExitTransitionState extends State<_ZoomExitTransition> with _ZoomTransitionBase {
-  late _ZoomExitTransitionDelegate delegate;
+  late _ZoomExitTransitionPainter delegate;
 
-  // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
-  bool get allowRasterization => !kIsWeb && widget.preferRasterization;
+  // See SnapshotWidget doc comment, this is disabled on web because the HTML backend doesn't
+  // support this functionality and the canvaskit backend uses a single thread for UI and raster
+  // work which diminishes the impact of this performance improvement.
+  @override
+  bool get useSnapshot => !kIsWeb && widget.allowSnapshotting;
 
   static final Animatable<double> _fadeOutTransition = Tween<double>(
     begin: 1.0,
@@ -428,10 +432,11 @@ class _ZoomExitTransitionState extends State<_ZoomExitTransition> with _ZoomTran
   @override
   void initState() {
     _updateAnimations();
-    delegate = _ZoomExitTransitionDelegate(
+    delegate = _ZoomExitTransitionPainter(
       reverse: widget.reverse,
       fade: fadeTransition,
       scale: scaleTransition,
+      animation: widget.animation,
     );
     super.initState();
   }
@@ -443,10 +448,11 @@ class _ZoomExitTransitionState extends State<_ZoomExitTransition> with _ZoomTran
       oldWidget.animation.removeStatusListener(onAnimationStatusChange);
       _updateAnimations();
       delegate.dispose();
-      delegate = _ZoomExitTransitionDelegate(
+      delegate = _ZoomExitTransitionPainter(
         reverse: widget.reverse,
         fade: fadeTransition,
         scale: scaleTransition,
+        animation: widget.animation,
       );
     }
     super.didUpdateWidget(oldWidget);
@@ -462,11 +468,10 @@ class _ZoomExitTransitionState extends State<_ZoomExitTransition> with _ZoomTran
 
   @override
   Widget build(BuildContext context) {
-    return RasterWidget(
-      delegate: delegate,
+    return SnapshotWidget(
+      painter: delegate,
       controller: controller,
-      fallback: delegate,
-      mode: allowRasterization ? RasterizeMode.enabled : RasterizeMode.fallback,
+      mode: SnapshotMode.permissive,
       child: widget.child,
     );
   }
@@ -602,7 +607,7 @@ class ZoomPageTransitionsBuilder extends PageTransitionsBuilder {
     return _ZoomPageTransition(
       animation: animation,
       secondaryAnimation: secondaryAnimation,
-      preferRasterization: route?.preferRasterization ?? true,
+      allowSnapshotting: route?.allowSnapshotting ?? true,
       child: child,
     );
   }
@@ -765,12 +770,14 @@ void _updateScaledTransform(Matrix4 transform, double scale, Size size) {
 }
 
 mixin _ZoomTransitionBase {
+  bool get useSnapshot;
+
   // Don't rasterize if:
   // 1. Rasterization is disabled by the platform.
   // 2. The animation is paused/stopped.
   // 3. The values of the scale/fade transition do not
   //    benefit from rasterization.
-  final RasterWidgetController controller = RasterWidgetController();
+  final SnapshotController controller = SnapshotController();
 
   late Animation<double> fadeTransition;
   late Animation<double> scaleTransition;
@@ -779,9 +786,9 @@ mixin _ZoomTransitionBase {
     if ((scaleTransition.value == 1.0) &&
         (fadeTransition.value == 0.0 ||
          fadeTransition.value == 1.0)) {
-        controller.rasterize = false;
+        controller.allowSnapshotting = false;
       } else {
-        controller.rasterize = true;
+        controller.allowSnapshotting = useSnapshot;
       }
   }
 
@@ -789,28 +796,33 @@ mixin _ZoomTransitionBase {
     switch (status) {
       case AnimationStatus.dismissed:
       case AnimationStatus.completed:
-        controller.rasterize = false;
+        controller.allowSnapshotting = false;
         break;
       case AnimationStatus.forward:
       case AnimationStatus.reverse:
-        controller.rasterize = true;
+        controller.allowSnapshotting = useSnapshot;
         break;
     }
   }
 }
 
-class _ZoomEnterTransitionDelegate extends RasterWidgetDelegate implements RasterWidgetFallbackDelegate {
-  _ZoomEnterTransitionDelegate({
+class _ZoomEnterTransitionPainter extends SnapshotPainter {
+  _ZoomEnterTransitionPainter({
     required this.reverse,
     required this.scale,
     required this.fade,
     required this.animation,
   }) {
     animation.addListener(notifyListeners);
+    animation.addStatusListener(_onStatusChange);
     scale.addListener(notifyListeners);
     fade.addListener(notifyListeners);
   }
 
+  void _onStatusChange(_) {
+    notifyListeners();
+  }
+
   final bool reverse;
   final Animation<double> animation;
   final Animation<double> scale;
@@ -845,7 +857,15 @@ class _ZoomEnterTransitionDelegate extends RasterWidgetDelegate implements Raste
   }
 
   @override
-  void paintFallback(PaintingContext context, ui.Offset offset, Size size, PaintingContextCallback painter) {
+  void paint(PaintingContext context, ui.Offset offset, Size size, PaintingContextCallback painter) {
+    switch (animation.status) {
+      case AnimationStatus.completed:
+      case AnimationStatus.dismissed:
+        return painter(context, offset);
+      case AnimationStatus.forward:
+      case AnimationStatus.reverse:
+    }
+
     _drawScrim(context, offset, size);
     _updateScaledTransform(_transform, scale.value, size);
     _transformHandler.layer = context.pushTransform(true, offset, _transform, (PaintingContext context, Offset offset) {
@@ -854,7 +874,7 @@ class _ZoomEnterTransitionDelegate extends RasterWidgetDelegate implements Raste
   }
 
   @override
-  void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
+  void paintSnapshot(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
     _drawScrim(context, offset, size);
     _drawImageScaledAndCentered(context, image, scale.value, fade.value, pixelRatio);
   }
@@ -862,6 +882,7 @@ class _ZoomEnterTransitionDelegate extends RasterWidgetDelegate implements Raste
   @override
   void dispose() {
     animation.removeListener(notifyListeners);
+    animation.removeStatusListener(_onStatusChange);
     scale.removeListener(notifyListeners);
     fade.removeListener(notifyListeners);
     _opacityHandle.layer = null;
@@ -870,7 +891,7 @@ class _ZoomEnterTransitionDelegate extends RasterWidgetDelegate implements Raste
   }
 
   @override
-  bool shouldRepaint(covariant _ZoomEnterTransitionDelegate oldDelegate) {
+  bool shouldRepaint(covariant _ZoomEnterTransitionPainter oldDelegate) {
     return oldDelegate.reverse != reverse
       || oldDelegate.animation.value != animation.value
       || oldDelegate.scale.value != scale.value
@@ -878,30 +899,46 @@ class _ZoomEnterTransitionDelegate extends RasterWidgetDelegate implements Raste
   }
 }
 
-class _ZoomExitTransitionDelegate extends RasterWidgetDelegate implements RasterWidgetFallbackDelegate {
-  _ZoomExitTransitionDelegate({
+class _ZoomExitTransitionPainter extends SnapshotPainter {
+  _ZoomExitTransitionPainter({
     required this.reverse,
     required this.scale,
     required this.fade,
+    required this.animation,
   }) {
     scale.addListener(notifyListeners);
     fade.addListener(notifyListeners);
+    animation.addStatusListener(_onStatusChange);
+  }
+
+  void _onStatusChange(_) {
+    notifyListeners();
   }
 
   final bool reverse;
   final Animation<double> scale;
   final Animation<double> fade;
+  final Animation<double> animation;
   final Matrix4 _transform = Matrix4.zero();
   final LayerHandle<OpacityLayer> _opacityHandle = LayerHandle<OpacityLayer>();
   final LayerHandle<TransformLayer> _transformHandler = LayerHandle<TransformLayer>();
 
   @override
-  void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
+  void paintSnapshot(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
     _drawImageScaledAndCentered(context, image, scale.value, fade.value, pixelRatio);
   }
 
   @override
-  void paintFallback(PaintingContext context, ui.Offset offset, Size size, PaintingContextCallback painter) {
+  void paint(PaintingContext context, ui.Offset offset, Size size, PaintingContextCallback painter) {
+    switch (animation.status) {
+      case AnimationStatus.completed:
+      case AnimationStatus.dismissed:
+        return painter(context, offset);
+      case AnimationStatus.forward:
+      case AnimationStatus.reverse:
+        break;
+    }
+
     _updateScaledTransform(_transform, scale.value, size);
     _transformHandler.layer = context.pushTransform(true, offset, _transform, (PaintingContext context, Offset offset) {
       _opacityHandle.layer = context.pushOpacity(offset, (fade.value * 255).round(), painter, oldLayer: _opacityHandle.layer);
@@ -909,7 +946,7 @@ class _ZoomExitTransitionDelegate extends RasterWidgetDelegate implements Raster
   }
 
   @override
-  bool shouldRepaint(covariant _ZoomExitTransitionDelegate oldDelegate) {
+  bool shouldRepaint(covariant _ZoomExitTransitionPainter oldDelegate) {
     return oldDelegate.reverse != reverse || oldDelegate.fade.value != fade.value || oldDelegate.scale.value != scale.value;
   }
 
@@ -919,6 +956,7 @@ class _ZoomExitTransitionDelegate extends RasterWidgetDelegate implements Raster
     _transformHandler.layer = null;
     scale.removeListener(notifyListeners);
     fade.removeListener(notifyListeners);
+    animation.removeStatusListener(_onStatusChange);
     super.dispose();
   }
 }

packages/flutter/lib/src/widgets/pages.dart

@@ -19,7 +19,7 @@ abstract class PageRoute<T> extends ModalRoute<T> {
   PageRoute({
     super.settings,
     this.fullscreenDialog = false,
-    this.preferRasterization = true,
+    this.allowSnapshotting = true,
   });
 
   /// {@template flutter.widgets.PageRoute.fullscreenDialog}
@@ -33,7 +33,7 @@ abstract class PageRoute<T> extends ModalRoute<T> {
   final bool fullscreenDialog;
 
   @override
-  final bool preferRasterization;
+  final bool allowSnapshotting;
 
   @override
   bool get opaque => true;
@@ -80,7 +80,7 @@ class PageRouteBuilder<T> extends PageRoute<T> {
     this.barrierLabel,
     this.maintainState = true,
     super.fullscreenDialog,
-    super.preferRasterization = true,
+    super.allowSnapshotting = true,
   }) : assert(pageBuilder != null),
        assert(transitionsBuilder != null),
        assert(opaque != null),

packages/flutter/lib/src/widgets/routes.dart

@@ -134,20 +134,20 @@ abstract class TransitionRoute<T> extends OverlayRoute<T> {
   /// {@endtemplate}
   bool get opaque;
 
-  /// {@template flutter.widgets.TransitionRoute.preferRasterization}
-  /// Whether the route transition will prefer to animate a rasterized
-  /// snapshot of the entering/exiting routes.
+  /// {@template flutter.widgets.TransitionRoute.allowSnapshotting}
+  /// Whether the route transition will prefer to animate a snapshot of the
+  /// entering/exiting routes.
   ///
   /// When this value is true, certain route transitions (such as the Android
-  /// zoom page transition) will rasterize the entering and exiting routes.
-  /// These textures are then animated in place of the underlying widgets to
+  /// zoom page transition) will snapshot the entering and exiting routes.
+  /// These snapshots are then animated in place of the underlying widgets to
   /// improve performance of the transition.
   ///
   /// Generally this means that animations that occur on the entering/exiting
   /// route while the route animation plays may appear frozen - unless they
   /// are a hero animation or something that is drawn in a separate overlay.
   /// {@endtemplate}
-  bool get preferRasterization => true;
+  bool get allowSnapshotting => true;
 
   // This ensures that if we got to the dismissed state while still current,
   // we will still be disposed when we are eventually popped.
@@ -1749,7 +1749,7 @@ abstract class PopupRoute<T> extends ModalRoute<T> {
   bool get maintainState => true;
 
   @override
-  bool get preferRasterization => false;
+  bool get allowSnapshotting => false;
 }
 
 /// A [Navigator] observer that notifies [RouteAware]s of changes to the

packages/flutter/lib/src/widgets/raster_widget.dart → packages/flutter/lib/src/widgets/snapshot_widget.dart

@@ -7,264 +7,162 @@ import 'dart:ui' as ui;
 import 'package:flutter/rendering.dart';
 
 import 'basic.dart';
+import 'debug.dart';
 import 'framework.dart';
 import 'media_query.dart';
 
-/// Controls how the [RasterWidget] paints its children via the [RasterWidgetController].
-enum RasterizeMode {
-  /// the children are rasterized, but only if all descendants can be rasterized.
+/// Controls how the [SnapshotWidget] paints its child.
+enum SnapshotMode {
+  /// The child is snapshotted, but only if all descendants can be snapshotted.
   ///
-  /// This setting is the default state of the [RasterWidgetController].
-  ///
-  /// If there is a platform view in the children of a raster widget
-  /// and a [RasterWidgetFallbackDelegate]h as been provided to the raster_widget,
-  /// this fallback delegate will be used to render the children instead of the image.
-  /// If there is no fallback delegate, an excpetion will be thrown
-  enabled,
+  /// If there is a platform view in the children of a snapshot widget, the
+  /// snapshot will not be used and the child will be rendered using
+  /// [SnapshotPainter.paint]. This uses an un-snapshotted child and by default
+  /// paints it with no additional modification.
+  permissive,
 
-  /// The children are rasterized and any child platform views are ignored.
+  /// An error is thrown if the child cannot be snapshotted.
   ///
-  /// In this state a [RasterWidgetFallbackDelegate] is never used. Generally this
-  /// can be useful if there is a platform view descendant that does not need to
-  /// be included in the raster.
-  forced,
+  /// This setting is the default state of the [SnapshotWidget].
+  normal,
 
-  /// the children are not rasterized and the [RasterWidgetFallbackDelegate],
-  /// if provided, is used to draw the children.
+  /// The child is snapshotted and any child platform views are ignored.
   ///
-  ///
-  fallback,
+  /// This mode can be useful if there is a platform view descendant that does
+  /// not need to be included in the snapshot.
+  forced,
 }
 
-/// A controller for the [RasterWidget] that controls when the child image is displayed
+/// A controller for the [SnapshotWidget] that controls when the child image is displayed
 /// and when to regenerated the child image.
 ///
-/// When the value of [rasterize] is true, the [RasterWidget] will paint the child
-/// widgets based on the [RasterizeMode] of the raster widget.
+/// When the value of [allowSnapshotting] is true, the [SnapshotWidget] will paint the child
+/// widgets based on the [SnapshotMode] of the snapshot widget.
 ///
-/// To force [RasterWidget] to recreate the child image, call [clear].
-class RasterWidgetController extends ChangeNotifier {
-  /// Create a new [RasterWidgetController].
+/// The controller notifies its listeners when the value of [allowSnapshotting] changes
+/// or when [clear] is called.
+///
+/// To force [SnapshotWidget] to recreate the child image, call [clear].
+class SnapshotController extends ChangeNotifier {
+  /// Create a new [SnapshotController].
   ///
-  /// By default, [rasterize] is `false` and cannot be `null`.
-  RasterWidgetController({
-    bool rasterize = false,
-  }) : _rasterize = rasterize;
+  /// By default, [allowSnapshotting] is `false` and cannot be `null`.
+  SnapshotController({
+    bool allowSnapshotting = false,
+  }) : _allowSnapshotting = allowSnapshotting;
 
-  /// Reset the raster held by any listening [RasterWidget].
+  /// Reset the snapshot held by any listening [SnapshotWidget].
   ///
-  /// This has no effect if [rasterize] is `false`.
+  /// This has no effect if [allowSnapshotting] is `false`.
   void clear() {
     notifyListeners();
   }
 
-  /// Whether a rasterized version of this render objects child is drawn in
-  /// place of the child.
-  bool get rasterize => _rasterize;
-  bool _rasterize;
-  set rasterize(bool value) {
-    if (value == rasterize) {
+  /// Whether a snapshot of this child widget is painted in its place.
+  bool get allowSnapshotting => _allowSnapshotting;
+  bool _allowSnapshotting;
+  set allowSnapshotting(bool value) {
+    if (value == allowSnapshotting) {
       return;
     }
-    _rasterize = value;
+    _allowSnapshotting = value;
     notifyListeners();
   }
 }
 
-/// A widget that replaces its child with a rasterized version of the child.
+/// A widget that can replace its child with a snapshoted version of the child.
+///
+/// A snapshot is a frozen texture-backed representation of all child pictures
+/// and layers stored as a [ui.Image].
+///
+/// This widget is useful for performing short animations that would otherwise
+/// be expensive or that cannot rely on raster caching. For example, scale and
+/// skew animations are often expensive to perform on complex children, as are
+/// blurs. For a short animation, a widget that contains these expensive effects
+/// can be replaced with a snapshot of itself and manipulated instead.
 ///
-/// By default, the child is drawn as is. The default [delegate] simply scales
-/// down the image by the current device pixel ratio and paints it into the
-/// canvas. How this image is drawn can be customized by providing a new
-/// subclass of [RasterWidgetDelegate] to the [delegate] argument.
+/// For example, the Android Q [ZoomPageTransitionsBuilder] uses a snapshot widget
+/// for the forward and entering route to avoid the expensive scale animation.
+/// This also has the effect of briefly pausing any animations on the page.
+///
+/// Generally, this widget should not be used in places where users expect the
+/// child widget to continue animating or to be responsive, such as an unbounded
+/// animation.
 ///
 /// Caveats:
 ///
-/// The contents of platform views cannot be captured by a raster
-/// widget. If a platform view is encountered, then the raster widget will
-/// determine how to render its children based on the [RasterizeMode]. This
-/// defaults to [RasterizeMode.enabled] which will throw an exception if a platform
-/// view is encountered.
+/// * The contents of platform views cannot be captured by a snapshot
+///   widget. If a platform view is encountered, then the snapshot widget will
+///   determine how to render its children based on the [SnapshotMode]. This
+///   defaults to [SnapshotMode.normal] which will throw an exception if a
+///   platform view is encountered.
 ///
-/// This widget is not supported on the HTML backend of Flutter for the web.
-class RasterWidget extends SingleChildRenderObjectWidget {
-  /// Create a new [RasterWidget].
+/// * The snapshotting functionality of this widget is not supported on the HTML
+///   backend of Flutter for the Web. Setting [SnapshotController.allowSnapshotting] to true
+///   may cause an error to be thrown. On the CanvasKit backend of Flutter, the
+///   performance of using this widget may regress performance due to the fact
+///   that both the UI and engine share a single thread.
+class SnapshotWidget extends SingleChildRenderObjectWidget {
+  /// Create a new [SnapshotWidget].
   ///
   /// The [controller] and [child] arguments are required.
-  const RasterWidget({
+  const SnapshotWidget({
     super.key,
-    this.delegate = const _RasterDefaultDelegate(),
-    this.fallback,
-    this.mode = RasterizeMode.enabled,
+    this.mode = SnapshotMode.normal,
+    this.painter = const _DefaultSnapshotPainter(),
     required this.controller,
     required super.child
   });
 
-  /// A delegate that allows customization of how the image is painted.
-  ///
-  /// If not provided, defaults to a delegate which paints the child as is.
-  final RasterWidgetDelegate delegate;
-
-  /// The controller that determines when to display the children as an image.
-  final RasterWidgetController controller;
+  /// The controller that determines when to display the children as a snapshot.
+  final SnapshotController controller;
 
-  /// A fallback delegate which is used if the child layers contains a platform view.
-  final RasterWidgetFallbackDelegate? fallback;
-
-  /// Configuration that controls how the raster widget decides to draw its children.
+  /// Configuration that controls how the snapshot widget decides to paint its children.
   ///
-  /// Defaults to [RasterizeMode.enabled], which throws an error when a platform view
-  /// or other un-rasterizable view is encountered.
+  /// Defaults to [SnapshotMode.normal], which throws an error when a platform view
+  /// or texture view is encountered.
   ///
-  /// See [RasterizeMode] for more information.
-  final RasterizeMode mode;
+  /// See [SnapshotMode] for more information.
+  final SnapshotMode mode;
+
+  /// The painter used to paint the child snapshot or child widgets.
+  final SnapshotPainter painter;
 
   @override
   RenderObject createRenderObject(BuildContext context) {
-    return RenderRasterWidget(
-      delegate: delegate,
+    debugCheckHasMediaQuery(context);
+    return _RenderSnapshotWidget(
       controller: controller,
-      fallback: fallback,
       mode: mode,
-      devicePixelRatio: MediaQuery.maybeOf(context)?.devicePixelRatio ?? 1.0,
+      devicePixelRatio: MediaQuery.of(context).devicePixelRatio,
+      painter: painter,
     );
   }
 
   @override
-  void updateRenderObject(BuildContext context, covariant RenderRasterWidget renderObject) {
-    renderObject
-      ..delegate = delegate
+  void updateRenderObject(BuildContext context, covariant RenderObject renderObject) {
+    debugCheckHasMediaQuery(context);
+    (renderObject as _RenderSnapshotWidget)
       ..controller = controller
-      ..fallback = fallback
       ..mode = mode
-      ..devicePixelRatio = MediaQuery.maybeOf(context)?.devicePixelRatio ?? 1.0;
+      ..devicePixelRatio = MediaQuery.of(context).devicePixelRatio
+      ..painter = painter;
   }
 }
 
-/// A delegate which the [RasterWidget] can use to fallback to regular rendering
-/// if a platform view is present in the layer tree.
-///
-/// Consumers of [RasterWidget] should almost never use this delegate. For the most part,
-/// the raster widget only functions as a performance improvement. If a platform view is
-/// present, the performance improving qualities aren't possible and using this API is
-/// pointless.
-///
-/// Instead, this interface is useful if a generic/reusable widget is being created which
-/// may include a platform view and it needs to handle this transparently. For example, the
-/// framework uses this for the zoom page transition so that navigating to a page shows the same
-/// animation whether or not there is a platform view.
-abstract class RasterWidgetFallbackDelegate {
-  /// const constructor so that subclasses can be const.
-  const RasterWidgetFallbackDelegate();
-
-  /// Paint the child via [painter], applying any effects that would have been painted
-  /// with the [RasterWidgetDelegate].
-  ///
-  /// The [offset] and [size] are the location and dimensions of the render object.
-  void paintFallback(PaintingContext context, Offset offset, Size size, PaintingContextCallback painter);
-}
-
-/// A delegate used to draw the image representing the rasterized child.
-///
-/// The delegate can call [notifyListeners] to have the raster widget
-/// re-paint (re-using the same raster). This allows animations to be connected
-/// to the raster and performed without re-rasterization of children. For
-/// certain scale or perspective changing transforms, such as a rotation, this
-/// can be significantly faster than performing the same animation at the
-/// widget level.
-///
-/// By default, the [RasterWidget] includes a delegate that draws the child raster
-/// exactly as the child widgets would have been drawn. Nevertheless, this can
-/// also be used to efficiently transform the child raster and apply complex paint
-/// effects.
-///
-/// {@tool snippet}
-///
-/// The following method shows how to efficiently rotate the child raster.
-///
-/// ```dart
-/// void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
-///   const double radians = 0.5; // Could be driven by an animation.
-///   final Matrix4 transform = Matrix4.rotationZ(radians);
-///   context.canvas.transform(transform.storage);
-///   final Rect src = Rect.fromLTWH(0, 0, image.width.toDouble(), image.height.toDouble());
-///   final Rect dst = Rect.fromLTWH(offset.dx, offset.dy, size.width, size.height);
-///   final Paint paint = Paint()
-///     ..filterQuality = FilterQuality.low;
-///   context.canvas.drawImageRect(image, src, dst, paint);
-/// }
-/// ```
-/// {@end-tool}
-abstract class RasterWidgetDelegate extends ChangeNotifier {
-  /// Called whenever the [image] that represents a [RasterWidget]s child should be painted.
-  ///
-  /// The image is rasterized at the physical pixel resolution and should be scaled down by
-  /// [pixelRatio] to account for device independent pixels.
-  ///
-  /// There is no offset given in this paint method, as the parent is an [OffsetLayer] all
-  /// offsets are [Offset.zero].
-  ///
-  /// {@tool snippet}
-  ///
-  /// The follow method shows how the default implementation of the delegate used by the
-  /// [RasterWidget] paints the child image. This must account for the fact that the image
-  /// width and height will be given in physical pixels, while the image must be painted with
-  /// device independent pixels. That is, the width and height of the image is the widget and
-  /// height of the provided `size`, multiplied by the `pixelRatio`:
-  ///
-  /// ```dart
-  /// void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
-  ///   final Rect src = Rect.fromLTWH(0, 0, image.width.toDouble(), image.height.toDouble());
-  ///   final Rect dst = Rect.fromLTWH(offset.dx, offset.dy, size.width, size.height);
-  ///   final Paint paint = Paint()
-  ///     ..filterQuality = FilterQuality.low;
-  ///   context.canvas.drawImageRect(image, src, dst, paint);
-  /// }
-  /// ```
-  /// {@end-tool}
-  void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio);
-
-  /// Called whenever a new instance of the raster widget delegate class is
-  /// provided to the [RenderRasterWidget] object, or any time that a new
-  /// [RasterWidgetDelegate] object is created with a new instance of the
-  /// delegate class (which amounts to the same thing, because the latter is
-  /// implemented in terms of the former).
-  ///
-  /// If the new instance represents different information than the old
-  /// instance, then the method should return true, otherwise it should return
-  /// false.
-  ///
-  /// If the method returns false, then the [paint] call might be optimized
-  /// away.
-  ///
-  /// It's possible that the [paint] method will get called even if
-  /// [shouldRepaint] returns false (e.g. if an ancestor or descendant needed to
-  /// be repainted). It's also possible that the [paint] method will get called
-  /// without [shouldRepaint] being called at all (e.g. if the box changes
-  /// size).
-  ///
-  /// Changing the delegate will not cause the child image retained by the
-  /// [RenderRasterWidget] to be updated. Instead, [RasterWidgetController.clear] can
-  /// be used to force the generation of a new image.
-  ///
-  /// The `oldDelegate` argument will never be null.
-  bool shouldRepaint(covariant RasterWidgetDelegate oldDelegate);
-}
-
-/// A render object that draws its child as a [ui.Image].
-class RenderRasterWidget extends RenderProxyBox {
-  /// Create a new [RenderRasterWidget].
-  RenderRasterWidget({
-    required RasterWidgetDelegate delegate,
+// A render object that conditionally converts its child into a [ui.Image]
+// and then paints it in place of the child.
+class _RenderSnapshotWidget extends RenderProxyBox {
+  // Create a new [_RenderSnapshotWidget].
+  _RenderSnapshotWidget({
     required double devicePixelRatio,
-    required RasterWidgetController controller,
-    required RasterizeMode mode,
-    RasterWidgetFallbackDelegate? fallback,
-  }) : _delegate = delegate,
-       _devicePixelRatio = devicePixelRatio,
+    required SnapshotController controller,
+    required SnapshotMode mode,
+    required SnapshotPainter painter,
+  }) : _devicePixelRatio = devicePixelRatio,
        _controller = controller,
-       _fallback = fallback,
-       _mode = mode;
+       _mode = mode,
+       _painter = painter;
 
   /// The device pixel ratio used to create the child image.
   double get devicePixelRatio => _devicePixelRatio;
@@ -274,61 +172,57 @@ class RenderRasterWidget extends RenderProxyBox {
       return;
     }
     _devicePixelRatio = value;
-    markNeedsPaint();
+    if (_childRaster == null) {
+      return;
+    } else {
+      _childRaster?.dispose();
+      _childRaster = null;
+      markNeedsPaint();
+    }
   }
 
-  /// Whether a rasterized version of this render objects child is drawn in
-  /// place of the child.
-  RasterWidgetController get controller => _controller;
-  RasterWidgetController _controller;
-  set controller(RasterWidgetController value) {
-    if (value == controller) {
+  /// The painter used to paint the child snapshot or child widgets.
+  SnapshotPainter get painter => _painter;
+  SnapshotPainter _painter;
+  set painter(SnapshotPainter value) {
+    if (value == painter) {
       return;
     }
-    controller.removeListener(_onRasterValueChanged);
-    final bool oldValue = controller.rasterize;
-    _controller = value;
+    final SnapshotPainter oldPainter = painter;
+    oldPainter.removeListener(markNeedsPaint);
+    _painter = value;
+    if (oldPainter.runtimeType != painter.runtimeType ||
+        painter.shouldRepaint(oldPainter)) {
+      markNeedsPaint();
+    }
     if (attached) {
-      controller.addListener(_onRasterValueChanged);
-      if (oldValue != controller.rasterize) {
-        _onRasterValueChanged();
-      }
+      painter.addListener(markNeedsPaint);
     }
   }
 
-  /// The delegate used to draw the image representing the child.
-  RasterWidgetDelegate get delegate => _delegate;
-  RasterWidgetDelegate _delegate;
-  set delegate(RasterWidgetDelegate value) {
-    if (value == delegate) {
+  /// A controller that determines whether to paint the child normally or to
+  /// paint a snapshotted version of that child.
+  SnapshotController get controller => _controller;
+  SnapshotController _controller;
+  set controller(SnapshotController value) {
+    if (value == controller) {
       return;
     }
-    delegate.removeListener(markNeedsPaint);
-    final RasterWidgetDelegate oldDelegate = _delegate;
-    _delegate = value;
+    controller.removeListener(_onRasterValueChanged);
+    final bool oldValue = controller.allowSnapshotting;
+    _controller = value;
     if (attached) {
-      delegate.addListener(markNeedsPaint);
-      if (delegate.shouldRepaint(oldDelegate)) {
-        markNeedsPaint();
+      controller.addListener(_onRasterValueChanged);
+      if (oldValue != controller.allowSnapshotting) {
+        _onRasterValueChanged();
       }
     }
   }
 
-  /// A fallback delegate which is used if the child layers contains a platform view.
-  RasterWidgetFallbackDelegate? get fallback => _fallback;
-  RasterWidgetFallbackDelegate? _fallback;
-  set fallback(RasterWidgetFallbackDelegate? value) {
-    if (value == fallback) {
-      return;
-    }
-    _fallback = value;
-    markNeedsPaint();
-  }
-
-  /// How the raster widget will handle platform views in child layers.
-  RasterizeMode get mode => _mode;
-  RasterizeMode _mode;
-  set mode(RasterizeMode value) {
+  /// How the snapshot widget will handle platform views in child layers.
+  SnapshotMode get mode => _mode;
+  SnapshotMode _mode;
+  set mode(SnapshotMode value) {
     if (value == _mode) {
       return;
     }
@@ -337,18 +231,22 @@ class RenderRasterWidget extends RenderProxyBox {
   }
 
   ui.Image? _childRaster;
+  // Set to true if the snapshot mode was not forced and a platform view
+  // was encountered while attempting to snapshot the child.
+  bool _disableSnapshotAttempt = false;
 
   @override
   void attach(covariant PipelineOwner owner) {
-    delegate.addListener(markNeedsPaint);
     controller.addListener(_onRasterValueChanged);
+    painter.addListener(markNeedsPaint);
     super.attach(owner);
   }
 
   @override
   void detach() {
-    delegate.removeListener(markNeedsPaint);
+    _disableSnapshotAttempt = false;
     controller.removeListener(_onRasterValueChanged);
+    painter.removeListener(markNeedsPaint);
     _childRaster?.dispose();
     _childRaster = null;
     super.detach();
@@ -356,22 +254,20 @@ class RenderRasterWidget extends RenderProxyBox {
 
   @override
   void dispose() {
-    delegate.removeListener(markNeedsPaint);
     controller.removeListener(_onRasterValueChanged);
+    painter.removeListener(markNeedsPaint);
     _childRaster?.dispose();
     _childRaster = null;
     super.dispose();
   }
 
   void _onRasterValueChanged() {
+    _disableSnapshotAttempt = false;
     _childRaster?.dispose();
     _childRaster = null;
     markNeedsPaint();
   }
 
-  bool _hitPlatformView = false;
-  bool get _useFallback => _hitPlatformView || mode == RasterizeMode.fallback;
-
   // Paint [child] with this painting context, then convert to a raster and detach all
   // children from this layer.
   ui.Image? _paintAndDetachToImage() {
@@ -383,15 +279,11 @@ class RenderRasterWidget extends RenderProxyBox {
     // that would conflict with our goals of minimizing painting context.
     // ignore: invalid_use_of_protected_member
     context.stopRecordingIfNeeded();
-    if (mode != RasterizeMode.forced && !offsetLayer.supportsRasterization()) {
-      _hitPlatformView = true;
-      if (fallback == null) {
-        assert(() {
-          throw FlutterError(
-            'RasterWidget used with a child that contains a PlatformView.'
-          );
-        }());
+    if (mode != SnapshotMode.forced && !offsetLayer.supportsRasterization()) {
+      if (mode == SnapshotMode.normal) {
+        throw FlutterError('SnapshotWidget used with a child that contains a PlatformView.');
       }
+      _disableSnapshotAttempt = true;
       return null;
     }
     final ui.Image image = offsetLayer.toImageSync(Offset.zero & size, pixelRatio: devicePixelRatio);
@@ -406,40 +298,117 @@ class RenderRasterWidget extends RenderProxyBox {
       _childRaster = null;
       return;
     }
-    if (controller.rasterize) {
-      if (_useFallback) {
-        fallback?.paintFallback(context, offset, size, super.paint);
-      } else {
-        _childRaster ??= _paintAndDetachToImage();
-        if (_childRaster == null && _useFallback) {
-          fallback?.paintFallback(context, offset, size, super.paint);
-        } else {
-          delegate.paint(context, offset, size, _childRaster!, devicePixelRatio);
-        }
-      }
+    if (!controller.allowSnapshotting || _disableSnapshotAttempt) {
+      _childRaster?.dispose();
+      _childRaster = null;
+      painter.paint(context, offset, size, super.paint);
       return;
     }
-    _childRaster?.dispose();
-    _childRaster = null;
-    super.paint(context, offset);
+    _childRaster ??= _paintAndDetachToImage();
+    if (_childRaster == null) {
+      painter.paint(context, offset, size, super.paint);
+    } else {
+      painter.paintSnapshot(context, offset, size, _childRaster!, devicePixelRatio);
+    }
+    return;
   }
 }
 
-// A delegate that paints the child widget as is.
-class _RasterDefaultDelegate implements RasterWidgetDelegate {
-  const _RasterDefaultDelegate();
+/// A painter used to paint either a snapshot or the child widgets that
+/// would be a snapshot.
+///
+/// The painter can call [notifyListeners] to have the [SnapshotWidget]
+/// re-paint (re-using the same raster). This allows animations to be  performed
+/// without re-snapshotting of children. For certain scale or perspective changing
+/// transforms, such as a rotation, this can be significantly faster than performing
+/// the same animation at the widget level.
+///
+/// By default, the [SnapshotWidget] includes a delegate that draws the child raster
+/// exactly as the child widgets would have been drawn. Nevertheless, this can
+/// also be used to efficiently transform the child raster and apply complex paint
+/// effects.
+///
+/// {@tool snippet}
+///
+/// The following method shows how to efficiently rotate the child raster.
+///
+/// ```dart
+/// void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
+///   const double radians = 0.5; // Could be driven by an animation.
+///   final Matrix4 transform = Matrix4.rotationZ(radians);
+///   context.canvas.transform(transform.storage);
+///   final Rect src = Rect.fromLTWH(0, 0, image.width.toDouble(), image.height.toDouble());
+///   final Rect dst = Rect.fromLTWH(offset.dx, offset.dy, size.width, size.height);
+///   final Paint paint = Paint()
+///     ..filterQuality = FilterQuality.low;
+///   context.canvas.drawImageRect(image, src, dst, paint);
+/// }
+/// ```
+/// {@end-tool}
+abstract class SnapshotPainter extends ChangeNotifier  {
+  /// Called whenever the [image] that represents a [SnapshotWidget]s child should be painted.
+  ///
+  /// The image is rasterized at the physical pixel resolution and should be scaled down by
+  /// [pixelRatio] to account for device independent pixels.
+  ///
+  /// {@tool snippet}
+  ///
+  /// The following method shows how the default implementation of the delegate used by the
+  /// [SnapshotPainter] paints the snapshot. This must account for the fact that the image
+  /// width and height will be given in physical pixels, while the image must be painted with
+  /// device independent pixels. That is, the width and height of the image is the widget and
+  /// height of the provided `size`, multiplied by the `pixelRatio`:
+  ///
+  /// ```dart
+  /// void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
+  ///   final Rect src = Rect.fromLTWH(0, 0, image.width.toDouble(), image.height.toDouble());
+  ///   final Rect dst = Rect.fromLTWH(offset.dx, offset.dy, size.width, size.height);
+  ///   final Paint paint = Paint()
+  ///     ..filterQuality = FilterQuality.low;
+  ///   context.canvas.drawImageRect(image, src, dst, paint);
+  /// }
+  /// ```
+  /// {@end-tool}
+  void paintSnapshot(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio);
+
+  /// Paint the child via [painter], applying any effects that would have been painted
+  /// in [SnapshotPainter.paintSnapshot].
+  ///
+  /// This method is called when snapshotting is disabled, or when [SnapshotMode.permissive]
+  /// is used and a child platform view prevents snapshotting.
+  ///
+  /// The [offset] and [size] are the location and dimensions of the render object.
+  void paint(PaintingContext context, Offset offset, Size size, PaintingContextCallback painter);
 
-  @override
-  void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
-    final Rect src = Rect.fromLTWH(0, 0, image.width.toDouble(), image.height.toDouble());
-    final Rect dst = Rect.fromLTWH(offset.dx, offset.dy, size.width, size.height);
-    final Paint paint = Paint()
-      ..filterQuality = FilterQuality.low;
-    context.canvas.drawImageRect(image, src, dst, paint);
-  }
+  /// Called whenever a new instance of the snapshot widget delegate class is
+  /// provided to the [SnapshotWidget] object, or any time that a new
+  /// [SnapshotPainter] object is created with a new instance of the
+  /// delegate class (which amounts to the same thing, because the latter is
+  /// implemented in terms of the former).
+  ///
+  /// If the new instance represents different information than the old
+  /// instance, then the method should return true, otherwise it should return
+  /// false.
+  ///
+  /// If the method returns false, then the [paint] call might be optimized
+  /// away.
+  ///
+  /// It's possible that the [paint] method will get called even if
+  /// [shouldRepaint] returns false (e.g. if an ancestor or descendant needed to
+  /// be repainted). It's also possible that the [paint] method will get called
+  /// without [shouldRepaint] being called at all (e.g. if the box changes
+  /// size).
+  ///
+  /// Changing the delegate will not cause the child image retained by the
+  /// [SnapshotWidget] to be updated. Instead, [SnapshotController.clear] can
+  /// be used to force the generation of a new image.
+  ///
+  /// The `oldPainter` argument will never be null.
+  bool shouldRepaint(covariant SnapshotPainter oldPainter);
+}
 
-  @override
-  bool shouldRepaint(covariant RasterWidgetDelegate oldDelegate) => false;
+class _DefaultSnapshotPainter implements SnapshotPainter {
+  const _DefaultSnapshotPainter();
 
   @override
   void addListener(ui.VoidCallback listener) { }
@@ -453,6 +422,23 @@ class _RasterDefaultDelegate implements RasterWidgetDelegate {
   @override
   void notifyListeners() { }
 
+  @override
+  void paint(PaintingContext context, ui.Offset offset, ui.Size size, PaintingContextCallback painter) {
+    painter(context, offset);
+  }
+
+  @override
+  void paintSnapshot(PaintingContext context, ui.Offset offset, ui.Size size, ui.Image image, double pixelRatio) {
+    final Rect src = Rect.fromLTWH(0, 0, image.width.toDouble(), image.height.toDouble());
+    final Rect dst = Rect.fromLTWH(offset.dx, offset.dy, size.width, size.height);
+    final Paint paint = Paint()
+      ..filterQuality = FilterQuality.low;
+    context.canvas.drawImageRect(image, src, dst, paint);
+  }
+
   @override
   void removeListener(ui.VoidCallback listener) { }
+
+  @override
+  bool shouldRepaint(covariant _DefaultSnapshotPainter oldPainter) => false;
 }

packages/flutter/lib/widgets.dart

@@ -91,7 +91,6 @@ export 'src/widgets/platform_selectable_region_context_menu.dart';
 export 'src/widgets/platform_view.dart';
 export 'src/widgets/preferred_size.dart';
 export 'src/widgets/primary_scroll_controller.dart';
-export 'src/widgets/raster_widget.dart';
 export 'src/widgets/raw_keyboard_listener.dart';
 export 'src/widgets/reorderable_list.dart';
 export 'src/widgets/restoration.dart';
@@ -127,6 +126,7 @@ export 'src/widgets/sliver_layout_builder.dart';
 export 'src/widgets/sliver_persistent_header.dart';
 export 'src/widgets/sliver_prototype_extent_list.dart';
 export 'src/widgets/slotted_render_object_widget.dart';
+export 'src/widgets/snapshot_widget.dart';
 export 'src/widgets/spacer.dart';
 export 'src/widgets/spell_check.dart';
 export 'src/widgets/status_transitions.dart';

packages/flutter/test/material/dropdown_test.dart

@@ -399,18 +399,21 @@ void main() {
     Widget build() {
       return Directionality(
         textDirection: TextDirection.ltr,
-        child: Navigator(
-          initialRoute: '/',
-          onGenerateRoute: (RouteSettings settings) {
-            return MaterialPageRoute<void>(
-              settings: settings,
-              builder: (BuildContext context) {
-                return Material(
-                  child: buildFrame(value: 'one', onChanged: didChangeValue),
-                );
-              },
-            );
-          },
+        child: MediaQuery(
+          data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+          child: Navigator(
+            initialRoute: '/',
+            onGenerateRoute: (RouteSettings settings) {
+              return MaterialPageRoute<void>(
+                settings: settings,
+                builder: (BuildContext context) {
+                  return Material(
+                    child: buildFrame(value: 'one', onChanged: didChangeValue),
+                  );
+                },
+              );
+            },
+          ),
         ),
       );
     }

packages/flutter/test/material/page_test.dart

@@ -158,7 +158,7 @@ void main() {
   testWidgets('test page transition (_ZoomPageTransition) without rasterization', (WidgetTester tester) async {
     Iterable<Layer> findLayers(Finder of) {
       return tester.layerListOf(
-        find.ancestor(of: of, matching: find.byType(RasterWidget)).first,
+        find.ancestor(of: of, matching: find.byType(SnapshotWidget)).first,
       );
     }
 
@@ -174,7 +174,7 @@ void main() {
       MaterialApp(
         onGenerateRoute: (RouteSettings settings) {
           return MaterialPageRoute<void>(
-            preferRasterization: false,
+            allowSnapshotting: false,
             builder: (BuildContext context) {
               if (settings.name == '/') {
                 return const Material(child: Text('Page 1'));
@@ -1004,8 +1004,7 @@ void main() {
     await tester.pumpWidget(
       RootRestorationScope(
         restorationId: 'root',
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             onPopPage: (Route<dynamic> route, dynamic result) { return false; },
             pages: const <Page<Object?>>[
@@ -1177,3 +1176,20 @@ class _TestRestorableWidgetState extends State<TestRestorableWidget> with Restor
     );
   }
 }
+
+class TestDependencies extends StatelessWidget {
+  const TestDependencies({required this.child, super.key});
+
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return Directionality(
+      textDirection: TextDirection.ltr,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+        child: child,
+      ),
+    );
+  }
+}

packages/flutter/test/material/text_field_test.dart

@@ -1821,7 +1821,7 @@ void main() {
     // Wait for context menu to be built.
     await tester.pumpAndSettle();
     final RenderBox container = tester.renderObject(find.descendant(
-      of: find.byType(RasterWidget),
+      of: find.byType(SnapshotWidget),
       matching: find.byType(SizedBox),
     ).first);
     expect(container.size, Size.zero);

packages/flutter/test/widgets/heroes_test.dart

@@ -327,8 +327,7 @@ Future<void> main() async {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: HeroController(),
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             key: key,
             initialRoute: 'navigator1',
@@ -382,8 +381,7 @@ Future<void> main() async {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: HeroController(),
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             key: key,
             initialRoute: 'navigator1',
@@ -3160,3 +3158,20 @@ Future<void> main() async {
     },
   );
 }
+
+class TestDependencies extends StatelessWidget {
+  const TestDependencies({required this.child, super.key});
+
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return Directionality(
+      textDirection: TextDirection.ltr,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+        child: child,
+      ),
+    );
+  }
+}

packages/flutter/test/widgets/navigator_restoration_test.dart

@@ -1042,9 +1042,12 @@ class PagedTestWidget extends StatelessWidget {
   Widget build(BuildContext context) {
     return RootRestorationScope(
       restorationId: restorationId,
-      child: const Directionality(
+      child: Directionality(
         textDirection: TextDirection.ltr,
-        child: PagedTestNavigator(),
+        child: MediaQuery(
+          data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+          child: const PagedTestNavigator(),
+        ),
       ),
     );
   }
@@ -1167,20 +1170,23 @@ class TestWidget extends StatelessWidget {
       restorationId: restorationId,
       child: Directionality(
         textDirection: TextDirection.ltr,
-        child: Navigator(
-          initialRoute: 'home',
-          restorationScopeId: 'app',
-          onGenerateRoute: (RouteSettings settings) {
-            return MaterialPageRoute<int>(
-              settings: settings,
-              builder: (BuildContext context) {
-                return RouteWidget(
-                  name: settings.name!,
-                  arguments: settings.arguments,
-                );
-              },
-            );
-          },
+        child: MediaQuery(
+          data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+          child: Navigator(
+            initialRoute: 'home',
+            restorationScopeId: 'app',
+            onGenerateRoute: (RouteSettings settings) {
+              return MaterialPageRoute<int>(
+                settings: settings,
+                builder: (BuildContext context) {
+                  return RouteWidget(
+                    name: settings.name!,
+                    arguments: settings.arguments,
+                  );
+                },
+              );
+            },
+          ),
         ),
       ),
     );

packages/flutter/test/widgets/navigator_test.dart

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import 'dart:ui';
-
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
@@ -201,8 +199,7 @@ void main() {
       };
     final GlobalKey<NavigatorState> navigator = GlobalKey<NavigatorState>();
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: Navigator(
           key: navigator,
           pages: pages,
@@ -566,8 +563,7 @@ void main() {
     }
     final TabController controller = TabController(length: 3, vsync: tester);
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: TabBarView(
           controller: controller,
           children: <Widget>[
@@ -598,8 +594,7 @@ void main() {
       );
     }
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: buildNavigator(),
       ),
     );
@@ -608,8 +603,7 @@ void main() {
     pages.add(const MaterialPage<void>(child: Text('Page 2')));
 
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: buildNavigator(),
       ),
     );
@@ -641,8 +635,7 @@ void main() {
       );
     }
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: buildNavigator(),
       ),
     );
@@ -659,8 +652,7 @@ void main() {
     ];
 
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: buildNavigator(),
       ),
     );
@@ -1904,8 +1896,7 @@ void main() {
   testWidgets('initial routes below opaque route are offstage', (WidgetTester tester) async {
     final GlobalKey<NavigatorState> testKey = GlobalKey<NavigatorState>();
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: Navigator(
           key: testKey,
           initialRoute: '/a/b',
@@ -1947,8 +1938,7 @@ void main() {
     bool onGenerateInitialRoutesCalled = false;
     final GlobalKey<NavigatorState> testKey = GlobalKey<NavigatorState>();
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: Navigator(
           key: testKey,
           initialRoute: 'Hello World',
@@ -2074,8 +2064,7 @@ void main() {
     final Map<String, MaterialPageRoute<dynamic>> routeNameToContext = <String, MaterialPageRoute<dynamic>>{};
 
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: Navigator(
           key: navigator,
           initialRoute: 'root',
@@ -2154,8 +2143,7 @@ void main() {
     Widget widgetUnderTest({required bool enabled}) {
       return TickerMode(
         enabled: enabled,
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             initialRoute: 'root',
             onGenerateRoute: (RouteSettings settings) {
@@ -2261,8 +2249,7 @@ void main() {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: spy,
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             key: top,
             initialRoute: 'top1',
@@ -2332,8 +2319,7 @@ void main() {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: spy,
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             key: key1,
             initialRoute: 'navigator1',
@@ -2353,8 +2339,7 @@ void main() {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: spy,
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Navigator(
             key: key2,
             initialRoute: 'navigator2',
@@ -2412,8 +2397,7 @@ void main() {
         );
       };
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: Stack(
           children: <Widget>[
             HeroControllerScope(
@@ -2459,8 +2443,7 @@ void main() {
 
     // Swaps the spies.
     await tester.pumpWidget(
-      Directionality(
-        textDirection: TextDirection.ltr,
+      TestDependencies(
         child: Stack(
           children: <Widget>[
             HeroControllerScope(
@@ -2532,8 +2515,7 @@ void main() {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: spy,
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Stack(
             children: <Widget>[
               Navigator(
@@ -2571,8 +2553,7 @@ void main() {
     await tester.pumpWidget(
       HeroControllerScope(
         controller: spy,
-        child: Directionality(
-          textDirection: TextDirection.ltr,
+        child: TestDependencies(
           child: Stack(
             children: <Widget>[
               Navigator(
@@ -2637,8 +2618,7 @@ void main() {
             DefaultMaterialLocalizations.delegate,
             DefaultWidgetsLocalizations.delegate,
           ],
-          child: Directionality(
-            textDirection: TextDirection.ltr,
+          child: TestDependencies(
             child: Navigator(
               key: key,
               pages: pages,
@@ -2736,8 +2716,7 @@ void main() {
               DefaultMaterialLocalizations.delegate,
               DefaultWidgetsLocalizations.delegate,
             ],
-            child: Directionality(
-              textDirection: TextDirection.ltr,
+            child: TestDependencies(
               child: Navigator(
                 pages: myPages,
               ),
@@ -2832,8 +2811,7 @@ void main() {
               DefaultMaterialLocalizations.delegate,
               DefaultWidgetsLocalizations.delegate,
             ],
-            child: Directionality(
-              textDirection: TextDirection.ltr,
+            child: TestDependencies(
               child: Navigator(
                 pages: myPages,
               ),
@@ -3086,8 +3064,7 @@ void main() {
     testWidgets('Pop no animation page does not crash', (WidgetTester tester) async {
       // Regression Test for https://github.com/flutter/flutter/issues/86604.
       Widget buildNavigator(bool secondPage) {
-        return Directionality(
-          textDirection: TextDirection.ltr,
+        return TestDependencies(
           child: Navigator(
             pages: <Page<void>>[
               const ZeroDurationPage(
@@ -3691,8 +3668,7 @@ void main() {
   testWidgets('Can reuse NavigatorObserver in rebuilt tree', (WidgetTester tester) async {
     final NavigatorObserver observer = NavigatorObserver();
     Widget build([Key? key]) {
-      return Directionality(
-        textDirection: TextDirection.ltr,
+      return TestDependencies(
         child: Navigator(
           key: key,
           observers: <NavigatorObserver>[observer],
@@ -3869,8 +3845,7 @@ void main() {
   testWidgets('class implementing NavigatorObserver can be used without problems', (WidgetTester tester) async {
     final _MockNavigatorObserver observer = _MockNavigatorObserver();
     Widget build([Key? key]) {
-      return Directionality(
-        textDirection: TextDirection.ltr,
+      return TestDependencies(
         child: Navigator(
           key: key,
           observers: <NavigatorObserver>[observer],
@@ -4122,7 +4097,7 @@ class ZeroDurationPage extends Page<void> {
 
 class ZeroDurationPageRoute extends PageRoute<void> {
   ZeroDurationPageRoute({required ZeroDurationPage page})
-      : super(settings: page, preferRasterization: false);
+      : super(settings: page, allowSnapshotting: false);
 
   @override
   Duration get transitionDuration => Duration.zero;
@@ -4163,3 +4138,20 @@ class _MockNavigatorObserver implements NavigatorObserver {
     return null;
   }
 }
+
+class TestDependencies extends StatelessWidget {
+  const TestDependencies({super.key, required this.child});
+
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return MediaQuery(
+      data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+      child: Directionality(
+        textDirection: TextDirection.ltr,
+        child: child,
+      )
+    );
+  }
+}

packages/flutter/test/widgets/scroll_position_test.dart

@@ -33,24 +33,27 @@ Future<void> performTest(WidgetTester tester, bool maintainState) async {
   await tester.pumpWidget(
     Directionality(
       textDirection: TextDirection.ltr,
-      child: Navigator(
-        key: navigatorKey,
-        onGenerateRoute: (RouteSettings settings) {
-          if (settings.name == '/') {
-            return MaterialPageRoute<void>(
-              settings: settings,
-              builder: (_) => const ThePositiveNumbers(from: 0),
-              maintainState: maintainState,
-            );
-          } else if (settings.name == '/second') {
-            return MaterialPageRoute<void>(
-              settings: settings,
-              builder: (_) => const ThePositiveNumbers(from: 10000),
-              maintainState: maintainState,
-            );
-          }
-          return null;
-        },
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window),
+        child: Navigator(
+          key: navigatorKey,
+          onGenerateRoute: (RouteSettings settings) {
+            if (settings.name == '/') {
+              return MaterialPageRoute<void>(
+                settings: settings,
+                builder: (_) => const ThePositiveNumbers(from: 0),
+                maintainState: maintainState,
+              );
+            } else if (settings.name == '/second') {
+              return MaterialPageRoute<void>(
+                settings: settings,
+                builder: (_) => const ThePositiveNumbers(from: 10000),
+                maintainState: maintainState,
+              );
+            }
+            return null;
+          },
+        ),
       ),
     ),
   );

packages/flutter/test/widgets/raster_widget_test.dart → packages/flutter/test/widgets/snapshot_widget_test.dart

@@ -14,13 +14,13 @@ import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 void main() {
-  testWidgets('RasterWidget can rasterize child', (WidgetTester tester) async {
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
+  testWidgets('SnapshotWidget can rasterize child', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
     final Key key = UniqueKey();
     await tester.pumpWidget(RepaintBoundary(
       key: key,
-      child: Center(
-        child: RasterWidget(
+      child: TestDependencies(
+        child: SnapshotWidget(
           controller: controller,
           child: Container(
             width: 100,
@@ -30,151 +30,107 @@ void main() {
         ),
       ),
     ));
-    // Rasterization is not actually complete until a frame has been pumped through
-    // the engine.
-    await tester.pumpAndSettle();
-
     await expectLater(find.byKey(key), matchesGoldenFile('raster_widget.yellow.png'));
-  }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RasterWidget is not a repaint boundary when rasterizing', (WidgetTester tester) async {
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
+    // Now change the color and assert the old snapshot still matches.
     await tester.pumpWidget(RepaintBoundary(
-      child: Center(
-        child: RasterWidget(
+      key: key,
+      child: TestDependencies(
+        child: SnapshotWidget(
           controller: controller,
           child: Container(
             width: 100,
             height: 100,
-            color: const Color(0xFFAABB11),
+            color: const Color(0xFFAA0000),
           ),
         ),
       ),
     ));
+    await expectLater(find.byKey(key), matchesGoldenFile('raster_widget.yellow.png'));
 
-    expect(tester.layers, hasLength(3));
-    expect(tester.layers.last, isA<PictureLayer>());
-
-    controller.rasterize = false;
+    // Now invoke clear and the raster is re-generated.
+    controller.clear();
     await tester.pump();
 
-    expect(tester.layers, hasLength(3));
-    expect(tester.layers.last, isA<PictureLayer>());
+    await expectLater(find.byKey(key), matchesGoldenFile('raster_widget.red.png'));
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RasterWidget repaints when RasterWidgetDelegate notifies listeners', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-    await tester.pumpWidget(RepaintBoundary(
-      child: Center(
-        child: RasterWidget(
-          delegate: delegate,
-          controller: controller,
-          child: Container(
-            width: 100,
-            height: 100,
-            color: const Color(0xFFAABB11),
-          ),
-        ),
-      ),
-    ));
-
-    expect(delegate.count, 1);
-    delegate.notify();
-    await tester.pump();
-
-    expect(delegate.count, 2);
-
-    // Remove widget and verify removal of listeners.
-    await tester.pumpWidget(const SizedBox());
-
-    delegate.notify();
-    await tester.pump();
-
-    expect(delegate.count, 2);
-  }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
+  testWidgets('Changing devicePixelRatio does not repaint if snapshotting is not enabled', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController();
+    final TestPainter painter = TestPainter();
+    double devicePixelRatio = 1.0;
+    late StateSetter localSetState;
 
-  testWidgets('RasterWidget will recreate raster when controller calls clear', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-    await tester.pumpWidget(RepaintBoundary(
-      child: Center(
-        child: RasterWidget(
-          delegate: delegate,
-          controller: controller,
-          child: Container(
-            width: 100,
-            height: 100,
-            color: const Color(0xFFAABB11),
+    await tester.pumpWidget(
+      StatefulBuilder(builder: (BuildContext context, StateSetter setState) {
+        localSetState = setState;
+        return Center(
+          child: TestDependencies(
+            devicePixelRatio: devicePixelRatio,
+            child: SnapshotWidget(
+              controller: controller,
+              painter: painter,
+              child: const SizedBox(width: 100, height: 100),
+            ),
           ),
-        ),
-      ),
-    ));
+        );
+      }),
+    );
 
-    expect(delegate.lastImage, isNotNull);
-    final ui.Image lastImage = delegate.lastImage!;
+    expect(painter.count, 1);
 
+    localSetState(() {
+      devicePixelRatio = 2.0;
+    });
     await tester.pump();
 
-    // Raster is re-used
-    expect(lastImage, equals(delegate.lastImage));
-
-    controller.clear();
-
-    await tester.pump();
-    // Raster is re-created.
-    expect(delegate.lastImage, isNotNull);
-    expect(lastImage, isNot(delegate.lastImage));
+    // Not repainted as dpr was not used.
+    expect(painter.count, 1);
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RasterWidget can update the delegate', (WidgetTester tester) async {
-    final TestDelegate delegateA = TestDelegate();
-    final TestDelegate delegateB = TestDelegate()
-      ..shouldRepaintValue = true;
-    TestDelegate delegate = delegateA;
-
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-    late void Function(void Function()) setStateFn;
-    await tester.pumpWidget(StatefulBuilder(
-      builder: (BuildContext context, void Function(void Function()) setState) {
-        setStateFn = setState;
+  testWidgets('Changing devicePixelRatio forces raster regeneration', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
+    final TestPainter painter = TestPainter();
+    double devicePixelRatio = 1.0;
+    late StateSetter localSetState;
+
+    await tester.pumpWidget(
+      StatefulBuilder(builder: (BuildContext context, StateSetter setState) {
+        localSetState = setState;
         return Center(
-          child: RasterWidget(
-            delegate: delegate,
-            controller: controller,
-            child: Container(
-              width: 100,
-              height: 100,
-              color: const Color(0xFFAABB11),
+          child: TestDependencies(
+            devicePixelRatio: devicePixelRatio,
+            child: SnapshotWidget(
+              controller: controller,
+              painter: painter,
+              child: const SizedBox(width: 100, height: 100),
             ),
           ),
         );
-      })
+      }),
     );
+    final ui.Image? raster = painter.lastImage;
+
+    expect(raster, isNotNull);
+    expect(painter.count, 1);
 
-    expect(delegateA.count, 1);
-    expect(delegateB.count, 0);
-    setStateFn(() {
-      delegate = delegateB;
+    localSetState(() {
+      devicePixelRatio = 2.0;
     });
     await tester.pump();
 
-    expect(delegateA.count, 1);
-    expect(delegateB.count, 1);
+    final ui.Image? newRaster = painter.lastImage;
+
+    expect(painter.count, 2);
+    expect(raster, isNot(newRaster));
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RasterWidget can update the ValueNotifier', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controllerA = RasterWidgetController(rasterize: true);
-    final RasterWidgetController controllerB = RasterWidgetController();
-    RasterWidgetController controller = controllerA;
-    late void Function(void Function()) setStateFn;
-    await tester.pumpWidget(StatefulBuilder(
-      builder: (BuildContext context, void Function(void Function()) setState) {
-        setStateFn = setState;
-        return Center(
-          child: RasterWidget(
-            delegate: delegate,
+  testWidgets('SnapshotWidget paints its child as a single picture layer', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
+    await tester.pumpWidget(RepaintBoundary(
+      child: Center(
+        child: TestDependencies(
+          child: SnapshotWidget(
             controller: controller,
             child: Container(
               width: 100,
@@ -182,155 +138,73 @@ void main() {
               color: const Color(0xFFAABB11),
             ),
           ),
-        );
-      })
-    );
-
-    expect(delegate.count, 1);
-    expect(tester.layers.last, isA<OffsetLayer>());
-    setStateFn(() {
-      controller = controllerB;
-    });
-    await tester.pump();
+        ),
+      ),
+    ));
 
-    expect(delegate.count, 1);
+    expect(tester.layers, hasLength(3));
     expect(tester.layers.last, isA<PictureLayer>());
 
-    // changes to old notifier do not impact widget.
-    controllerA.rasterize = false;
+    controller.allowSnapshotting = false;
     await tester.pump();
 
-    expect(delegate.count, 1);
+    expect(tester.layers, hasLength(3));
     expect(tester.layers.last, isA<PictureLayer>());
-
-    await tester.pumpWidget(const SizedBox());
-
-    // changes to notifier do not impact widget after disposal.
-    controllerB.rasterize = true;
-    await tester.pump();
-    expect(delegate.count, 1);
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RenderRasterWidget correctly attaches and detaches delegate callbacks', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-    final RenderRasterWidget rasterWidget = RenderRasterWidget(
-      delegate: delegate,
-      controller: controller,
-      devicePixelRatio: 1.0,
-      mode: RasterizeMode.enabled,
-    );
-
-    expect(delegate.addedListenerCount, 0);
-    expect(delegate.removedListenerCount, 0);
-
-    final PipelineOwner owner = PipelineOwner();
-    rasterWidget.attach(owner);
-
-    expect(delegate.addedListenerCount, 1);
-    expect(delegate.removedListenerCount, 0);
-
-    rasterWidget.detach();
-
-    expect(delegate.addedListenerCount, 1);
-    expect(delegate.removedListenerCount, 1);
-
-    final TestDelegate updatedDelegate = TestDelegate();
-    rasterWidget.delegate = updatedDelegate;
-
-    // No listeners added or removed while not attached.
-    expect(updatedDelegate.addedListenerCount, 0);
-    expect(updatedDelegate.removedListenerCount, 0);
-  }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
-
-  testWidgets('RenderRasterWidget correctly attaches and detaches controller callbacks', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final TestController controller = TestController();
-    final RenderRasterWidget rasterWidget = RenderRasterWidget(
-      delegate: delegate,
-      controller: controller,
-      devicePixelRatio: 1.0,
-      mode: RasterizeMode.enabled,
+  testWidgets('SnapshotWidget can update the painter type', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
+    await tester.pumpWidget(
+      Center(
+        child: TestDependencies(
+          child: SnapshotWidget(
+            controller: controller,
+            painter: TestPainter(),
+            child: const SizedBox(),
+          ),
+        ),
+      ),
     );
 
-    expect(controller.addedListenerCount, 0);
-    expect(controller.removedListenerCount, 0);
-
-    final PipelineOwner owner = PipelineOwner();
-    rasterWidget.attach(owner);
-
-    expect(controller.addedListenerCount, 1);
-    expect(controller.removedListenerCount, 0);
-
-    rasterWidget.detach();
-
-    expect(controller.addedListenerCount, 1);
-    expect(controller.removedListenerCount, 1);
-
-    final TestController updatedController = TestController();
-    rasterWidget.controller = updatedController;
-
-    // No listeners added or removed while not attached.
-    expect(updatedController.addedListenerCount, 0);
-    expect(updatedController.removedListenerCount, 0);
-  }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
-
-  testWidgets('RenderRasterWidget does not error on rasterization of child with empty size', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-
     await tester.pumpWidget(
       Center(
-        child: Directionality(
-          textDirection: TextDirection.ltr,
-          child: RasterWidget(
-            delegate: delegate,
+        child: TestDependencies(
+          child: SnapshotWidget(
             controller: controller,
+            painter: TestPainter2(),
             child: const SizedBox(),
           ),
         ),
       ),
     );
-  }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
-
 
-  testWidgets('RenderRasterWidget throws assertion if platform view is encountered', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
+    expect(tester.takeException(), isNull);
+  }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
+  testWidgets('RenderSnapshotWidget does not error on rasterization of child with empty size', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
     await tester.pumpWidget(
       Center(
-        child: Directionality(
-          textDirection: TextDirection.ltr,
-          child: RasterWidget(
-            delegate: delegate,
+        child: TestDependencies(
+          child: SnapshotWidget(
             controller: controller,
-            child: const SizedBox(
-              width: 100,
-              height: 100,
-              child: TestPlatformView(),
-            ),
+            child: const SizedBox(),
           ),
         ),
       ),
     );
 
-    expect(tester.takeException(), isA<FlutterError>()
-      .having((FlutterError error) => error.message, 'message', contains('RasterWidget used with a child that contains a PlatformView')));
+    expect(tester.takeException(), isNull);
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RenderRasterWidget does not assert if RasterizeMode.forced', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
 
+  testWidgets('RenderSnapshotWidget throws assertion if platform view is encountered', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
     await tester.pumpWidget(
       Center(
-        child: Directionality(
-          textDirection: TextDirection.ltr,
-          child: RasterWidget(
-            delegate: delegate,
+        child: TestDependencies(
+          child: SnapshotWidget(
             controller: controller,
-            mode: RasterizeMode.forced,
             child: const SizedBox(
               width: 100,
               height: 100,
@@ -341,21 +215,18 @@ void main() {
       ),
     );
 
-    expect(tester.takeException(), isNull);
+    expect(tester.takeException(), isA<FlutterError>()
+      .having((FlutterError error) => error.message, 'message', contains('SnapshotWidget used with a child that contains a PlatformView')));
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RenderRasterWidget fallbacks to delegate if PlatformView is present', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-    final TestFallback fallback = TestFallback();
+  testWidgets('RenderSnapshotWidget does not assert if SnapshotMode.forced', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
     await tester.pumpWidget(
       Center(
-        child: Directionality(
-          textDirection: TextDirection.ltr,
-          child: RasterWidget(
-            delegate: delegate,
+        child: TestDependencies(
+          child: SnapshotWidget(
             controller: controller,
-            fallback: fallback,
+            mode: SnapshotMode.forced,
             child: const SizedBox(
               width: 100,
               height: 100,
@@ -366,48 +237,33 @@ void main() {
       ),
     );
 
-    expect(fallback.calledFallback, 1);
-    expect(delegate.count, 0);
+    expect(tester.takeException(), isNull);
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 
-  testWidgets('RenderRasterWidget fallbacks to delegate if mode: RasterizeMode.fallback', (WidgetTester tester) async {
-    final TestDelegate delegate = TestDelegate();
-    final RasterWidgetController controller = RasterWidgetController(rasterize: true);
-    final TestFallback fallback = TestFallback();
+  testWidgets('RenderSnapshotWidget does not take a snapshot if a platform view is encounted with SnapshotMode.permissive', (WidgetTester tester) async {
+    final SnapshotController controller = SnapshotController(allowSnapshotting: true);
     await tester.pumpWidget(
       Center(
-        child: Directionality(
-          textDirection: TextDirection.ltr,
-          child: RasterWidget(
-            delegate: delegate,
+        child: TestDependencies(
+          child: SnapshotWidget(
             controller: controller,
-            fallback: fallback,
-            mode: RasterizeMode.fallback,
+            mode: SnapshotMode.permissive,
             child: const SizedBox(
               width: 100,
               height: 100,
+              child: TestPlatformView(),
             ),
           ),
         ),
       ),
     );
 
-    expect(fallback.calledFallback, 1);
-    expect(delegate.count, 0);
+    expect(tester.takeException(), isNull);
+    expect(tester.layers.last, isA<PlatformViewLayer>());
   }, skip: kIsWeb); // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/106689
 }
 
-class TestFallback extends RasterWidgetFallbackDelegate {
-  int calledFallback = 0;
-
-  @override
-  void paintFallback(PaintingContext context, ui.Offset offset, ui.Size size, PaintingContextCallback painter) {
-    calledFallback += 1;
-  }
-
-}
-
-class TestController extends RasterWidgetController {
+class TestController extends SnapshotController {
   int addedListenerCount = 0;
   int removedListenerCount = 0;
 
@@ -424,7 +280,23 @@ class TestController extends RasterWidgetController {
   }
 }
 
-class TestDelegate extends RasterWidgetDelegate {
+class TestPlatformView extends SingleChildRenderObjectWidget {
+  const TestPlatformView({super.key});
+
+  @override
+  RenderObject createRenderObject(BuildContext context) {
+    return RenderTestPlatformView();
+  }
+}
+
+class RenderTestPlatformView extends RenderProxyBox {
+  @override
+  void paint(PaintingContext context, ui.Offset offset) {
+    context.addLayer(PlatformViewLayer(rect: offset & size, viewId: 1));
+  }
+}
+
+class TestPainter extends SnapshotPainter {
   int count = 0;
   bool shouldRepaintValue = false;
   ui.Image? lastImage;
@@ -449,29 +321,40 @@ class TestDelegate extends RasterWidgetDelegate {
   }
 
   @override
-  void paint(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
+  void paintSnapshot(PaintingContext context, Offset offset, Size size, ui.Image image, double pixelRatio) {
     count += 1;
     lastImage = image;
   }
 
   @override
-  bool shouldRepaint(covariant RasterWidgetDelegate oldDelegate) => shouldRepaintValue;
-}
-
+  void paint(PaintingContext context, ui.Offset offset, ui.Size size, PaintingContextCallback painter) {
+    count += 1;
+  }
 
-class TestPlatformView extends SingleChildRenderObjectWidget {
-  const TestPlatformView({super.key});
+  @override
+  bool shouldRepaint(covariant TestPainter oldDelegate) => shouldRepaintValue;
+}
 
+class TestPainter2 extends TestPainter {
   @override
-  RenderObject createRenderObject(BuildContext context) {
-    return RenderTestPlatformView();
-  }
+  bool shouldRepaint(covariant TestPainter2 oldDelegate) => shouldRepaintValue;
 }
 
-class RenderTestPlatformView extends RenderProxyBox {
+class TestDependencies extends StatelessWidget {
+  const TestDependencies({required this.child, super.key, this.devicePixelRatio});
+
+  final Widget child;
+  final double? devicePixelRatio;
 
   @override
-  void paint(PaintingContext context, ui.Offset offset) {
-    context.addLayer(PlatformViewLayer(rect: offset & size, viewId: 1));
+  Widget build(BuildContext context) {
+    return Directionality(
+      textDirection: TextDirection.ltr,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window)
+          .copyWith(devicePixelRatio: devicePixelRatio),
+        child: child,
+      ),
+    );
   }
 }