Break up SurfaceProducer/SceneUpdateContext/SessionConnection

Author: arbreng

flow/layers/fuchsia_layer_unittests.cc

@@ -238,15 +238,28 @@ class MockSession : public fuchsia::ui::scenic::testing::Session_TestBase {
   fuchsia::ui::scenic::SessionListenerPtr listener_;
 };
 
+class MockSessionWrapper : public flutter::SessionWrapper {
+ public:
+  MockSessionWrapper(fuchsia::ui::scenic::SessionPtr session_ptr)
+      : session_(std::move(session_ptr)) {}
+  ~MockSessionWrapper() override = default;
+
+  scenic::Session* get() override { return &session_; }
+  void Present() override { session_.Flush(); }
+
+ private:
+  scenic::Session session_;
+};
+
 struct TestContext {
   // Message loop.
   fml::RefPtr<fml::MessageLoopFuchsia> loop;
   fml::RefPtr<fml::TaskRunner> task_runner;
 
   // Session.
-  MockSession mock_session;
   fidl::InterfaceRequest<fuchsia::ui::scenic::SessionListener> listener_request;
-  std::unique_ptr<scenic::Session> session;
+  MockSession mock_session;
+  std::unique_ptr<MockSessionWrapper> mock_session_wrapper;
 
   // SceneUpdateContext.
   std::unique_ptr<SceneUpdateContext> scene_update_context;
@@ -270,11 +283,13 @@ 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->session = std::make_unique<scenic::Session>(std::move(session_ptr));
+  context->mock_session_wrapper =
+      std::make_unique<MockSessionWrapper>(std::move(session_ptr));
 
   // Init SceneUpdateContext.
-  context->scene_update_context =
-      std::make_unique<SceneUpdateContext>(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));
 
   // Init PrerollContext.
   context->preroll_context = std::unique_ptr<PrerollContext>(new PrerollContext{
@@ -543,7 +558,7 @@ TEST_F(FuchsiaLayerTest, DISABLED_PhysicalShapeLayersAndChildSceneLayers) {
   // against the list above.
   root->UpdateScene(*(test_context->scene_update_context));
 
-  test_context->session->Flush();
+  test_context->mock_session_wrapper->Present();
 
   // Run loop until idle, so that the Session receives and processes
   // its method calls.
@@ -725,7 +740,7 @@ TEST_F(FuchsiaLayerTest, DISABLED_OpacityAndTransformLayer) {
   // commands against the list above.
   root->UpdateScene(*(test_context->scene_update_context));
 
-  test_context->session->Flush();
+  test_context->mock_session_wrapper->Present();
 
   // Run loop until idle, so that the Session receives and processes
   // its method calls.

flow/layers/layer_tree.cc

@@ -60,29 +60,6 @@ bool LayerTree::Preroll(CompositorContext::ScopedFrame& frame,
   return context.surface_needs_readback;
 }
 
-#if defined(LEGACY_FUCHSIA_EMBEDDER)
-void LayerTree::UpdateScene(SceneUpdateContext& context,
-                            scenic::ContainerNode& container) {
-  TRACE_EVENT0("flutter", "LayerTree::UpdateScene");
-
-  const float inv_dpr = 1.0f / device_pixel_ratio_;
-  SceneUpdateContext::Transform transform(context, inv_dpr, inv_dpr, 1.0f);
-
-  SceneUpdateContext::Frame frame(
-      context,
-      SkRRect::MakeRect(
-          SkRect::MakeWH(frame_size_.width(), frame_size_.height())),
-      SK_ColorTRANSPARENT, SK_AlphaOPAQUE, "flutter::LayerTree");
-  if (root_layer_->needs_system_composite()) {
-    root_layer_->UpdateScene(context);
-  }
-  if (root_layer_->needs_painting()) {
-    frame.AddPaintLayer(root_layer_.get());
-  }
-  container.AddChild(transform.entity_node());
-}
-#endif
-
 void LayerTree::Paint(CompositorContext::ScopedFrame& frame,
                       bool ignore_raster_cache) const {
   TRACE_EVENT0("flutter", "LayerTree::Paint");

flow/layers/layer_tree.h

@@ -32,11 +32,6 @@ class LayerTree {
   bool Preroll(CompositorContext::ScopedFrame& frame,
                bool ignore_raster_cache = false);
 
-#if defined(LEGACY_FUCHSIA_EMBEDDER)
-  void UpdateScene(SceneUpdateContext& context,
-                   scenic::ContainerNode& container);
-#endif
-
   void Paint(CompositorContext::ScopedFrame& frame,
              bool ignore_raster_cache = false) const;
 

flow/scene_update_context.cc

@@ -4,6 +4,7 @@
 
 #include "flutter/flow/scene_update_context.h"
 
+#include <lib/ui/scenic/cpp/commands.h>
 #include <lib/ui/scenic/cpp/view_token_pair.h>
 
 #include "flutter/flow/layers/layer.h"
@@ -64,28 +65,67 @@ void SetMaterialColor(scenic::Material& material,
 
 }  // namespace
 
-SceneUpdateContext::SceneUpdateContext(scenic::Session* session)
-    : session_(session) {}
+SceneUpdateContext::SceneUpdateContext(std::string debug_label,
+                                       fuchsia::ui::views::ViewToken view_token,
+                                       scenic::ViewRefPair view_ref_pair,
+                                       SessionWrapper& session)
+    : session_(session),
+      root_view_(session_.get(),
+                 std::move(view_token),
+                 std::move(view_ref_pair.control_ref),
+                 std::move(view_ref_pair.view_ref),
+                 debug_label),
+      root_node_(session_.get()) {
+  root_view_.AddChild(root_node_);
+  root_node_.SetEventMask(fuchsia::ui::gfx::kMetricsEventMask);
+
+  session_.Present();
+}
+
+std::vector<SceneUpdateContext::PaintTask> SceneUpdateContext::GetPaintTasks() {
+  std::vector<PaintTask> frame_paint_tasks = std::move(paint_tasks_);
+
+  paint_tasks_.clear();
+
+  return frame_paint_tasks;
+}
 
-void SceneUpdateContext::CreateFrame(scenic::EntityNode entity_node,
+void SceneUpdateContext::EnableWireframe(bool enable) {
+  session_.get()->Enqueue(
+      scenic::NewSetEnableDebugViewBoundsCmd(root_view_.id(), enable));
+}
+
+void SceneUpdateContext::Reset() {
+  paint_tasks_.clear();
+  top_entity_ = nullptr;
+  top_scale_x_ = 1.f;
+  top_scale_y_ = 1.f;
+  top_elevation_ = 0.f;
+  next_elevation_ = 0.f;
+  alpha_ = 1.f;
+
+  // We are going to be sending down a fresh node hierarchy every frame. So just
+  // enqueue a detach op on the imported root node.
+  session_.get()->Enqueue(scenic::NewDetachChildrenCmd(root_node_.id()));
+}
+
+void SceneUpdateContext::CreateFrame(scenic::EntityNode& entity_node,
                                      const SkRRect& rrect,
                                      SkColor color,
                                      SkAlpha opacity,
                                      const SkRect& paint_bounds,
                                      std::vector<Layer*> paint_layers) {
-  FML_DCHECK(!rrect.isEmpty());
+  if (rrect.isEmpty())
+    return;
 
   // Frames always clip their children.
   SkRect shape_bounds = rrect.getBounds();
   SetEntityNodeClipPlanes(entity_node, shape_bounds);
 
   // and possibly for its texture.
   // TODO(SCN-137): Need to be able to express the radii as vectors.
-  scenic::ShapeNode shape_node(session());
-  scenic::Rectangle shape(session_,       // session
-                          rrect.width(),  // width
-                          rrect.height()  // height
-  );
+  scenic::ShapeNode shape_node(session_.get());
+  scenic::Rectangle shape(session_.get(), rrect.width(), rrect.height());
   shape_node.SetShape(shape);
   shape_node.SetTranslation(shape_bounds.width() * 0.5f + shape_bounds.left(),
                             shape_bounds.height() * 0.5f + shape_bounds.top(),
@@ -95,7 +135,7 @@ void SceneUpdateContext::CreateFrame(scenic::EntityNode entity_node,
   if (paint_bounds.isEmpty() || !paint_bounds.intersects(shape_bounds))
     paint_layers.clear();
 
-  scenic::Material material(session());
+  scenic::Material material(session_.get());
   shape_node.SetMaterial(material);
   entity_node.AddChild(shape_node);
 
@@ -120,19 +160,6 @@ void SceneUpdateContext::CreateFrame(scenic::EntityNode entity_node,
   }
 }
 
-std::vector<SceneUpdateContext::PaintTask>
-SceneUpdateContext::ResetAndGetPaintTasks() {
-  std::vector<PaintTask> frame_paint_tasks = std::move(paint_tasks_);
-
-  // Reset all internal state.
-  paint_tasks_.clear();
-  top_elevation_ = 0.0f;
-  next_elevation_ = 0.0f;
-  alpha_ = 1.0f;
-
-  return frame_paint_tasks;
-}
-
 void SceneUpdateContext::CreateView(int64_t view_id,
                                     bool hit_testable,
                                     bool focusable) {
@@ -163,20 +190,24 @@ void SceneUpdateContext::UpdateView(int64_t view_id,
                           : view_holder->hit_testable();
   view_holder->SetProperties(size.width(), size.height(), 0, 0, 0, 0,
                              view_holder->focusable());
-  view_holder->Update(session_, top_entity_->embedder_node(), offset, size,
-                      SkScalarRoundToInt(alphaf() * 255), hit_testable);
+  view_holder->Update(session_.get(), top_entity_->embedder_node(), offset,
+                      size, SkScalarRoundToInt(alphaf() * 255), hit_testable);
 }
 
 SceneUpdateContext::Entity::Entity(SceneUpdateContext& context)
     : context_(context),
       previous_entity_(context.top_entity_),
-      entity_node_(context.session()) {
-  if (previous_entity_)
-    previous_entity_->embedder_node().AddChild(entity_node_);
+      entity_node_(context.session_.get()) {
   context.top_entity_ = this;
 }
 
 SceneUpdateContext::Entity::~Entity() {
+  if (previous_entity_) {
+    previous_entity_->embedder_node().AddChild(entity_node_);
+  } else {
+    context_.root_node_.AddChild(entity_node_);
+  }
+
   FML_DCHECK(context_.top_entity_ == this);
   context_.top_entity_ = previous_entity_;
 }
@@ -245,7 +276,7 @@ SceneUpdateContext::Frame::Frame(SceneUpdateContext& context,
       rrect_(rrect),
       color_(color),
       opacity_(opacity),
-      opacity_node_(context.session()),
+      opacity_node_(context.session_.get()),
       paint_bounds_(SkRect::MakeEmpty()) {
   entity_node().SetLabel(label);
   entity_node().SetTranslation(0.f, 0.f,
@@ -262,15 +293,11 @@ SceneUpdateContext::Frame::Frame(SceneUpdateContext& context,
 }
 
 SceneUpdateContext::Frame::~Frame() {
-  context().top_elevation_ = previous_elevation_;
-
-  // We don't need a shape if the frame is zero size.
-  if (rrect_.isEmpty())
-    return;
-
   // Add a part which represents the frame's geometry for clipping purposes
-  context().CreateFrame(std::move(entity_node()), rrect_, color_, opacity_,
-                        paint_bounds_, std::move(paint_layers_));
+  context().CreateFrame(entity_node(), rrect_, color_, opacity_, paint_bounds_,
+                        std::move(paint_layers_));
+
+  context().top_elevation_ = previous_elevation_;
 }
 
 void SceneUpdateContext::Frame::AddPaintLayer(Layer* layer) {

flow/scene_update_context.h

@@ -5,16 +5,19 @@
 #ifndef FLUTTER_FLOW_SCENE_UPDATE_CONTEXT_H_
 #define FLUTTER_FLOW_SCENE_UPDATE_CONTEXT_H_
 
+#include <fuchsia/ui/views/cpp/fidl.h>
+#include <lib/ui/scenic/cpp/resources.h>
+#include <lib/ui/scenic/cpp/session.h>
+#include <lib/ui/scenic/cpp/view_ref_pair.h>
+
 #include <cfloat>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "flutter/flow/embedded_views.h"
-#include "flutter/fml/compiler_specific.h"
 #include "flutter/fml/logging.h"
 #include "flutter/fml/macros.h"
-#include "lib/ui/scenic/cpp/resources.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
@@ -31,6 +34,14 @@ constexpr float kOneMinusEpsilon = 1 - FLT_EPSILON;
 // How much layers are separated in Scenic z elevation.
 constexpr float kScenicZElevationBetweenLayers = 10.f;
 
+class SessionWrapper {
+ public:
+  virtual ~SessionWrapper() {}
+
+  virtual scenic::Session* get() = 0;
+  virtual void Present() = 0;
+};
+
 class SceneUpdateContext : public flutter::ExternalViewEmbedder {
  public:
   class Entity {
@@ -106,18 +117,24 @@ class SceneUpdateContext : public flutter::ExternalViewEmbedder {
     std::vector<Layer*> layers;
   };
 
-  SceneUpdateContext(scenic::Session* session);
+  SceneUpdateContext(std::string debug_label,
+                     fuchsia::ui::views::ViewToken view_token,
+                     scenic::ViewRefPair view_ref_pair,
+                     SessionWrapper& session);
   ~SceneUpdateContext() = default;
 
-  scenic::Session* session() { return session_; }
-  Entity* top_entity() { return top_entity_; }
-
   // The cumulative alpha value based on all the parent OpacityLayers.
   void set_alphaf(float alpha) { alpha_ = alpha; }
   float alphaf() { return alpha_; }
 
   // Returns all `PaintTask`s generated for the current frame.
-  std::vector<PaintTask> ResetAndGetPaintTasks();
+  std::vector<PaintTask> GetPaintTasks();
+
+  // Enable/disable wireframe rendering around the root view bounds.
+  void EnableWireframe(bool enable);
+
+  // Reset state for a new frame.
+  void Reset();
 
   // |ExternalViewEmbedder|
   SkCanvas* GetRootCanvas() override { return nullptr; }
@@ -155,24 +172,27 @@ class SceneUpdateContext : public flutter::ExternalViewEmbedder {
                   std::optional<bool> override_hit_testable = std::nullopt);
 
  private:
-  void CreateFrame(scenic::EntityNode entity_node,
+  void CreateFrame(scenic::EntityNode& entity_node,
                    const SkRRect& rrect,
                    SkColor color,
                    SkAlpha opacity,
                    const SkRect& paint_bounds,
                    std::vector<Layer*> paint_layers);
 
+  SessionWrapper& session_;
+
+  scenic::View root_view_;
+  scenic::EntityNode root_node_;
+
+  std::vector<PaintTask> paint_tasks_;
+
   Entity* top_entity_ = nullptr;
   float top_scale_x_ = 1.f;
   float top_scale_y_ = 1.f;
-  float top_elevation_ = 0.0f;
+  float top_elevation_ = 0.f;
 
-  scenic::Session* const session_;
-
-  float alpha_ = 1.0f;
-  float next_elevation_ = 0.0f;
-
-  std::vector<PaintTask> paint_tasks_;
+  float next_elevation_ = 0.f;
+  float alpha_ = 1.f;
 
   FML_DISALLOW_COPY_AND_ASSIGN(SceneUpdateContext);
 };

shell/platform/fuchsia/flutter/component.cc

@@ -365,6 +365,12 @@ Application::Application(
   // Controls whether category "skia" trace events are enabled.
   settings_.trace_skia = true;
 
+  settings_.verbose_logging = true;
+
+  settings_.advisory_script_uri = debug_label_;
+
+  settings_.advisory_script_entrypoint = debug_label_;
+
   settings_.icu_data_path = "";
 
   settings_.assets_dir = application_assets_directory_.get();