Revert "fuchsia: Remove dead code / break dependencies (#19396)" (#20302)

This reverts commit 12a3747.

Author: zanderso

flow/layers/child_scene_layer.cc

@@ -4,6 +4,8 @@
 
 #include "flutter/flow/layers/child_scene_layer.h"
 
+#include "flutter/flow/view_holder.h"
+
 namespace flutter {
 
 ChildSceneLayer::ChildSceneLayer(zx_koid_t layer_id,
@@ -17,10 +19,12 @@ ChildSceneLayer::ChildSceneLayer(zx_koid_t layer_id,
 
 void ChildSceneLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "ChildSceneLayer::Preroll");
+  set_needs_system_composite(true);
 
-  context->child_scene_layer_exists_below = true;
   CheckForChildLayerBelow(context);
 
+  context->child_scene_layer_exists_below = true;
+
   // An alpha "hole punch" is required if the frame behind us is not opaque.
   if (!context->is_opaque) {
     set_paint_bounds(
@@ -45,7 +49,15 @@ void ChildSceneLayer::Paint(PaintContext& context) const {
 void ChildSceneLayer::UpdateScene(SceneUpdateContext& context) {
   TRACE_EVENT0("flutter", "ChildSceneLayer::UpdateScene");
   FML_DCHECK(needs_system_composite());
-  context.UpdateView(layer_id_, offset_, size_, hit_testable_);
+
+  Layer::UpdateScene(context);
+
+  auto* view_holder = ViewHolder::FromId(layer_id_);
+  FML_DCHECK(view_holder);
+
+  view_holder->UpdateScene(context, offset_, size_,
+                           SkScalarRoundToInt(context.alphaf() * 255),
+                           hit_testable_);
 }
 
 }  // namespace flutter

flow/layers/container_layer.cc

@@ -4,8 +4,6 @@
 
 #include "flutter/flow/layers/container_layer.h"
 
-#include <optional>
-
 namespace flutter {
 
 ContainerLayer::ContainerLayer() {}
@@ -32,9 +30,6 @@ void ContainerLayer::PrerollChildren(PrerollContext* context,
                                      const SkMatrix& child_matrix,
                                      SkRect* child_paint_bounds) {
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
-  // If there is embedded Fuchsia content in the scene (a ChildSceneLayer),
-  // Layers that appear above the embedded content will be turned into their own
-  // Scenic layers.
   child_layer_exists_below_ = context->child_scene_layer_exists_below;
   context->child_scene_layer_exists_below = false;
 #endif
@@ -103,20 +98,63 @@ void ContainerLayer::UpdateScene(SceneUpdateContext& context) {
 }
 
 void ContainerLayer::UpdateSceneChildren(SceneUpdateContext& context) {
+  auto update_scene_layers = [&] {
+    // Paint all of the layers which need to be drawn into the container.
+    // These may be flattened down to a containing Scenic Frame.
+    for (auto& layer : layers_) {
+      if (layer->needs_system_composite()) {
+        layer->UpdateScene(context);
+      }
+    }
+  };
+
   FML_DCHECK(needs_system_composite());
 
-  std::optional<SceneUpdateContext::Frame> frame;
+  // If there is embedded Fuchsia content in the scene (a ChildSceneLayer),
+  // PhysicalShapeLayers that appear above the embedded content will be turned
+  // into their own Scenic layers.
   if (child_layer_exists_below_) {
-    frame.emplace(
-        context, SkRRect::MakeRect(paint_bounds()), SK_ColorTRANSPARENT,
-        SkScalarRoundToInt(context.alphaf() * 255), "flutter::ContainerLayer");
-    frame->AddPaintLayer(this);
-  }
-
-  for (auto& layer : layers_) {
-    if (layer->needs_system_composite()) {
-      layer->UpdateScene(context);
+    float global_scenic_elevation =
+        context.GetGlobalElevationForNextScenicLayer();
+    float local_scenic_elevation =
+        global_scenic_elevation - context.scenic_elevation();
+    float z_translation = -local_scenic_elevation;
+
+    // Retained rendering: speedup by reusing a retained entity node if
+    // possible. When an entity node is reused, no paint layer is added to the
+    // frame so we won't call PhysicalShapeLayer::Paint.
+    LayerRasterCacheKey key(unique_id(), context.Matrix());
+    if (context.HasRetainedNode(key)) {
+      TRACE_EVENT_INSTANT0("flutter", "retained layer cache hit");
+      scenic::EntityNode* retained_node = context.GetRetainedNode(key);
+      FML_DCHECK(context.top_entity());
+      FML_DCHECK(retained_node->session() == context.session());
+
+      // Re-adjust the elevation.
+      retained_node->SetTranslation(0.f, 0.f, z_translation);
+
+      context.top_entity()->entity_node().AddChild(*retained_node);
+      return;
     }
+
+    TRACE_EVENT_INSTANT0("flutter", "cache miss, creating");
+    // If we can't find an existing retained surface, create one.
+    SceneUpdateContext::Frame frame(
+        context, SkRRect::MakeRect(paint_bounds()), SK_ColorTRANSPARENT,
+        SkScalarRoundToInt(context.alphaf() * 255),
+        "flutter::PhysicalShapeLayer", z_translation, this);
+
+    frame.AddPaintLayer(this);
+
+    // Node: UpdateSceneChildren needs to be called here so that |frame| is
+    // still in scope (and therefore alive) while UpdateSceneChildren is being
+    // called.
+    float scenic_elevation = context.scenic_elevation();
+    context.set_scenic_elevation(scenic_elevation + local_scenic_elevation);
+    update_scene_layers();
+    context.set_scenic_elevation(scenic_elevation);
+  } else {
+    update_scene_layers();
   }
 }
 

flow/layers/fuchsia_layer_unittests.cc

@@ -238,17 +238,57 @@ class MockSession : public fuchsia::ui::scenic::testing::Session_TestBase {
   fuchsia::ui::scenic::SessionListenerPtr listener_;
 };
 
-class MockSessionWrapper : public flutter::SessionWrapper {
+class MockSurfaceProducerSurface
+    : public SceneUpdateContext::SurfaceProducerSurface {
  public:
-  MockSessionWrapper(fuchsia::ui::scenic::SessionPtr session_ptr)
-      : session_(std::move(session_ptr)) {}
-  ~MockSessionWrapper() override = default;
+  MockSurfaceProducerSurface(scenic::Session* session, const SkISize& size)
+      : image_(session, 0, 0, {}), size_(size) {}
 
-  scenic::Session* get() override { return &session_; }
-  void Present() override { session_.Flush(); }
+  size_t AdvanceAndGetAge() override { return 0; }
+
+  bool FlushSessionAcquireAndReleaseEvents() override { return false; }
+
+  bool IsValid() const override { return false; }
+
+  SkISize GetSize() const override { return size_; }
+
+  void SignalWritesFinished(
+      const std::function<void(void)>& on_writes_committed) override {}
+
+  scenic::Image* GetImage() override { return &image_; };
+
+  sk_sp<SkSurface> GetSkiaSurface() const override { return nullptr; };
 
  private:
-  scenic::Session session_;
+  scenic::Image image_;
+  SkISize size_;
+};
+
+class MockSurfaceProducer : public SceneUpdateContext::SurfaceProducer {
+ public:
+  MockSurfaceProducer(scenic::Session* session) : session_(session) {}
+  std::unique_ptr<SceneUpdateContext::SurfaceProducerSurface> ProduceSurface(
+      const SkISize& size,
+      const LayerRasterCacheKey& layer_key,
+      std::unique_ptr<scenic::EntityNode> entity_node) override {
+    return std::make_unique<MockSurfaceProducerSurface>(session_, size);
+  }
+
+  // Query a retained entity node (owned by a retained surface) for retained
+  // rendering.
+  bool HasRetainedNode(const LayerRasterCacheKey& key) const override {
+    return false;
+  }
+
+  scenic::EntityNode* GetRetainedNode(const LayerRasterCacheKey& key) override {
+    return nullptr;
+  }
+
+  void SubmitSurface(std::unique_ptr<SceneUpdateContext::SurfaceProducerSurface>
+                         surface) override {}
+
+ private:
+  scenic::Session* session_;
 };
 
 struct TestContext {
@@ -257,11 +297,12 @@ struct TestContext {
   fml::RefPtr<fml::TaskRunner> task_runner;
 
   // Session.
-  fidl::InterfaceRequest<fuchsia::ui::scenic::SessionListener> listener_request;
   MockSession mock_session;
-  std::unique_ptr<MockSessionWrapper> mock_session_wrapper;
+  fidl::InterfaceRequest<fuchsia::ui::scenic::SessionListener> listener_request;
+  std::unique_ptr<scenic::Session> session;
 
   // SceneUpdateContext.
+  std::unique_ptr<MockSurfaceProducer> mock_surface_producer;
   std::unique_ptr<SceneUpdateContext> scene_update_context;
 
   // PrerollContext.
@@ -283,13 +324,15 @@ std::unique_ptr<TestContext> InitTest() {
   fuchsia::ui::scenic::SessionListenerPtr listener;
   context->listener_request = listener.NewRequest();
   context->mock_session.Bind(session_ptr.NewRequest(), std::move(listener));
-  context->mock_session_wrapper =
-      std::make_unique<MockSessionWrapper>(std::move(session_ptr));
+  context->session = std::make_unique<scenic::Session>(std::move(session_ptr));
 
   // Init SceneUpdateContext.
+  context->mock_surface_producer =
+      std::make_unique<MockSurfaceProducer>(context->session.get());
   context->scene_update_context = std::make_unique<SceneUpdateContext>(
-      "fuchsia_layer_unittest", fuchsia::ui::views::ViewToken(),
-      scenic::ViewRefPair::New(), *(context->mock_session_wrapper));
+      context->session.get(), context->mock_surface_producer.get());
+  context->scene_update_context->set_metrics(
+      fidl::MakeOptional(fuchsia::ui::gfx::Metrics{1.f, 1.f, 1.f}));
 
   // Init PrerollContext.
   context->preroll_context = std::unique_ptr<PrerollContext>(new PrerollContext{
@@ -305,6 +348,7 @@ std::unique_ptr<TestContext> InitTest() {
       context->unused_texture_registry,  // texture registry (not
                                          // supported)
       false,                             // checkerboard_offscreen_layers
+      100.f,                             // maximum depth allowed for rendering
       1.f                                // ratio between logical and physical
   });
 
@@ -558,7 +602,7 @@ TEST_F(FuchsiaLayerTest, DISABLED_PhysicalShapeLayersAndChildSceneLayers) {
   // against the list above.
   root->UpdateScene(*(test_context->scene_update_context));
 
-  test_context->mock_session_wrapper->Present();
+  test_context->session->Flush();
 
   // Run loop until idle, so that the Session receives and processes
   // its method calls.
@@ -740,7 +784,7 @@ TEST_F(FuchsiaLayerTest, DISABLED_OpacityAndTransformLayer) {
   // commands against the list above.
   root->UpdateScene(*(test_context->scene_update_context));
 
-  test_context->mock_session_wrapper->Present();
+  test_context->session->Flush();
 
   // Run loop until idle, so that the Session receives and processes
   // its method calls.

flow/layers/layer.cc

@@ -58,24 +58,49 @@ Layer::AutoPrerollSaveLayerState::~AutoPrerollSaveLayerState() {
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
 
 void Layer::CheckForChildLayerBelow(PrerollContext* context) {
-  // If there is embedded Fuchsia content in the scene (a ChildSceneLayer),
-  // PhysicalShapeLayers that appear above the embedded content will be turned
-  // into their own Scenic layers.
   child_layer_exists_below_ = context->child_scene_layer_exists_below;
   if (child_layer_exists_below_) {
     set_needs_system_composite(true);
   }
 }
 
 void Layer::UpdateScene(SceneUpdateContext& context) {
-  FML_DCHECK(needs_system_composite());
-  FML_DCHECK(child_layer_exists_below_);
-
-  SceneUpdateContext::Frame frame(
-      context, SkRRect::MakeRect(paint_bounds()), SK_ColorTRANSPARENT,
-      SkScalarRoundToInt(context.alphaf() * 255), "flutter::Layer");
-
-  frame.AddPaintLayer(this);
+  // If there is embedded Fuchsia content in the scene (a ChildSceneLayer),
+  // PhysicalShapeLayers that appear above the embedded content will be turned
+  // into their own Scenic layers.
+  if (child_layer_exists_below_) {
+    float global_scenic_elevation =
+        context.GetGlobalElevationForNextScenicLayer();
+    float local_scenic_elevation =
+        global_scenic_elevation - context.scenic_elevation();
+    float z_translation = -local_scenic_elevation;
+
+    // Retained rendering: speedup by reusing a retained entity node if
+    // possible. When an entity node is reused, no paint layer is added to the
+    // frame so we won't call PhysicalShapeLayer::Paint.
+    LayerRasterCacheKey key(unique_id(), context.Matrix());
+    if (context.HasRetainedNode(key)) {
+      TRACE_EVENT_INSTANT0("flutter", "retained layer cache hit");
+      scenic::EntityNode* retained_node = context.GetRetainedNode(key);
+      FML_DCHECK(context.top_entity());
+      FML_DCHECK(retained_node->session() == context.session());
+
+      // Re-adjust the elevation.
+      retained_node->SetTranslation(0.f, 0.f, z_translation);
+
+      context.top_entity()->entity_node().AddChild(*retained_node);
+      return;
+    }
+
+    TRACE_EVENT_INSTANT0("flutter", "cache miss, creating");
+    // If we can't find an existing retained surface, create one.
+    SceneUpdateContext::Frame frame(
+        context, SkRRect::MakeRect(paint_bounds()), SK_ColorTRANSPARENT,
+        SkScalarRoundToInt(context.alphaf() * 255),
+        "flutter::PhysicalShapeLayer", z_translation, this);
+
+    frame.AddPaintLayer(this);
+  }
 }
 
 #endif

flow/layers/layer.h

@@ -56,10 +56,14 @@ struct PrerollContext {
   const Stopwatch& ui_time;
   TextureRegistry& texture_registry;
   const bool checkerboard_offscreen_layers;
-  const float frame_device_pixel_ratio;
+
+  // These allow us to make use of the scene metrics during Preroll.
+  float frame_physical_depth;
+  float frame_device_pixel_ratio;
 
   // These allow us to track properties like elevation, opacity, and the
   // prescence of a platform view during Preroll.
+  float total_elevation = 0.0f;
   bool has_platform_view = false;
   bool is_opaque = true;
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
@@ -124,7 +128,10 @@ class Layer {
     TextureRegistry& texture_registry;
     const RasterCache* raster_cache;
     const bool checkerboard_offscreen_layers;
-    const float frame_device_pixel_ratio;
+
+    // These allow us to make use of the scene metrics during Paint.
+    float frame_physical_depth;
+    float frame_device_pixel_ratio;
   };
 
   // Calls SkCanvas::saveLayer and restores the layer upon destruction. Also