Stand-alone widget tree with multiple render trees to enable multi-view rendering (#125003)

This change enables Flutter to generate multiple Scenes to be rendered into separate FlutterViews from a single widget tree. Each Scene is described by a separate render tree, which are all associated with the single widget tree.

This PR implements the framework-side mechanisms to describe the content to be rendered into multiple views. Separate engine-side changes are necessary to provide these views to the framework and to draw the framework-generated Scene into them.

## Summary of changes

The details of this change are described in [flutter.dev/go/multiple-views](https://flutter.dev/go/multiple-views). Below is a high-level summary organized by layers.

### Rendering layer changes

* The `RendererBinding` no longer owns a single `renderView`. In fact, it doesn't OWN any `RenderView`s at all anymore. Instead, it offers an API (`addRenderView`/`removeRenderView`) to add and remove `RenderView`s that then will be MANAGED by the binding. The `RenderView` itself is now owned by a higher-level abstraction (e.g. the `RawView` Element of the widgets layer, see below), who is also in charge of adding it to the binding. When added, the binding will interact with the `RenderView` to produce a frame (e.g. by calling `compositeFrame` on it) and to perform hit tests for incoming pointer events. Multiple `RenderView`s can be added to the binding (typically one per `FlutterView`) to produce multiple Scenes.
* Instead of owning a single `pipelineOwner`, the `RendererBinding` now owns the root of the `PipelineOwner` tree (exposed as `rootPipelineOwner` on the binding). Each `PipelineOwner` in that tree (except for the root) typically manages its own render tree typically rooted in one of the `RenderView`s mentioned in the previous bullet. During frame production, the binding will instruct each `PipelineOwner` of that tree to flush layout, paint, semantics etc. A higher-level abstraction (e.g. the widgets layer, see below) is in charge of adding `PipelineOwner`s to this tree.
* Backwards compatibility: The old `renderView` and `pipelineOwner` properties of the `RendererBinding` are retained, but marked as deprecated. Care has been taken to keep their original behavior for the deprecation period, i.e. if you just call `runApp`, the render tree bootstrapped by this call is rooted in the deprecated `RendererBinding.renderView` and managed by the deprecated `RendererBinding.pipelineOwner`.

### Widgets layer changes

* The `WidgetsBinding` no longer attaches the widget tree to an existing render tree. Instead, it bootstraps a stand-alone widget tree that is not backed by a render tree. For this, `RenderObjectToWidgetAdapter` has been replaced by `RootWidget`.
* Multiple render trees can be bootstrapped and attached to the widget tree with the help of the `View` widget, which internally is backed by a `RawView` widget. Configured with a `FlutterView` to render into, the `RawView` creates a new `PipelineOwner` and a new `RenderView` for the new render tree. It adds the new `RenderView` to the `RendererBinding` and its `PipelineOwner` to the pipeline owner tree.
* The `View` widget can only appear in certain well-defined locations in the widget tree since it bootstraps a new render tree and does not insert a `RenderObject` into an ancestor. However, almost all Elements expect that their children insert `RenderObject`s, otherwise they will not function properly. To produce a good error message when the `View` widget is used in an illegal location, the `debugMustInsertRenderObjectIntoSlot` method has been added to Element, where a child can ask whether a given slot must insert a RenderObject into its ancestor or not. In practice, the `View` widget can be used as a child of the `RootWidget`, inside the `view` slot of the `ViewAnchor` (see below) and inside a `ViewCollection` (see below). In those locations, the `View` widget may be wrapped in other non-RenderObjectWidgets (e.g. InheritedWidgets).
* The new `ViewAnchor` can be used to create a side-view inside a parent `View`. The `child` of the `ViewAnchor` widget renders into the parent `View` as usual, but the `view` slot can take on another `View` widget, which has access to all inherited widgets above the `ViewAnchor`. Metaphorically speaking, the view is anchored to the location of the `ViewAnchor` in the widget tree.
* The new `ViewCollection` widget allows for multiple sibling views as it takes a list of `View`s as children. It can be used in all the places that accept a `View` widget.

## Google3

As of July 5, 2023 this change passed a TAP global presubmit (TGP) in google3: tap/OCL:544707016:BASE:545809771:1688597935864:e43dd651

## Note to reviewers

This change is big (sorry). I suggest focusing the initial review on the changes inside of `packages/flutter` first. The majority of the changes describe above are implemented in (listed in suggested review order):

* `rendering/binding.dart`
* `widgets/binding.dart`
* `widgets/view.dart`
* `widgets/framework.dart`

All other changes included in the PR are basically the fallout of what's implemented in those files. Also note that a lot of the lines added in this PR are documentation and tests.

I am also very happy to walk reviewers through the code in person or via video call, if that is helpful.

I appreciate any feedback.

## Feedback to address before submitting ("TODO")

dev/benchmarks/microbenchmarks/lib/stocks/layout_bench.dart

@@ -39,7 +39,7 @@ Future<void> main() async {
       size: const Size(355.0, 635.0),
       view: tester.view,
     );
-    final RenderView renderView = WidgetsBinding.instance.renderView;
+    final RenderView renderView = WidgetsBinding.instance.renderViews.single;
     binding.framePolicy = LiveTestWidgetsFlutterBindingFramePolicy.benchmark;
 
     watch.start();

dev/bots/test.dart

@@ -1361,7 +1361,7 @@ Future<void> _runWebTreeshakeTest() async {
   final String javaScript = mainDartJs.readAsStringSync();
 
   // Check that we're not looking at minified JS. Otherwise this test would result in false positive.
-  expect(javaScript.contains('RenderObjectToWidgetElement'), true);
+  expect(javaScript.contains('RootElement'), true);
 
   const String word = 'debugFillProperties';
   int count = 0;

dev/integration_tests/flutter_gallery/test/smoke_test.dart

@@ -79,8 +79,8 @@ Future<void> smokeDemo(WidgetTester tester, GalleryDemo demo) async {
   // Verify that the dumps are pretty.
   final String routeName = demo.routeName;
   verifyToStringOutput('debugDumpApp', routeName, WidgetsBinding.instance.rootElement!.toStringDeep());
-  verifyToStringOutput('debugDumpRenderTree', routeName, RendererBinding.instance.renderView.toStringDeep());
-  verifyToStringOutput('debugDumpLayerTree', routeName, RendererBinding.instance.renderView.debugLayer?.toStringDeep() ?? '');
+  verifyToStringOutput('debugDumpRenderTree', routeName, RendererBinding.instance.renderViews.single.toStringDeep());
+  verifyToStringOutput('debugDumpLayerTree', routeName, RendererBinding.instance.renderViews.single.debugLayer?.toStringDeep() ?? '');
   verifyToStringOutput('debugDumpFocusTree', routeName, WidgetsBinding.instance.focusManager.toStringDeep());
 
   // Scroll the demo around a bit more.

examples/layers/rendering/custom_coordinate_systems.dart

@@ -6,6 +6,7 @@
 // system. Most of the guts of this examples are in src/sector_layout.dart.
 
 import 'package:flutter/rendering.dart';
+import 'src/binding.dart';
 import 'src/sector_layout.dart';
 
 RenderBox buildSectorExample() {
@@ -21,5 +22,5 @@ RenderBox buildSectorExample() {
 }
 
 void main() {
-  RenderingFlutterBinding(root: buildSectorExample()).scheduleFrame();
+  ViewRenderingFlutterBinding(root: buildSectorExample()).scheduleFrame();
 }

examples/layers/rendering/flex_layout.dart

@@ -7,6 +7,7 @@
 
 import 'package:flutter/rendering.dart';
 
+import 'src/binding.dart';
 import 'src/solid_color_box.dart';
 
 void main() {
@@ -86,5 +87,5 @@ void main() {
     child: RenderPadding(child: table, padding: const EdgeInsets.symmetric(vertical: 50.0)),
   );
 
-  RenderingFlutterBinding(root: root).scheduleFrame();
+  ViewRenderingFlutterBinding(root: root).scheduleFrame();
 }

examples/layers/rendering/hello_world.dart

@@ -7,9 +7,11 @@
 
 import 'package:flutter/rendering.dart';
 
+import 'src/binding.dart';
+
 void main() {
-  // We use RenderingFlutterBinding to attach the render tree to the window.
-  RenderingFlutterBinding(
+  // We use ViewRenderingFlutterBinding to attach the render tree to the window.
+  ViewRenderingFlutterBinding(
     // The root of our render tree is a RenderPositionedBox, which centers its
     // child both vertically and horizontally.
     root: RenderPositionedBox(

examples/layers/rendering/spinning_square.dart

@@ -11,6 +11,8 @@ import 'package:flutter/animation.dart';
 import 'package:flutter/rendering.dart';
 import 'package:flutter/scheduler.dart';
 
+import 'src/binding.dart';
+
 class NonStopVSync implements TickerProvider {
   const NonStopVSync();
   @override
@@ -42,7 +44,7 @@ void main() {
     child: spin,
   );
   // and attach it to the window.
-  RenderingFlutterBinding(root: root);
+  ViewRenderingFlutterBinding(root: root);
 
   // To make the square spin, we use an animation that repeats every 1800
   // milliseconds.

examples/layers/rendering/src/binding.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// 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/rendering.dart';
+
+/// An extension of [RenderingFlutterBinding] that owns and manages a
+/// [renderView].
+///
+/// Unlike [RenderingFlutterBinding], this binding also creates and owns a
+/// [renderView] to simplify bootstrapping for apps that have a dedicated main
+/// view.
+class ViewRenderingFlutterBinding extends RenderingFlutterBinding {
+  /// Creates a binding for the rendering layer.
+  ///
+  /// The `root` render box is attached directly to the [renderView] and is
+  /// given constraints that require it to fill the window. The [renderView]
+  /// itself is attached to the [rootPipelineOwner].
+  ///
+  /// This binding does not automatically schedule any frames. Callers are
+  /// responsible for deciding when to first call [scheduleFrame].
+  ViewRenderingFlutterBinding({ RenderBox? root }) : _root = root;
+
+  @override
+  void initInstances() {
+    super.initInstances();
+    // TODO(goderbauer): Create window if embedder doesn't provide an implicit view.
+    assert(PlatformDispatcher.instance.implicitView != null);
+    _renderView = initRenderView(PlatformDispatcher.instance.implicitView!);
+    _renderView.child = _root;
+    _root = null;
+  }
+
+  RenderBox? _root;
+
+  @override
+  RenderView get renderView => _renderView;
+  late RenderView _renderView;
+
+  /// Creates a [RenderView] object to be the root of the
+  /// [RenderObject] rendering tree, and initializes it so that it
+  /// will be rendered when the next frame is requested.
+  ///
+  /// Called automatically when the binding is created.
+  RenderView initRenderView(FlutterView view) {
+    final RenderView renderView = RenderView(view: view);
+    rootPipelineOwner.rootNode = renderView;
+    addRenderView(renderView);
+    renderView.prepareInitialFrame();
+    return renderView;
+  }
+
+  @override
+  PipelineOwner createRootPipelineOwner() {
+    return PipelineOwner(
+      onSemanticsOwnerCreated: () {
+        renderView.scheduleInitialSemantics();
+      },
+      onSemanticsUpdate: (SemanticsUpdate update) {
+        renderView.updateSemantics(update);
+      },
+      onSemanticsOwnerDisposed: () {
+        renderView.clearSemantics();
+      },
+    );
+  }
+}

examples/layers/rendering/touch_input.dart

@@ -8,6 +8,8 @@
 import 'package:flutter/material.dart'; // Imported just for its color palette.
 import 'package:flutter/rendering.dart';
 
+import 'src/binding.dart';
+
 // Material design colors. :p
 List<Color> _kColors = <Color>[
   Colors.teal,
@@ -133,5 +135,5 @@ void main() {
     ..left = 20.0;
 
   // Finally, we attach the render tree we've built to the screen.
-  RenderingFlutterBinding(root: stack).scheduleFrame();
+  ViewRenderingFlutterBinding(root: stack).scheduleFrame();
 }

examples/layers/widgets/spinning_mixed.dart

@@ -52,10 +52,10 @@ void attachWidgetTreeToRenderTree(RenderProxyBox container) {
                   mainAxisAlignment: MainAxisAlignment.spaceAround,
                   children: <Widget>[
                     ElevatedButton(
-                      child: Row(
+                      child: const Row(
                         children: <Widget>[
-                          Image.network('https://flutter.dev/images/favicon.png'),
-                          const Text('PRESS ME'),
+                          FlutterLogo(),
+                          Text('PRESS ME'),
                         ],
                       ),
                       onPressed: () {
@@ -102,6 +102,16 @@ void main() {
   transformBox = RenderTransform(child: flexRoot, transform: Matrix4.identity(), alignment: Alignment.center);
   final RenderPadding root = RenderPadding(padding: const EdgeInsets.all(80.0), child: transformBox);
 
-  binding.renderView.child = root;
+  // TODO(goderbauer): Create a window if embedder doesn't provide an implicit view to draw into.
+  assert(binding.platformDispatcher.implicitView != null);
+  final RenderView view = RenderView(
+    view: binding.platformDispatcher.implicitView!,
+    child: root,
+  );
+  final PipelineOwner pipelineOwner = PipelineOwner()..rootNode = view;
+  binding.rootPipelineOwner.adoptChild(pipelineOwner);
+  binding.addRenderView(view);
+  view.prepareInitialFrame();
+
   binding.addPersistentFrameCallback(rotate);
 }

packages/flutter/lib/src/rendering/object.dart

@@ -870,7 +870,7 @@ class _LocalSemanticsHandle implements SemanticsHandle {
 /// without tying it to a specific binding implementation. All [PipelineOwner]s
 /// in a given tree must be attached to the same [PipelineManifold]. This
 /// happens automatically during [adoptChild].
-class PipelineOwner {
+class PipelineOwner with DiagnosticableTreeMixin {
   /// Creates a pipeline owner.
   ///
   /// Typically created by the binding (e.g., [RendererBinding]), but can be
@@ -984,7 +984,7 @@ class PipelineOwner {
         return true;
       }());
       FlutterTimeline.startSync(
-        'LAYOUT',
+        'LAYOUT$_debugRootSuffixForTimelineEventNames',
         arguments: debugTimelineArguments,
       );
     }
@@ -1071,7 +1071,7 @@ class PipelineOwner {
   /// [flushPaint].
   void flushCompositingBits() {
     if (!kReleaseMode) {
-      FlutterTimeline.startSync('UPDATING COMPOSITING BITS');
+      FlutterTimeline.startSync('UPDATING COMPOSITING BITS$_debugRootSuffixForTimelineEventNames');
     }
     _nodesNeedingCompositingBitsUpdate.sort((RenderObject a, RenderObject b) => a.depth - b.depth);
     for (final RenderObject node in _nodesNeedingCompositingBitsUpdate) {
@@ -1120,7 +1120,7 @@ class PipelineOwner {
         return true;
       }());
       FlutterTimeline.startSync(
-        'PAINT',
+        'PAINT$_debugRootSuffixForTimelineEventNames',
         arguments: debugTimelineArguments,
       );
     }
@@ -1247,7 +1247,7 @@ class PipelineOwner {
       return;
     }
     if (!kReleaseMode) {
-      FlutterTimeline.startSync('SEMANTICS');
+      FlutterTimeline.startSync('SEMANTICS$_debugRootSuffixForTimelineEventNames');
     }
     assert(_semanticsOwner != null);
     assert(() {
@@ -1279,6 +1279,20 @@ class PipelineOwner {
     }
   }
 
+  @override
+  List<DiagnosticsNode> debugDescribeChildren() {
+    return <DiagnosticsNode>[
+      for (final PipelineOwner child in _children)
+        child.toDiagnosticsNode(),
+    ];
+  }
+
+  @override
+  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+    super.debugFillProperties(properties);
+    properties.add(DiagnosticsProperty<RenderObject>('rootNode', rootNode, defaultValue: null));
+  }
+
   // TREE MANAGEMENT
 
   final Set<PipelineOwner> _children = <PipelineOwner>{};
@@ -1290,6 +1304,8 @@ class PipelineOwner {
     return true;
   }
 
+  String get _debugRootSuffixForTimelineEventNames => _debugParent == null ? ' (root)' : '';
+
   /// Mark this [PipelineOwner] as attached to the given [PipelineManifold].
   ///
   /// Typically, this is only called directly on the root [PipelineOwner].
@@ -1315,7 +1331,9 @@ class PipelineOwner {
     assert(_manifold != null);
     _manifold!.removeListener(_updateSemanticsOwner);
     _manifold = null;
-    _updateSemanticsOwner();
+    // Not updating the semantics owner here to not disrupt any of its clients
+    // in case we get re-attached. If necessary, semantics owner will be updated
+    // in "attach", or disposed in "dispose", if not reattached.
 
     for (final PipelineOwner child in _children) {
       child.detach();
@@ -1351,7 +1369,9 @@ class PipelineOwner {
     assert(!_children.contains(child));
     assert(_debugAllowChildListModifications, 'Cannot modify child list after layout.');
     _children.add(child);
-    assert(_debugSetParent(child, this));
+    if (!kReleaseMode) {
+      _debugSetParent(child, this);
+    }
     if (_manifold != null) {
       child.attach(_manifold!);
     }
@@ -1369,7 +1389,9 @@ class PipelineOwner {
     assert(_children.contains(child));
     assert(_debugAllowChildListModifications, 'Cannot modify child list after layout.');
     _children.remove(child);
-    assert(_debugSetParent(child, null));
+    if (!kReleaseMode) {
+      _debugSetParent(child, null);
+    }
     if (_manifold != null) {
       child.detach();
     }
@@ -1384,6 +1406,26 @@ class PipelineOwner {
   void visitChildren(PipelineOwnerVisitor visitor) {
     _children.forEach(visitor);
   }
+
+  /// Release any resources held by this pipeline owner.
+  ///
+  /// Prior to calling this method the pipeline owner must be removed from the
+  /// pipeline owner tree, i.e. it must have neither a parent nor any children
+  /// (see [dropChild]). It also must be [detach]ed from any [PipelineManifold].
+  ///
+  /// The object is no longer usable after calling dispose.
+  void dispose() {
+    assert(_children.isEmpty);
+    assert(rootNode == null);
+    assert(_manifold == null);
+    assert(_debugParent == null);
+    _semanticsOwner?.dispose();
+    _semanticsOwner = null;
+    _nodesNeedingLayout.clear();
+    _nodesNeedingCompositingBitsUpdate.clear();
+    _nodesNeedingPaint.clear();
+    _nodesNeedingSemantics.clear();
+  }
 }
 
 /// Signature for the callback to [PipelineOwner.visitChildren].
@@ -3919,7 +3961,6 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
 /// This mixin is typically used to implement render objects created
 /// in a [SingleChildRenderObjectWidget].
 mixin RenderObjectWithChildMixin<ChildType extends RenderObject> on RenderObject {
-
   /// Checks whether the given render object has the correct [runtimeType] to be
   /// a child of this render object.
   ///

packages/flutter/lib/src/rendering/view.dart

@@ -67,10 +67,14 @@ class RenderView extends RenderObject with RenderObjectWithChildMixin<RenderBox>
   ///
   /// Typically created by the binding (e.g., [RendererBinding]).
   ///
-  /// The [configuration] must not be null.
+  /// Providing a [configuration] is optional, but a configuration must be set
+  /// before calling [prepareInitialFrame]. This decouples creating the
+  /// [RenderView] object from configuring it. Typically, the object is created
+  /// by the [View] widget and configured by the [RendererBinding] when the
+  /// [RenderView] is registered with it by the [View] widget.
   RenderView({
     RenderBox? child,
-    required ViewConfiguration configuration,
+    ViewConfiguration? configuration,
     required ui.FlutterView view,
   }) : _configuration = configuration,
        _view = view {
@@ -82,26 +86,39 @@ class RenderView extends RenderObject with RenderObjectWithChildMixin<RenderBox>
   Size _size = Size.zero;
 
   /// The constraints used for the root layout.
-  ViewConfiguration get configuration => _configuration;
-  ViewConfiguration _configuration;
-
-  /// The configuration is initially set by the [configuration] argument
-  /// passed to the constructor.
   ///
-  /// Always call [prepareInitialFrame] before changing the configuration.
+  /// Typically, this configuration is set by the [RendererBinding], when the
+  /// [RenderView] is registered with it. It will also update the configuration
+  /// if necessary. Therefore, if used in conjunction with the [RendererBinding]
+  /// this property must not be set manually as the [RendererBinding] will just
+  /// override it.
+  ///
+  /// For tests that want to change the size of the view, set
+  /// [TestFlutterView.physicalSize] on the appropriate [TestFlutterView]
+  /// (typically [WidgetTester.view]) instead of setting a configuration
+  /// directly on the [RenderView].
+  ViewConfiguration get configuration => _configuration!;
+  ViewConfiguration? _configuration;
   set configuration(ViewConfiguration value) {
-    if (configuration == value) {
+    if (_configuration == value) {
       return;
     }
-    final ViewConfiguration oldConfiguration = _configuration;
+    final ViewConfiguration? oldConfiguration = _configuration;
     _configuration = value;
-    if (oldConfiguration.toMatrix() != _configuration.toMatrix()) {
+    if (_rootTransform == null) {
+      // [prepareInitialFrame] has not been called yet, nothing to do for now.
+      return;
+    }
+    if (oldConfiguration?.toMatrix() != configuration.toMatrix()) {
       replaceRootLayer(_updateMatricesAndCreateNewRootLayer());
     }
     assert(_rootTransform != null);
     markNeedsLayout();
   }
 
+  /// Whether a [configuration] has been set.
+  bool get hasConfiguration => _configuration != null;
+
   /// The [FlutterView] into which this [RenderView] will render.
   ui.FlutterView get flutterView => _view;
   final ui.FlutterView _view;

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

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/rendering.dart';
+
+import 'framework.dart';
+
+/// A bridge from a [RenderObject] to an [Element] tree.
+///
+/// The given container is the [RenderObject] that the [Element] tree should be
+/// inserted into. It must be a [RenderObject] that implements the
+/// [RenderObjectWithChildMixin] protocol. The type argument `T` is the kind of
+/// [RenderObject] that the container expects as its child.
+///
+/// The [RenderObjectToWidgetAdapter] is an alternative to [RootWidget] for
+/// bootstrapping an element tree. Unlike [RootWidget] it requires the
+/// existence of a render tree (the [container]) to attach the element tree to.
+class RenderObjectToWidgetAdapter<T extends RenderObject> extends RenderObjectWidget {
+  /// Creates a bridge from a [RenderObject] to an [Element] tree.
+  RenderObjectToWidgetAdapter({
+    this.child,
+    required this.container,
+    this.debugShortDescription,
+  }) : super(key: GlobalObjectKey(container));
+
+  /// The widget below this widget in the tree.
+  ///
+  /// {@macro flutter.widgets.ProxyWidget.child}
+  final Widget? child;
+
+  /// The [RenderObject] that is the parent of the [Element] created by this widget.
+  final RenderObjectWithChildMixin<T> container;
+
+  /// A short description of this widget used by debugging aids.
+  final String? debugShortDescription;
+
+  @override
+  RenderObjectToWidgetElement<T> createElement() => RenderObjectToWidgetElement<T>(this);
+
+  @override
+  RenderObjectWithChildMixin<T> createRenderObject(BuildContext context) => container;
+
+  @override
+  void updateRenderObject(BuildContext context, RenderObject renderObject) { }
+
+  /// Inflate this widget and actually set the resulting [RenderObject] as the
+  /// child of [container].
+  ///
+  /// If `element` is null, this function will create a new element. Otherwise,
+  /// the given element will have an update scheduled to switch to this widget.
+  RenderObjectToWidgetElement<T> attachToRenderTree(BuildOwner owner, [ RenderObjectToWidgetElement<T>? element ]) {
+    if (element == null) {
+      owner.lockState(() {
+        element = createElement();
+        assert(element != null);
+        element!.assignOwner(owner);
+      });
+      owner.buildScope(element!, () {
+        element!.mount(null, null);
+      });
+    } else {
+      element._newWidget = this;
+      element.markNeedsBuild();
+    }
+    return element!;
+  }
+
+  @override
+  String toStringShort() => debugShortDescription ?? super.toStringShort();
+}
+
+/// The root of an element tree that is hosted by a [RenderObject].
+///
+/// This element class is the instantiation of a [RenderObjectToWidgetAdapter]
+/// widget. It can be used only as the root of an [Element] tree (it cannot be
+/// mounted into another [Element]; it's parent must be null).
+///
+/// In typical usage, it will be instantiated for a [RenderObjectToWidgetAdapter]
+/// whose container is the [RenderView].
+class RenderObjectToWidgetElement<T extends RenderObject> extends RenderTreeRootElement with RootElementMixin {
+  /// Creates an element that is hosted by a [RenderObject].
+  ///
+  /// The [RenderObject] created by this element is not automatically set as a
+  /// child of the hosting [RenderObject]. To actually attach this element to
+  /// the render tree, call [RenderObjectToWidgetAdapter.attachToRenderTree].
+  RenderObjectToWidgetElement(RenderObjectToWidgetAdapter<T> super.widget);
+
+  Element? _child;
+
+  static const Object _rootChildSlot = Object();
+
+  @override
+  void visitChildren(ElementVisitor visitor) {
+    if (_child != null) {
+      visitor(_child!);
+    }
+  }
+
+  @override
+  void forgetChild(Element child) {
+    assert(child == _child);
+    _child = null;
+    super.forgetChild(child);
+  }
+
+  @override
+  void mount(Element? parent, Object? newSlot) {
+    assert(parent == null);
+    super.mount(parent, newSlot);
+    _rebuild();
+    assert(_child != null);
+  }
+
+  @override
+  void update(RenderObjectToWidgetAdapter<T> newWidget) {
+    super.update(newWidget);
+    assert(widget == newWidget);
+    _rebuild();
+  }
+
+  // When we are assigned a new widget, we store it here
+  // until we are ready to update to it.
+  Widget? _newWidget;
+
+  @override
+  void performRebuild() {
+    if (_newWidget != null) {
+      // _newWidget can be null if, for instance, we were rebuilt
+      // due to a reassemble.
+      final Widget newWidget = _newWidget!;
+      _newWidget = null;
+      update(newWidget as RenderObjectToWidgetAdapter<T>);
+    }
+    super.performRebuild();
+    assert(_newWidget == null);
+  }
+
+  @pragma('vm:notify-debugger-on-exception')
+  void _rebuild() {
+    try {
+      _child = updateChild(_child, (widget as RenderObjectToWidgetAdapter<T>).child, _rootChildSlot);
+    } catch (exception, stack) {
+      final FlutterErrorDetails details = FlutterErrorDetails(
+        exception: exception,
+        stack: stack,
+        library: 'widgets library',
+        context: ErrorDescription('attaching to the render tree'),
+      );
+      FlutterError.reportError(details);
+      final Widget error = ErrorWidget.builder(details);
+      _child = updateChild(null, error, _rootChildSlot);
+    }
+  }
+
+  @override
+  RenderObjectWithChildMixin<T> get renderObject => super.renderObject as RenderObjectWithChildMixin<T>;
+
+  @override
+  void insertRenderObjectChild(RenderObject child, Object? slot) {
+    assert(slot == _rootChildSlot);
+    assert(renderObject.debugValidateChild(child));
+    renderObject.child = child as T;
+  }
+
+  @override
+  void moveRenderObjectChild(RenderObject child, Object? oldSlot, Object? newSlot) {
+    assert(false);
+  }
+
+  @override
+  void removeRenderObjectChild(RenderObject child, Object? slot) {
+    assert(renderObject.child == child);
+    renderObject.child = null;
+  }
+}

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

@@ -47,25 +47,31 @@ class SemanticsDebugger extends StatefulWidget {
 }
 
 class _SemanticsDebuggerState extends State<SemanticsDebugger> with WidgetsBindingObserver {
-  late _SemanticsClient _client;
+  _SemanticsClient? _client;
+  PipelineOwner? _pipelineOwner;
 
   @override
   void initState() {
     super.initState();
-    // TODO(abarth): We shouldn't reach out to the WidgetsBinding.instance
-    // static here because we might not be in a tree that's attached to that
-    // binding. Instead, we should find a way to get to the PipelineOwner from
-    // the BuildContext.
-    _client = _SemanticsClient(WidgetsBinding.instance.pipelineOwner)
-      ..addListener(_update);
     WidgetsBinding.instance.addObserver(this);
   }
 
+  @override
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    final PipelineOwner newOwner = View.pipelineOwnerOf(context);
+    if (newOwner != _pipelineOwner) {
+      _client?.dispose();
+      _client = _SemanticsClient(newOwner)
+        ..addListener(_update);
+      _pipelineOwner = newOwner;
+    }
+  }
+
   @override
   void dispose() {
-    _client
-      ..removeListener(_update)
-      ..dispose();
+    _client?.dispose();
     WidgetsBinding.instance.removeObserver(this);
     super.dispose();
   }
@@ -145,19 +151,15 @@ class _SemanticsDebuggerState extends State<SemanticsDebugger> with WidgetsBindi
   }
 
   void _performAction(Offset position, SemanticsAction action) {
-    _pipelineOwner.semanticsOwner?.performActionAt(position, action);
+    _pipelineOwner?.semanticsOwner?.performActionAt(position, action);
   }
 
-  // TODO(abarth): This shouldn't be a static. We should get the pipeline owner
-  // from [context] somehow.
-  PipelineOwner get _pipelineOwner => WidgetsBinding.instance.pipelineOwner;
-
   @override
   Widget build(BuildContext context) {
     return CustomPaint(
       foregroundPainter: _SemanticsDebuggerPainter(
-        _pipelineOwner,
-        _client.generation,
+        _pipelineOwner!,
+        _client!.generation,
         _lastPointerDownLocation, // in physical pixels
         View.of(context).devicePixelRatio,
         widget.labelStyle,

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

@@ -1103,8 +1103,7 @@ mixin WidgetInspectorService {
               renderObject.markNeedsPaint();
               renderObject.visitChildren(markTreeNeedsPaint);
             }
-            final RenderObject root = RendererBinding.instance.renderView;
-            markTreeNeedsPaint(root);
+            RendererBinding.instance.renderViews.forEach(markTreeNeedsPaint);
           } else {
             debugOnProfilePaint = null;
           }

packages/flutter/lib/widgets.dart

@@ -18,6 +18,7 @@ export 'package:vector_math/vector_math_64.dart' show Matrix4;
 export 'foundation.dart' show UniqueKey;
 export 'rendering.dart' show TextSelectionHandleType;
 export 'src/widgets/actions.dart';
+export 'src/widgets/adapter.dart';
 export 'src/widgets/animated_cross_fade.dart';
 export 'src/widgets/animated_scroll_view.dart';
 export 'src/widgets/animated_size.dart';

packages/flutter/test/foundation/service_extensions_test.dart

@@ -117,9 +117,17 @@ Future<Map<String, dynamic>> hasReassemble(Future<Map<String, dynamic>> pendingR
 
 void main() {
   final List<String?> console = <String?>[];
+  late PipelineOwner owner;
 
   setUpAll(() async {
-    binding = TestServiceExtensionsBinding()..scheduleFrame();
+    binding = TestServiceExtensionsBinding();
+    final RenderView view = RenderView(view: binding.platformDispatcher.views.single);
+    owner = PipelineOwner(onSemanticsUpdate: (ui.SemanticsUpdate _) { })
+      ..rootNode = view;
+    binding.rootPipelineOwner.adoptChild(owner);
+    binding.addRenderView(view);
+    view.prepareInitialFrame();
+    binding.scheduleFrame();
     expect(binding.frameScheduled, isTrue);
 
     // We need to test this service extension here because the result is true
@@ -176,6 +184,10 @@ void main() {
 
     expect(console, isEmpty);
     debugPrint = debugPrintThrottled;
+    binding.rootPipelineOwner.dropChild(owner);
+    owner
+      ..rootNode = null
+      ..dispose();
   });
 
   // The following list is alphabetical, one test per extension.
@@ -268,11 +280,13 @@ void main() {
     await binding.doFrame();
     final Map<String, dynamic> result = await binding.testExtension(RenderingServiceExtensions.debugDumpSemanticsTreeInTraversalOrder.name, <String, String>{});
 
-    expect(result, <String, String>{
-      'data': 'Semantics not generated.\n'
-        'For performance reasons, the framework only generates semantics when asked to do so by the platform.\n'
-        'Usually, platforms only ask for semantics when assistive technologies (like screen readers) are running.\n'
-        'To generate semantics, try turning on an assistive technology (like VoiceOver or TalkBack) on your device.'
+    expect(result, <String, Object>{
+      'data': matches(
+        r'Semantics not generated for RenderView#[0-9a-f]{5}\.\n'
+        r'For performance reasons, the framework only generates semantics when asked to do so by the platform.\n'
+        r'Usually, platforms only ask for semantics when assistive technologies \(like screen readers\) are running.\n'
+        r'To generate semantics, try turning on an assistive technology \(like VoiceOver or TalkBack\) on your device.'
+      )
     });
   });
 
@@ -280,11 +294,13 @@ void main() {
     await binding.doFrame();
     final Map<String, dynamic> result = await binding.testExtension(RenderingServiceExtensions.debugDumpSemanticsTreeInInverseHitTestOrder.name, <String, String>{});
 
-    expect(result, <String, String>{
-      'data': 'Semantics not generated.\n'
-        'For performance reasons, the framework only generates semantics when asked to do so by the platform.\n'
-        'Usually, platforms only ask for semantics when assistive technologies (like screen readers) are running.\n'
-        'To generate semantics, try turning on an assistive technology (like VoiceOver or TalkBack) on your device.'
+    expect(result, <String, Object>{
+      'data': matches(
+        r'Semantics not generated for RenderView#[0-9a-f]{5}\.\n'
+        r'For performance reasons, the framework only generates semantics when asked to do so by the platform.\n'
+        r'Usually, platforms only ask for semantics when assistive technologies \(like screen readers\) are running.\n'
+        r'To generate semantics, try turning on an assistive technology \(like VoiceOver or TalkBack\) on your device.'
+      )
     });
   });
 

packages/flutter/test/rendering/binding_pipeline_manifold_test.dart

@@ -13,20 +13,20 @@ void main() {
 
   tearDown(() {
     final List<PipelineOwner> children = <PipelineOwner>[];
-    RendererBinding.instance.pipelineOwner.visitChildren((PipelineOwner child) {
+    RendererBinding.instance.rootPipelineOwner.visitChildren((PipelineOwner child) {
       children.add(child);
     });
-    children.forEach(RendererBinding.instance.pipelineOwner.dropChild);
+    children.forEach(RendererBinding.instance.rootPipelineOwner.dropChild);
   });
 
   test("BindingPipelineManifold notifies binding if render object managed by binding's PipelineOwner tree needs visual update", () {
     final PipelineOwner child = PipelineOwner();
-    RendererBinding.instance.pipelineOwner.adoptChild(child);
+    RendererBinding.instance.rootPipelineOwner.adoptChild(child);
 
     final RenderObject renderObject = TestRenderObject();
     child.rootNode = renderObject;
     renderObject.scheduleInitialLayout();
-    RendererBinding.instance.pipelineOwner.flushLayout();
+    RendererBinding.instance.rootPipelineOwner.flushLayout();
 
     MyTestRenderingFlutterBinding.instance.ensureVisualUpdateCount = 0;
     renderObject.markNeedsLayout();
@@ -37,20 +37,20 @@ void main() {
     final PipelineOwner child = PipelineOwner(
       onSemanticsUpdate: (_) { },
     );
-    RendererBinding.instance.pipelineOwner.adoptChild(child);
+    RendererBinding.instance.rootPipelineOwner.adoptChild(child);
 
     expect(child.semanticsOwner, isNull);
-    expect(RendererBinding.instance.pipelineOwner.semanticsOwner, isNull);
+    expect(RendererBinding.instance.rootPipelineOwner.semanticsOwner, isNull);
 
     final SemanticsHandle handle = SemanticsBinding.instance.ensureSemantics();
 
     expect(child.semanticsOwner, isNotNull);
-    expect(RendererBinding.instance.pipelineOwner.semanticsOwner, isNotNull);
+    expect(RendererBinding.instance.rootPipelineOwner.semanticsOwner, isNotNull);
 
     handle.dispose();
 
     expect(child.semanticsOwner, isNull);
-    expect(RendererBinding.instance.pipelineOwner.semanticsOwner, isNull);
+    expect(RendererBinding.instance.rootPipelineOwner.semanticsOwner, isNull);
   });
 }
 

packages/flutter/test/rendering/binding_test.dart

@@ -10,29 +10,48 @@ import 'package:flutter_test/flutter_test.dart';
 void main() {
   WidgetsFlutterBinding.ensureInitialized();
 
-  test('handleMetricsChanged does not scheduleForcedFrame unless there is a child to the renderView', () async {
+  test('handleMetricsChanged does not scheduleForcedFrame unless there a registered renderView with a child', () async {
     expect(SchedulerBinding.instance.hasScheduledFrame, false);
     RendererBinding.instance.handleMetricsChanged();
     expect(SchedulerBinding.instance.hasScheduledFrame, false);
 
+    RendererBinding.instance.addRenderView(RendererBinding.instance.renderView);
+    RendererBinding.instance.handleMetricsChanged();
+    expect(SchedulerBinding.instance.hasScheduledFrame, false);
+
     RendererBinding.instance.renderView.child = RenderLimitedBox();
     RendererBinding.instance.handleMetricsChanged();
     expect(SchedulerBinding.instance.hasScheduledFrame, true);
+
+    RendererBinding.instance.removeRenderView(RendererBinding.instance.renderView);
   });
 
   test('debugDumpSemantics prints explanation when semantics are unavailable', () {
+    RendererBinding.instance.addRenderView(RendererBinding.instance.renderView);
     final List<String?> log = <String?>[];
     debugPrint = (String? message, {int? wrapWidth}) {
       log.add(message);
     };
     debugDumpSemanticsTree();
     expect(log, hasLength(1));
+    expect(log.single, startsWith('Semantics not generated'));
+    expect(log.single, endsWith(
+      'For performance reasons, the framework only generates semantics when asked to do so by the platform.\n'
+      'Usually, platforms only ask for semantics when assistive technologies (like screen readers) are running.\n'
+      'To generate semantics, try turning on an assistive technology (like VoiceOver or TalkBack) on your device.'
+    ));
+    RendererBinding.instance.removeRenderView(RendererBinding.instance.renderView);
+  });
+
+  test('root pipeline owner cannot manage root node', () {
+    final RenderObject rootNode = RenderProxyBox();
     expect(
-      log.single,
-      'Semantics not generated.\n'
-        'For performance reasons, the framework only generates semantics when asked to do so by the platform.\n'
-        'Usually, platforms only ask for semantics when assistive technologies (like screen readers) are running.\n'
-        'To generate semantics, try turning on an assistive technology (like VoiceOver or TalkBack) on your device.'
+      () => RendererBinding.instance.rootPipelineOwner.rootNode = rootNode,
+      throwsA(isFlutterError.having(
+        (FlutterError e) => e.message,
+        'message',
+        contains('Cannot set a rootNode on the default root pipeline owner.'),
+      )),
     );
   });
 }

packages/flutter/test/rendering/mouse_tracker_test_utils.dart

@@ -32,8 +32,21 @@ class TestMouseTrackerFlutterBinding extends BindingBase
     postFrameCallbacks = <void Function(Duration)>[];
   }
 
+  late final RenderView _renderView = RenderView(
+    view: platformDispatcher.implicitView!,
+  );
+
+  late final PipelineOwner _pipelineOwner = PipelineOwner(
+    onSemanticsUpdate: (ui.SemanticsUpdate _) { assert(false); },
+  );
+
   void setHitTest(BoxHitTest hitTest) {
-    renderView.child = _TestHitTester(hitTest);
+    if (_pipelineOwner.rootNode == null) {
+      _pipelineOwner.rootNode = _renderView;
+      rootPipelineOwner.adoptChild(_pipelineOwner);
+      addRenderView(_renderView);
+    }
+    _renderView.child = _TestHitTester(hitTest);
   }
 
   SchedulerPhase? _overridePhase;

packages/flutter/test/rendering/multi_view_binding_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// 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/rendering.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  final RendererBinding binding = RenderingFlutterBinding.ensureInitialized();
+
+  test('Adding/removing renderviews updates renderViews getter', () {
+    final FlutterView flutterView = FakeFlutterView();
+    final RenderView view = RenderView(view: flutterView);
+
+    expect(binding.renderViews, isEmpty);
+    binding.addRenderView(view);
+    expect(binding.renderViews, contains(view));
+    expect(view.configuration.devicePixelRatio, flutterView.devicePixelRatio);
+    expect(view.configuration.size, flutterView.physicalSize / flutterView.devicePixelRatio);
+
+    binding.removeRenderView(view);
+    expect(binding.renderViews, isEmpty);
+  });
+
+  test('illegal add/remove renderviews', () {
+    final FlutterView flutterView = FakeFlutterView();
+    final RenderView view1 = RenderView(view: flutterView);
+    final RenderView view2 = RenderView(view: flutterView);
+    final RenderView view3 = RenderView(view: FakeFlutterView(viewId: 200));
+
+    expect(binding.renderViews, isEmpty);
+    binding.addRenderView(view1);
+    expect(binding.renderViews, contains(view1));
+
+    expect(() => binding.addRenderView(view1), throwsAssertionError);
+    expect(() => binding.addRenderView(view2), throwsAssertionError);
+    expect(() => binding.removeRenderView(view2), throwsAssertionError);
+    expect(() => binding.removeRenderView(view3), throwsAssertionError);
+
+    expect(binding.renderViews, contains(view1));
+    binding.removeRenderView(view1);
+    expect(binding.renderViews, isEmpty);
+    expect(() => binding.removeRenderView(view1), throwsAssertionError);
+    expect(() => binding.removeRenderView(view2), throwsAssertionError);
+  });
+
+  test('changing metrics updates configuration', () {
+    final FakeFlutterView flutterView = FakeFlutterView();
+    final RenderView view = RenderView(view: flutterView);
+    binding.addRenderView(view);
+    expect(view.configuration.devicePixelRatio, 2.5);
+    expect(view.configuration.size, const Size(160.0, 240.0));
+
+    flutterView.devicePixelRatio = 3.0;
+    flutterView.physicalSize = const Size(300, 300);
+    binding.handleMetricsChanged();
+    expect(view.configuration.devicePixelRatio, 3.0);
+    expect(view.configuration.size, const Size(100.0, 100.0));
+
+    binding.removeRenderView(view);
+  });
+
+  test('semantics actions are performed on the right view', () {
+    final FakeFlutterView flutterView1 = FakeFlutterView(viewId: 1);
+    final FakeFlutterView flutterView2 = FakeFlutterView(viewId: 2);
+    final RenderView renderView1 = RenderView(view: flutterView1);
+    final RenderView renderView2 = RenderView(view: flutterView2);
+    final PipelineOwnerSpy owner1 = PipelineOwnerSpy()
+      ..rootNode = renderView1;
+    final PipelineOwnerSpy owner2 = PipelineOwnerSpy()
+      ..rootNode = renderView2;
+
+    binding.addRenderView(renderView1);
+    binding.addRenderView(renderView2);
+
+    binding.performSemanticsAction(
+      const SemanticsActionEvent(type: SemanticsAction.copy, viewId: 1, nodeId: 11),
+    );
+    expect(owner1.semanticsOwner.performedActions.single, (11, SemanticsAction.copy, null));
+    expect(owner2.semanticsOwner.performedActions, isEmpty);
+    owner1.semanticsOwner.performedActions.clear();
+
+    binding.performSemanticsAction(
+      const SemanticsActionEvent(type: SemanticsAction.tap, viewId: 2, nodeId: 22),
+    );
+    expect(owner1.semanticsOwner.performedActions, isEmpty);
+    expect(owner2.semanticsOwner.performedActions.single, (22, SemanticsAction.tap, null));
+    owner2.semanticsOwner.performedActions.clear();
+
+    binding.performSemanticsAction(
+      const SemanticsActionEvent(type: SemanticsAction.tap, viewId: 3, nodeId: 22),
+    );
+    expect(owner1.semanticsOwner.performedActions, isEmpty);
+    expect(owner2.semanticsOwner.performedActions, isEmpty);
+
+    binding.removeRenderView(renderView1);
+    binding.removeRenderView(renderView2);
+  });
+
+  test('all registered renderviews are asked to composite frame', () {
+    final FakeFlutterView flutterView1 = FakeFlutterView(viewId: 1);
+    final FakeFlutterView flutterView2 = FakeFlutterView(viewId: 2);
+    final RenderView renderView1 = RenderView(view: flutterView1);
+    final RenderView renderView2 = RenderView(view: flutterView2);
+    final PipelineOwner owner1 = PipelineOwner()..rootNode = renderView1;
+    final PipelineOwner owner2 = PipelineOwner()..rootNode = renderView2;
+    binding.rootPipelineOwner.adoptChild(owner1);
+    binding.rootPipelineOwner.adoptChild(owner2);
+    binding.addRenderView(renderView1);
+    binding.addRenderView(renderView2);
+    renderView1.prepareInitialFrame();
+    renderView2.prepareInitialFrame();
+
+    expect(flutterView1.renderedScenes, isEmpty);
+    expect(flutterView2.renderedScenes, isEmpty);
+
+    binding.handleBeginFrame(Duration.zero);
+    binding.handleDrawFrame();
+
+    expect(flutterView1.renderedScenes, hasLength(1));
+    expect(flutterView2.renderedScenes, hasLength(1));
+
+    binding.removeRenderView(renderView1);
+
+    binding.handleBeginFrame(Duration.zero);
+    binding.handleDrawFrame();
+
+    expect(flutterView1.renderedScenes, hasLength(1));
+    expect(flutterView2.renderedScenes, hasLength(2));
+
+    binding.removeRenderView(renderView2);
+
+    binding.handleBeginFrame(Duration.zero);
+    binding.handleDrawFrame();
+
+    expect(flutterView1.renderedScenes, hasLength(1));
+    expect(flutterView2.renderedScenes, hasLength(2));
+  });
+
+  test('hit-testing reaches the right view', () {
+    final FakeFlutterView flutterView1 = FakeFlutterView(viewId: 1);
+    final FakeFlutterView flutterView2 = FakeFlutterView(viewId: 2);
+    final RenderView renderView1 = RenderView(view: flutterView1);
+    final RenderView renderView2 = RenderView(view: flutterView2);
+    binding.addRenderView(renderView1);
+    binding.addRenderView(renderView2);
+
+    HitTestResult result = HitTestResult();
+    binding.hitTestInView(result, Offset.zero, 1);
+    expect(result.path, hasLength(2));
+    expect(result.path.first.target, renderView1);
+    expect(result.path.last.target, binding);
+
+    result = HitTestResult();
+    binding.hitTestInView(result, Offset.zero, 2);
+    expect(result.path, hasLength(2));
+    expect(result.path.first.target, renderView2);
+    expect(result.path.last.target, binding);
+
+    result = HitTestResult();
+    binding.hitTestInView(result, Offset.zero, 3);
+    expect(result.path.single.target, binding);
+
+    binding.removeRenderView(renderView1);
+    binding.removeRenderView(renderView2);
+  });
+}
+
+class FakeFlutterView extends Fake implements FlutterView  {
+  FakeFlutterView({
+    this.viewId = 100,
+    this.devicePixelRatio = 2.5,
+    this.physicalSize = const Size(400,600),
+    this.padding = FakeViewPadding.zero,
+  });
+
+  @override
+  final int viewId;
+  @override
+  double devicePixelRatio;
+  @override
+  Size physicalSize;
+  @override
+  ViewPadding padding;
+
+  List<Scene> renderedScenes = <Scene>[];
+
+  @override
+  void render(Scene scene) {
+    renderedScenes.add(scene);
+  }
+}
+
+class PipelineOwnerSpy extends PipelineOwner {
+  @override
+  final SemanticsOwnerSpy semanticsOwner = SemanticsOwnerSpy();
+}
+
+class SemanticsOwnerSpy extends Fake implements SemanticsOwner {
+  final List<(int, SemanticsAction, Object?)> performedActions = <(int, SemanticsAction, Object?)>[];
+
+  @override
+  void performAction(int id, SemanticsAction action, [ Object? args ]) {
+    performedActions.add((id, action, args));
+  }
+}

packages/flutter/test/rendering/pipeline_owner_tree_test.dart

@@ -678,20 +678,43 @@ void main() {
 
     expect(root.semanticsOwner, isNotNull);
     expect(child.semanticsOwner, isNotNull);
-    expect(childOfChild.semanticsOwner, isNull);
+    expect(childOfChild.semanticsOwner, isNotNull); // Retained in case we get re-attached.
 
     final SemanticsHandle childSemantics = child.ensureSemantics();
     root.dropChild(child);
 
     expect(root.semanticsOwner, isNotNull);
     expect(child.semanticsOwner, isNotNull);
-    expect(childOfChild.semanticsOwner, isNull);
+    expect(childOfChild.semanticsOwner, isNotNull); // Retained in case we get re-attached.
 
     childSemantics.dispose();
 
     expect(root.semanticsOwner, isNotNull);
     expect(child.semanticsOwner, isNull);
-    expect(childOfChild.semanticsOwner, isNull);
+    expect(childOfChild.semanticsOwner, isNotNull);
+
+    manifold.semanticsEnabled = false;
+
+    expect(root.semanticsOwner, isNull);
+    expect(childOfChild.semanticsOwner, isNotNull);
+
+    root.adoptChild(childOfChild);
+    expect(root.semanticsOwner, isNull);
+    expect(childOfChild.semanticsOwner, isNull); // Disposed on re-attachment.
+
+    manifold.semanticsEnabled = true;
+    expect(root.semanticsOwner, isNotNull);
+    expect(childOfChild.semanticsOwner, isNotNull);
+
+    root.dropChild(childOfChild);
+
+    expect(root.semanticsOwner, isNotNull);
+    expect(childOfChild.semanticsOwner, isNotNull);
+
+    childOfChild.dispose();
+
+    expect(root.semanticsOwner, isNotNull);
+    expect(childOfChild.semanticsOwner, isNull); // Disposed on dispose.
   });
 
   test('can adopt/drop children during own layout', () {
@@ -789,6 +812,38 @@ void main() {
     });
     expect(children.single, childOfChild3);
   });
+
+  test('printing pipeline owner tree smoke test', () {
+    final PipelineOwner root = PipelineOwner();
+    final PipelineOwner child1 = PipelineOwner()
+      ..rootNode = FakeRenderView();
+    final PipelineOwner childOfChild1 = PipelineOwner()
+      ..rootNode = FakeRenderView();
+    final PipelineOwner child2 = PipelineOwner()
+      ..rootNode = FakeRenderView();
+    final PipelineOwner childOfChild2 = PipelineOwner()
+      ..rootNode = FakeRenderView();
+
+    root.adoptChild(child1);
+    child1.adoptChild(childOfChild1);
+    root.adoptChild(child2);
+    child2.adoptChild(childOfChild2);
+
+    expect(root.toStringDeep(), equalsIgnoringHashCodes(
+      'PipelineOwner#00000\n'
+      ' ├─PipelineOwner#00000\n'
+      ' │ │ rootNode: FakeRenderView#00000 NEEDS-LAYOUT NEEDS-PAINT\n'
+      ' │ │\n'
+      ' │ └─PipelineOwner#00000\n'
+      ' │     rootNode: FakeRenderView#00000 NEEDS-LAYOUT NEEDS-PAINT\n'
+      ' │\n'
+      ' └─PipelineOwner#00000\n'
+      '   │ rootNode: FakeRenderView#00000 NEEDS-LAYOUT NEEDS-PAINT\n'
+      '   │\n'
+      '   └─PipelineOwner#00000\n'
+      '       rootNode: FakeRenderView#00000 NEEDS-LAYOUT NEEDS-PAINT\n'
+    ));
+  });
 }
 
 class TestPipelineManifold extends ChangeNotifier implements PipelineManifold {
@@ -860,3 +915,5 @@ List<PipelineOwner> _treeWalk(PipelineOwner root) {
   root.visitChildren(visitor);
   return results;
 }
+
+class FakeRenderView extends RenderBox { }

packages/flutter/test/rendering/platform_view_test.dart

@@ -47,10 +47,10 @@ void main() {
         child: platformViewRenderBox,
       );
       int semanticsUpdateCount = 0;
-      final SemanticsHandle semanticsHandle = TestRenderingFlutterBinding.instance.pipelineOwner.ensureSemantics(
-          listener: () {
-            ++semanticsUpdateCount;
-          },
+      final SemanticsHandle semanticsHandle = TestRenderingFlutterBinding.instance.rootPipelineOwner.ensureSemantics(
+        listener: () {
+          ++semanticsUpdateCount;
+        },
       );
       layout(tree, phase: EnginePhase.flushSemantics);
       // Initial semantics update

packages/flutter/test/rendering/rendering_tester.dart

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import 'dart:async';
+import 'dart:ui' show SemanticsUpdate;
 
 import 'package:flutter/foundation.dart';
 import 'package:flutter/gestures.dart';
@@ -43,6 +44,44 @@ class TestRenderingFlutterBinding extends BindingBase with SchedulerBinding, Ser
   void initInstances() {
     super.initInstances();
     _instance = this;
+    // TODO(goderbauer): Create (fake) window if embedder doesn't provide an implicit view.
+    assert(platformDispatcher.implicitView != null);
+    _renderView = initRenderView(platformDispatcher.implicitView!);
+  }
+
+  @override
+  RenderView get renderView => _renderView;
+  late RenderView _renderView;
+
+  @override
+  PipelineOwner get pipelineOwner => rootPipelineOwner;
+
+  /// Creates a [RenderView] object to be the root of the
+  /// [RenderObject] rendering tree, and initializes it so that it
+  /// will be rendered when the next frame is requested.
+  ///
+  /// Called automatically when the binding is created.
+  RenderView initRenderView(FlutterView view) {
+    final RenderView renderView = RenderView(view: view);
+    rootPipelineOwner.rootNode = renderView;
+    addRenderView(renderView);
+    renderView.prepareInitialFrame();
+    return renderView;
+  }
+
+  @override
+  PipelineOwner createRootPipelineOwner() {
+    return PipelineOwner(
+      onSemanticsOwnerCreated: () {
+        renderView.scheduleInitialSemantics();
+      },
+      onSemanticsUpdate: (SemanticsUpdate update) {
+        renderView.updateSemantics(update);
+      },
+      onSemanticsOwnerDisposed: () {
+        renderView.clearSemantics();
+      },
+    );
   }
 
   /// Creates and initializes the binding. This function is
@@ -139,23 +178,25 @@ class TestRenderingFlutterBinding extends BindingBase with SchedulerBinding, Ser
     final FlutterExceptionHandler? oldErrorHandler = FlutterError.onError;
     FlutterError.onError = _errors.add;
     try {
-      pipelineOwner.flushLayout();
+      rootPipelineOwner.flushLayout();
       if (phase == EnginePhase.layout) {
         return;
       }
-      pipelineOwner.flushCompositingBits();
+      rootPipelineOwner.flushCompositingBits();
       if (phase == EnginePhase.compositingBits) {
         return;
       }
-      pipelineOwner.flushPaint();
+      rootPipelineOwner.flushPaint();
       if (phase == EnginePhase.paint) {
         return;
       }
-      renderView.compositeFrame();
+      for (final RenderView renderView in renderViews) {
+        renderView.compositeFrame();
+      }
       if (phase == EnginePhase.composite) {
         return;
       }
-      pipelineOwner.flushSemantics();
+      rootPipelineOwner.flushSemantics();
       if (phase == EnginePhase.flushSemantics) {
         return;
       }

packages/flutter/test/rendering/view_test.dart

@@ -122,6 +122,16 @@ void main() {
       isNot(paintsGreenRect),
     );
   });
+
+  test('Config can be set and changed after instantiation without calling prepareInitialFrame first', () {
+    final RenderView view = RenderView(
+      view: RendererBinding.instance.platformDispatcher.views.single,
+    );
+    view.configuration = const ViewConfiguration(size: Size(100, 200), devicePixelRatio: 3.0);
+    view.configuration = const ViewConfiguration(size: Size(200, 300), devicePixelRatio: 2.0);
+    PipelineOwner().rootNode = view;
+    view.prepareInitialFrame();
+  });
 }
 
 const Color orange = Color(0xFFFF9000);

packages/flutter/test/scheduler/benchmarks_test.dart

@@ -42,7 +42,7 @@ void main() {
     await benchmarkWidgets(
       (WidgetTester tester) async {
         const Key root = Key('root');
-        binding.attachRootWidget(Container(key: root));
+        binding.attachRootWidget(binding.wrapWithDefaultView(Container(key: root)));
         await tester.pump();
 
         expect(binding.framesBegun, greaterThan(0));

packages/flutter/test/widgets/custom_multi_child_layout_test.dart

@@ -373,8 +373,9 @@ void main() {
           '   The following child has no ID: RenderConstrainedBox#00000 NEEDS-LAYOUT NEEDS-PAINT:\n'
           '     creator: ConstrainedBox ← Container ← LayoutWithMissingId ←\n'
           '       CustomMultiChildLayout ← Center ← MediaQuery ←\n'
-          '       _MediaQueryFromView ← _ViewScope ← View-[GlobalObjectKey\n'
-          '       TestFlutterView#00000] ← [root]\n'
+          '       _MediaQueryFromView ← _PipelineOwnerScope ← _ViewScope ←\n'
+          '       _RawView-[_DeprecatedRawViewKey TestFlutterView#00000] ← View ←\n'
+          '       [root]\n'
           '     parentData: offset=Offset(0.0, 0.0); id=null\n'
           '     constraints: MISSING\n'
           '     size: MISSING\n'

packages/flutter/test/widgets/debug_test.dart

@@ -144,7 +144,10 @@ void main() {
               ),
             );
           }
-          return Container();
+          return View(
+            view: tester.view,
+            child: const SizedBox(),
+          );
         },
       ),
     );

packages/flutter/test/widgets/focus_manager_test.dart

@@ -1227,8 +1227,9 @@ void main() {
           'FocusManager#00000\n'
           ' │ primaryFocus: FocusNode#00000(Child 4 [PRIMARY FOCUS])\n'
           ' │ primaryFocusCreator: Container-[GlobalKey#00000] ← MediaQuery ←\n'
-          ' │   _MediaQueryFromView ← _ViewScope ← View-[GlobalObjectKey\n'
-          ' │   TestFlutterView#00000] ← [root]\n'
+          ' │   _MediaQueryFromView ← _PipelineOwnerScope ← _ViewScope ←\n'
+          ' │   _RawView-[_DeprecatedRawViewKey TestFlutterView#00000] ← View ←\n'
+          ' │   [root]\n'
           ' │\n'
           ' └─rootScope: FocusScopeNode#00000(Root Focus Scope [IN FOCUS PATH])\n'
           '   │ IN FOCUS PATH\n'

packages/flutter/test/widgets/init_state_test.dart

@@ -30,7 +30,7 @@ class TestWidgetState extends State<TestWidget> {
 void main() {
   testWidgets('initState() is called when we are in the tree', (WidgetTester tester) async {
     await tester.pumpWidget(const Parent(child: TestWidget()));
-    expect(ancestors, containsAllInOrder(<String>['Parent', 'View', 'RenderObjectToWidgetAdapter<RenderBox>']));
+    expect(ancestors, containsAllInOrder(<String>['Parent', 'View', 'RootWidget']));
   });
 }
 

packages/flutter/test/widgets/keep_alive_test.dart

@@ -205,7 +205,7 @@ void main() {
     );
     // The important lines below are the ones marked with "<----"
     expect(tester.binding.renderView.toStringDeep(minLevel: DiagnosticLevel.info), equalsIgnoringHashCodes(
-      'RenderView#00000\n'
+      '_ReusableRenderView#00000\n'
       ' │ debug mode enabled - ${Platform.operatingSystem}\n'
       ' │ view size: Size(2400.0, 1800.0) (in physical pixels)\n'
       ' │ device pixel ratio: 3.0 (physical pixels per logical pixel)\n'
@@ -379,7 +379,7 @@ void main() {
     await tester.drag(find.byType(ListView), const Offset(0.0, -1000.0));
     await tester.pump();
     expect(tester.binding.renderView.toStringDeep(minLevel: DiagnosticLevel.info), equalsIgnoringHashCodes(
-      'RenderView#00000\n'
+      '_ReusableRenderView#00000\n'
       ' │ debug mode enabled - ${Platform.operatingSystem}\n'
       ' │ view size: Size(2400.0, 1800.0) (in physical pixels)\n'
       ' │ device pixel ratio: 3.0 (physical pixels per logical pixel)\n'

packages/flutter/test/widgets/media_query_test.dart

@@ -44,26 +44,25 @@ class _MediaQueryAspectVariant extends TestVariant<_MediaQueryAspectCase> {
 
 void main() {
   testWidgets('MediaQuery does not have a default', (WidgetTester tester) async {
-    bool tested = false;
+    late final FlutterError error;
     // Cannot use tester.pumpWidget here because it wraps the widget in a View,
     // which introduces a MediaQuery ancestor.
     await pumpWidgetWithoutViewWrapper(
       tester: tester,
       widget: Builder(
         builder: (BuildContext context) {
-          tested = true;
-          MediaQuery.of(context); // should throw
-          return Container();
+          try {
+            MediaQuery.of(context);
+          } on FlutterError catch (e) {
+            error = e;
+          }
+          return View(
+            view: tester.view,
+            child: const SizedBox(),
+          );
         },
       ),
     );
-    expect(tested, isTrue);
-    final dynamic exception = tester.takeException();
-    expect(exception, isNotNull);
-    expect(exception ,isFlutterError);
-    final FlutterError error = exception as FlutterError;
-    expect(error.diagnostics.length, 5);
-    expect(error.diagnostics.last, isA<ErrorHint>());
     expect(
       error.toStringDeep(),
       startsWith(
@@ -119,7 +118,10 @@ void main() {
           final MediaQueryData? data = MediaQuery.maybeOf(context);
           expect(data, isNull);
           tested = true;
-          return Container();
+          return View(
+            view: tester.view,
+            child: const SizedBox(),
+          );
         },
       ),
     );
@@ -295,7 +297,10 @@ void main() {
               child: Builder(
                 builder: (BuildContext context) {
                   data = MediaQuery.of(context);
-                  return const Placeholder();
+                  return View(
+                    view: tester.view,
+                    child: const SizedBox(),
+                  );
                 },
               )
           );
@@ -348,7 +353,10 @@ void main() {
                 builder: (BuildContext context) {
                   rebuildCount++;
                   data = MediaQuery.of(context);
-                  return const Placeholder();
+                  return View(
+                    view: tester.view,
+                    child: const SizedBox(),
+                  );
                 },
               ),
           );

packages/flutter/test/widgets/multi_view_binding_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/material.dart';
+import 'package:flutter/rendering.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  testWidgets('runApp uses deprecated pipelineOwner and renderView', (WidgetTester tester) async {
+    runApp(const SizedBox());
+    final RenderObject renderObject = tester.renderObject(find.byType(SizedBox));
+
+    RenderObject parent = renderObject;
+    while (parent.parent != null) {
+      parent = parent.parent!;
+    }
+    expect(parent, isA<RenderView>());
+    expect(parent, equals(tester.binding.renderView));
+
+    expect(renderObject.owner, equals(tester.binding.pipelineOwner));
+  });
+
+  testWidgets('can manually attach RootWidget to build owner', (WidgetTester tester) async {
+    expect(find.byType(ColoredBox), findsNothing);
+
+    final RootWidget rootWidget = RootWidget(
+      child: View(
+        view: tester.view,
+        child: const ColoredBox(color: Colors.orange),
+      ),
+    );
+    tester.binding.attachToBuildOwner(rootWidget);
+    await tester.pump();
+    expect(find.byType(ColoredBox), findsOneWidget);
+    expect(tester.binding.rootElement!.widget, equals(rootWidget));
+    expect(tester.element(find.byType(ColoredBox)).owner, equals(tester.binding.buildOwner));
+  });
+}

packages/flutter/test/widgets/multi_view_tree_updates_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// 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/material.dart';
+import 'package:flutter/rendering.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  testWidgets('Widgets in view update as expected', (WidgetTester tester) async {
+    final Widget widget = View(
+      view: tester.view,
+      child: const TestWidget(),
+    );
+
+    await pumpWidgetWithoutViewWrapper(
+      tester: tester,
+      widget: widget,
+    );
+
+    expect(find.text('Hello'), findsOneWidget);
+    expect(tester.renderObject<RenderParagraph>(find.byType(Text)).text.toPlainText(), 'Hello');
+
+    tester.state<TestWidgetState>(find.byType(TestWidget)).text = 'World';
+    await tester.pump();
+    expect(find.text('Hello'), findsNothing);
+    expect(find.text('World'), findsOneWidget);
+    expect(tester.renderObject<RenderParagraph>(find.byType(Text)).text.toPlainText(), 'World');
+
+    await pumpWidgetWithoutViewWrapper(
+      tester: tester,
+      widget: ViewCollection(
+        views: <Widget>[widget],
+      ),
+    );
+    expect(find.text('Hello'), findsNothing);
+    expect(find.text('World'), findsOneWidget);
+    expect(tester.renderObject<RenderParagraph>(find.byType(Text)).text.toPlainText(), 'World');
+
+    tester.state<TestWidgetState>(find.byType(TestWidget)).text = 'FooBar';
+    await pumpWidgetWithoutViewWrapper(
+      tester: tester,
+      widget: widget,
+    );
+    expect(find.text('World'), findsNothing);
+    expect(find.text('FooBar'), findsOneWidget);
+    expect(tester.renderObject<RenderParagraph>(find.byType(Text)).text.toPlainText(), 'FooBar');
+  });
+
+  testWidgets('Views in ViewCollection update as expected', (WidgetTester tester) async {
+    Iterable<String> renderParagraphTexts() {
+      return tester.renderObjectList<RenderParagraph>(find.byType(Text)).map((RenderParagraph r) => r.text.toPlainText());
+    }
+
+    final Key key1 = UniqueKey();
+    final Key key2 = UniqueKey();
+    final Widget view1 = View(
+      view: tester.view,
+      child: TestWidget(key: key1),
+    );
+    final Widget view2 = View(
+      view: FakeView(tester.view),
+      child: TestWidget(key: key2),
+    );
+
+    await pumpWidgetWithoutViewWrapper(
+      tester: tester,
+      widget: ViewCollection(
+        views: <Widget>[view1, view2],
+      ),
+    );
+
+    expect(find.text('Hello'), findsNWidgets(2));
+    expect(renderParagraphTexts(), <String>['Hello', 'Hello']);
+
+    tester.state<TestWidgetState>(find.byKey(key1)).text = 'Guten';
+    tester.state<TestWidgetState>(find.byKey(key2)).text = 'Tag';
+    await tester.pump();
+    expect(find.text('Hello'), findsNothing);
+    expect(find.text('Guten'), findsOneWidget);
+    expect(find.text('Tag'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Guten', 'Tag']);
+
+    tester.state<TestWidgetState>(find.byKey(key2)).text = 'Abend';
+    await tester.pump();
+    expect(find.text('Tag'), findsNothing);
+    expect(find.text('Guten'), findsOneWidget);
+    expect(find.text('Abend'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Guten', 'Abend']);
+
+    tester.state<TestWidgetState>(find.byKey(key2)).text = 'Morgen';
+    await pumpWidgetWithoutViewWrapper(
+      tester: tester,
+      widget: ViewCollection(
+        views: <Widget>[view1, ViewCollection(views: <Widget>[view2])],
+      ),
+    );
+    expect(find.text('Abend'), findsNothing);
+    expect(find.text('Guten'), findsOneWidget);
+    expect(find.text('Morgen'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Guten', 'Morgen']);
+  });
+
+  testWidgets('Views in ViewAnchor update as expected', (WidgetTester tester) async {
+    Iterable<String> renderParagraphTexts() {
+      return tester.renderObjectList<RenderParagraph>(find.byType(Text)).map((RenderParagraph r) => r.text.toPlainText());
+    }
+
+    final Key insideAnchoredViewKey = UniqueKey();
+    final Key outsideAnchoredViewKey = UniqueKey();
+    final Widget view = View(
+      view: FakeView(tester.view),
+      child: TestWidget(key: insideAnchoredViewKey),
+    );
+
+    await tester.pumpWidget(
+      ViewAnchor(
+        view: view,
+        child: TestWidget(key: outsideAnchoredViewKey),
+      ),
+    );
+
+    expect(find.text('Hello'), findsNWidgets(2));
+    expect(renderParagraphTexts(), <String>['Hello', 'Hello']);
+
+    tester.state<TestWidgetState>(find.byKey(outsideAnchoredViewKey)).text = 'Guten';
+    tester.state<TestWidgetState>(find.byKey(insideAnchoredViewKey)).text = 'Tag';
+    await tester.pump();
+    expect(find.text('Hello'), findsNothing);
+    expect(find.text('Guten'), findsOneWidget);
+    expect(find.text('Tag'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Guten', 'Tag']);
+
+    tester.state<TestWidgetState>(find.byKey(insideAnchoredViewKey)).text = 'Abend';
+    await tester.pump();
+    expect(find.text('Tag'), findsNothing);
+    expect(find.text('Guten'), findsOneWidget);
+    expect(find.text('Abend'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Guten', 'Abend']);
+
+    tester.state<TestWidgetState>(find.byKey(outsideAnchoredViewKey)).text = 'Schönen';
+    await tester.pump();
+    expect(find.text('Guten'), findsNothing);
+    expect(find.text('Schönen'), findsOneWidget);
+    expect(find.text('Abend'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Schönen', 'Abend']);
+
+    tester.state<TestWidgetState>(find.byKey(insideAnchoredViewKey)).text = 'Tag';
+    await tester.pumpWidget(
+      ViewAnchor(
+        view: ViewCollection(views: <Widget>[view]),
+        child: TestWidget(key: outsideAnchoredViewKey),
+      ),
+    );
+    await tester.pump();
+    expect(find.text('Abend'), findsNothing);
+    expect(find.text('Schönen'), findsOneWidget);
+    expect(find.text('Tag'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Schönen', 'Tag']);
+
+    tester.state<TestWidgetState>(find.byKey(insideAnchoredViewKey)).text = 'Morgen';
+    await tester.pumpWidget(
+      SizedBox(
+        child: ViewAnchor(
+          view: ViewCollection(views: <Widget>[view]),
+          child: TestWidget(key: outsideAnchoredViewKey),
+        ),
+      ),
+    );
+    await tester.pump();
+    expect(find.text('Schönen'), findsNothing); // The `outsideAnchoredViewKey` is not a global key, its state is lost in the move above.
+    expect(find.text('Tag'), findsNothing);
+    expect(find.text('Hello'), findsOneWidget);
+    expect(find.text('Morgen'), findsOneWidget);
+    expect(renderParagraphTexts(), <String>['Hello', 'Morgen']);
+  });
+}
+
+class TestWidget extends StatefulWidget {
+  const TestWidget({super.key});
+
+  @override
+  State<TestWidget> createState() => TestWidgetState();
+}
+
+class TestWidgetState extends State<TestWidget> {
+  String get text => _text;
+  String _text = 'Hello';
+  set text(String value) {
+    if (_text == value) {
+      return;
+    }
+    setState(() {
+      _text = value;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Text(text, textDirection: TextDirection.ltr);
+  }
+}
+
+Future<void> pumpWidgetWithoutViewWrapper({required WidgetTester tester, required  Widget widget}) {
+  tester.binding.attachRootWidget(widget);
+  tester.binding.scheduleFrame();
+  return tester.binding.pump();
+}
+
+class FakeView extends TestFlutterView{
+  FakeView(FlutterView view, { this.viewId = 100 }) : super(
+    view: view,
+    platformDispatcher: view.platformDispatcher as TestPlatformDispatcher,
+    display: view.display as TestDisplay,
+  );
+
+  @override
+  final int viewId;
+}

packages/flutter/test/widgets/slotted_render_object_widget_test.dart

@@ -222,16 +222,18 @@ void main() {
       equalsIgnoringHashCodes(
         '_RenderDiagonal#00000 relayoutBoundary=up1\n'
         ' │ creator: _Diagonal ← Align ← Directionality ← MediaQuery ←\n'
-        ' │   _MediaQueryFromView ← _ViewScope ← View-[GlobalObjectKey\n'
-        ' │   TestFlutterView#00000] ← [root]\n'
+        ' │   _MediaQueryFromView ← _PipelineOwnerScope ← _ViewScope ←\n'
+        ' │   _RawView-[_DeprecatedRawViewKey TestFlutterView#00000] ← View ←\n'
+        ' │   [root]\n'
         ' │ parentData: offset=Offset(0.0, 0.0) (can use size)\n'
         ' │ constraints: BoxConstraints(0.0<=w<=800.0, 0.0<=h<=600.0)\n'
         ' │ size: Size(190.0, 220.0)\n'
         ' │\n'
         ' ├─topLeft: RenderConstrainedBox#00000 relayoutBoundary=up2\n'
         ' │   creator: SizedBox ← _Diagonal ← Align ← Directionality ←\n'
-        ' │     MediaQuery ← _MediaQueryFromView ← _ViewScope ←\n'
-        ' │     View-[GlobalObjectKey TestFlutterView#00000] ← [root]\n'
+        ' │     MediaQuery ← _MediaQueryFromView ← _PipelineOwnerScope ←\n'
+        ' │     _ViewScope ← _RawView-[_DeprecatedRawViewKey\n'
+        ' │     TestFlutterView#00000] ← View ← [root]\n'
         ' │   parentData: offset=Offset(0.0, 0.0) (can use size)\n'
         ' │   constraints: BoxConstraints(unconstrained)\n'
         ' │   size: Size(80.0, 100.0)\n'
@@ -239,8 +241,9 @@ void main() {
         ' │\n'
         ' └─bottomRight: RenderConstrainedBox#00000 relayoutBoundary=up2\n'
         '     creator: SizedBox ← _Diagonal ← Align ← Directionality ←\n'
-        '       MediaQuery ← _MediaQueryFromView ← _ViewScope ←\n'
-        '       View-[GlobalObjectKey TestFlutterView#00000] ← [root]\n'
+        '       MediaQuery ← _MediaQueryFromView ← _PipelineOwnerScope ←\n'
+        '       _ViewScope ← _RawView-[_DeprecatedRawViewKey\n'
+        '       TestFlutterView#00000] ← View ← [root]\n'
         '     parentData: offset=Offset(80.0, 100.0) (can use size)\n'
         '     constraints: BoxConstraints(unconstrained)\n'
         '     size: Size(110.0, 120.0)\n'

packages/flutter/test/widgets/stateful_component_test.dart

@@ -10,10 +10,9 @@ import 'test_widgets.dart';
 
 void main() {
   testWidgets('Stateful widget smoke test', (WidgetTester tester) async {
-
     void checkTree(BoxDecoration expectedDecoration) {
       final SingleChildRenderObjectElement element = tester.element(
-        find.byElementPredicate((Element element) => element is SingleChildRenderObjectElement),
+        find.byElementPredicate((Element element) => element is SingleChildRenderObjectElement && element.renderObject is! RenderView),
       );
       expect(element, isNotNull);
       expect(element.renderObject, isA<RenderDecoratedBox>());

packages/flutter/test/widgets/widget_inspector_test.dart

@@ -4509,7 +4509,6 @@ class _TestWidgetInspectorService extends TestWidgetInspectorService {
         expect(result['parentData'], isNull);
       });
 
-
       testWidgets('ext.flutter.inspector.getLayoutExplorerNode for RenderView',(WidgetTester tester) async {
         await pumpWidgetForLayoutExplorer(tester);
 
@@ -4530,7 +4529,7 @@ class _TestWidgetInspectorService extends TestWidgetInspectorService {
 
         final Map<String, Object?>? renderObject = result['renderObject'] as Map<String, Object?>?;
         expect(renderObject, isNotNull);
-        expect(renderObject!['description'], startsWith('RenderView'));
+        expect(renderObject!['description'], contains('RenderView'));
 
         expect(result['parentRenderElement'], isNull);
         expect(result['constraints'], isNull);

packages/flutter/test_release/widgets/memory_allocations_test.dart

@@ -55,7 +55,7 @@ class _TestRenderObject extends RenderObject {
   Rect get semanticBounds => throw UnimplementedError();
 }
 
-class _TestElement extends RenderObjectElement with RootElementMixin {
+class _TestElement extends RenderTreeRootElement with RootElementMixin {
   _TestElement(): super(_TestLeafRenderObjectWidget());
 
   void makeInactive() {

packages/flutter_driver/lib/src/common/handler_factory.dart

@@ -187,11 +187,20 @@ mixin CommandHandlerFactory {
   Future<Health> _getHealth(Command command) async => const Health(HealthStatus.ok);
 
   Future<LayerTree> _getLayerTree(Command command) async {
-    return LayerTree(RendererBinding.instance.renderView.debugLayer?.toStringDeep());
+    final String trees = <String>[
+      for (final RenderView renderView in RendererBinding.instance.renderViews)
+        if (renderView.debugLayer != null)
+          renderView.debugLayer!.toStringDeep(),
+    ].join('\n\n');
+    return LayerTree(trees.isNotEmpty ? trees : null);
   }
 
   Future<RenderTree> _getRenderTree(Command command) async {
-    return RenderTree(RendererBinding.instance.renderView.toStringDeep());
+    final String trees = <String>[
+      for (final RenderView renderView in RendererBinding.instance.renderViews)
+        renderView.toStringDeep(),
+    ].join('\n\n');
+    return RenderTree(trees.isNotEmpty ? trees : null);
   }
 
   Future<Result> _enterText(Command command) async {