Extract SessionConnection & friends

Author: arbreng

flow/layers/child_scene_layer.cc

@@ -4,8 +4,6 @@
 
 #include "flutter/flow/layers/child_scene_layer.h"
 
-#include "flutter/flow/view_holder.h"
-
 namespace flutter {
 
 ChildSceneLayer::ChildSceneLayer(zx_koid_t layer_id,
@@ -47,15 +45,7 @@ void ChildSceneLayer::Paint(PaintContext& context) const {
 void ChildSceneLayer::UpdateScene(SceneUpdateContext& context) {
   TRACE_EVENT0("flutter", "ChildSceneLayer::UpdateScene");
   FML_DCHECK(needs_system_composite());
-
-  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_);
+  context.UpdateView(layer_id_, offset_, size_, hit_testable_);
 }
 
 }  // namespace flutter

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,10 +60,12 @@ bool LayerTree::Preroll(CompositorContext::ScopedFrame& frame,
 }
 
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
-void LayerTree::UpdateScene(SceneUpdateContext& context,
-                            scenic::ContainerNode& container) {
+void LayerTree::UpdateScene(SceneUpdateContext& context) {
   TRACE_EVENT0("flutter", "LayerTree::UpdateScene");
 
+  // Reset for a new Scene.
+  context.Reset();
+
   const float inv_dpr = 1.0f / device_pixel_ratio_;
   SceneUpdateContext::Transform transform(context, inv_dpr, inv_dpr, 1.0f);
 
@@ -78,7 +80,7 @@ void LayerTree::UpdateScene(SceneUpdateContext& context,
   if (root_layer_->needs_painting()) {
     frame.AddPaintLayer(root_layer_.get());
   }
-  container.AddChild(transform.entity_node());
+  context.root_node().AddChild(transform.entity_node());
 }
 #endif
 

flow/layers/layer_tree.h

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

flow/layers/platform_view_layer.cc

@@ -48,7 +48,9 @@ void PlatformViewLayer::Paint(PaintContext& context) const {
 
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
 void PlatformViewLayer::UpdateScene(SceneUpdateContext& context) {
-  context.UpdateScene(view_id_, offset_, size_);
+  TRACE_EVENT0("flutter", "PlatformViewLayer::UpdateScene");
+  FML_DCHECK(needs_system_composite());
+  context.UpdateView(view_id_, offset_, size_);
 }
 #endif
 

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();
 
-void SceneUpdateContext::CreateFrame(scenic::EntityNode entity_node,
+  return frame_paint_tasks;
+}
+
+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,30 +160,24 @@ 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::UpdateScene(int64_t view_id,
-                                     const SkPoint& offset,
-                                     const SkSize& size) {
+void SceneUpdateContext::UpdateView(int64_t view_id,
+                                    const SkPoint& offset,
+                                    const SkSize& size,
+                                    std::optional<bool> override_hit_testable) {
   auto* view_holder = ViewHolder::FromId(view_id);
   FML_DCHECK(view_holder);
 
-  view_holder->SetProperties(size.width(), size.height(), 0, 0, 0, 0,
-                             view_holder->focusable());
-  view_holder->UpdateScene(*this, offset, size,
-                           SkScalarRoundToInt(alphaf() * 255),
-                           view_holder->hit_testable());
+  if (size.width() > 0.f && size.height() > 0.f) {
+    view_holder->SetProperties(size.width(), size.height(), 0, 0, 0, 0,
+                               view_holder->focusable());
+  }
+
+  bool hit_testable = override_hit_testable.has_value()
+                          ? *override_hit_testable
+                          : view_holder->hit_testable();
+  view_holder->UpdateScene(session_.get(), top_entity_->embedder_node(), offset,
+                           size, SkScalarRoundToInt(alphaf() * 255),
+                           hit_testable);
 }
 
 void SceneUpdateContext::CreateView(int64_t view_id,
@@ -167,13 +201,17 @@ void SceneUpdateContext::DestroyView(int64_t view_id) {
 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_;
 }
@@ -242,7 +280,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,
@@ -259,15 +297,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) {