[fuchsia][a11y] Set explicit hit regions per compositor layer on GFX.

shell/platform/fuchsia/flutter/gfx_external_view_embedder.cc

@@ -10,6 +10,7 @@
 
 #include <algorithm>  // For std::clamp
 
+#include "flutter/fml/logging.h"
 #include "flutter/fml/trace_event.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkSurface.h"
@@ -169,8 +170,9 @@ void GfxExternalViewEmbedder::PrerollCompositeEmbeddedView(
   zx_handle_t handle = static_cast<zx_handle_t>(view_id);
   FML_CHECK(frame_layers_.count(handle) == 0);
 
-  frame_layers_.emplace(std::make_pair(EmbedderLayerId{handle},
-                                       EmbedderLayer(frame_size_, *params)));
+  frame_layers_.emplace(std::make_pair(
+      EmbedderLayerId{handle},
+      EmbedderLayer(frame_size_, *params, flutter::RTreeFactory())));
   frame_composition_order_.push_back(handle);
 }
 
@@ -200,8 +202,9 @@ void GfxExternalViewEmbedder::BeginFrame(
   frame_dpr_ = device_pixel_ratio;
 
   // Create the root layer.
-  frame_layers_.emplace(
-      std::make_pair(kRootLayerId, EmbedderLayer(frame_size, std::nullopt)));
+  frame_layers_.emplace(std::make_pair(
+      kRootLayerId,
+      EmbedderLayer(frame_size, std::nullopt, flutter::RTreeFactory())));
   frame_composition_order_.push_back(kRootLayerId);
 
   // Set up the input interceptor at the top of the scene, if applicable.
@@ -271,6 +274,38 @@ void GfxExternalViewEmbedder::SubmitFrame(
     }
   }
 
+  // Render the recorded SkPictures into the surfaces.
+  {
+    TRACE_EVENT0("flutter", "RasterizeSurfaces");
+
+    for (const auto& surface_index : frame_surface_indices) {
+      TRACE_EVENT0("flutter", "RasterizeSurface");
+
+      FML_CHECK(surface_index.second < frame_surfaces.size());
+      SurfaceProducerSurface* surface =
+          frame_surfaces[surface_index.second].get();
+      FML_CHECK(surface != nullptr);
+
+      sk_sp<SkSurface> sk_surface = surface->GetSkiaSurface();
+      FML_CHECK(sk_surface != nullptr);
+      FML_CHECK(SkISize::Make(sk_surface->width(), sk_surface->height()) ==
+                frame_size_);
+      SkCanvas* canvas = sk_surface->getCanvas();
+      FML_CHECK(canvas != nullptr);
+
+      const auto& layer = frame_layers_.find(surface_index.first);
+      FML_CHECK(layer != frame_layers_.end());
+      sk_sp<SkPicture> picture =
+          layer->second.recorder->finishRecordingAsPicture();
+      FML_CHECK(picture != nullptr);
+
+      canvas->setMatrix(SkMatrix::I());
+      canvas->clear(SK_ColorTRANSPARENT);
+      canvas->drawPicture(picture);
+      canvas->flush();
+    }
+  }
+
   // Submit layers and platform views to Scenic in composition order.
   {
     TRACE_EVENT0("flutter", "SubmitLayers");
@@ -491,7 +526,7 @@ void GfxExternalViewEmbedder::SubmitFrame(
             embedded_views_height;
         auto& scenic_layer = scenic_layers_[scenic_layer_index];
         auto& scenic_rect = found_rects->second[rect_index];
-        scenic_layer.shape_node.SetLabel("Flutter::Layer");
+        scenic_layer.shape_node.SetLabel("Flutter::Layer::Image");
         scenic_layer.shape_node.SetShape(scenic_rect);
         scenic_layer.shape_node.SetTranslation(
             layer->second.surface_size.width() * 0.5f,
@@ -500,16 +535,39 @@ void GfxExternalViewEmbedder::SubmitFrame(
                                        SK_AlphaOPAQUE, layer_opacity);
         scenic_layer.material.SetTexture(surface_for_layer->GetImageId());
 
-        // Only the first (i.e. the bottom-most) layer should receive input.
-        // TODO: Workaround for invisible overlays stealing input. Remove when
-        // the underlying bug is fixed.
-        const fuchsia::ui::gfx::HitTestBehavior layer_hit_test_behavior =
-            first_layer ? fuchsia::ui::gfx::HitTestBehavior::kDefault
-                        : fuchsia::ui::gfx::HitTestBehavior::kSuppress;
-        scenic_layer.shape_node.SetHitTestBehavior(layer_hit_test_behavior);
+        // We'll set hit regions expliclty on a separate ShapeNode, so the image
+        // itself should be unhittable and semantically invisible.
+        scenic_layer.shape_node.SetHitTestBehavior(
+            fuchsia::ui::gfx::HitTestBehavior::kSuppress);
+        scenic_layer.shape_node.SetSemanticVisibility(false);
 
         // Attach the ScenicLayer to the main scene graph.
         layer_tree_node_.AddChild(scenic_layer.shape_node);
+
+        // Compute the set of non-overlapping set of bounding boxes for the
+        // paintied content in this layer.
+        {
+          FML_CHECK(layer->second.rtree);
+          std::list<SkRect> intersection_rects =
+              layer->second.rtree->searchNonOverlappingDrawnRects(
+                  SkRect::Make(layer->second.surface_size));
+
+          // SkRect joined_rect = SkRect::MakeEmpty();
+          for (const SkRect& rect : intersection_rects) {
+            auto paint_bounds =
+                scenic::Rectangle(session_->get(), rect.width(), rect.height());
+            auto shape_node = scenic::ShapeNode(session_->get());
+            shape_node.SetLabel("Flutter::Layer::HitRegion");
+            shape_node.SetShape(paint_bounds);
+            shape_node.SetTranslation(rect.centerX(), rect.centerY(),
+                                      -layer_elevation);
+            shape_node.SetHitTestBehavior(
+                fuchsia::ui::gfx::HitTestBehavior::kDefault);
+            shape_node.SetSemanticVisibility(true);
+
+            layer_tree_node_.AddChild(shape_node);
+          }
+        }
       }
 
       // Reset for the next pass:
@@ -527,38 +585,6 @@ void GfxExternalViewEmbedder::SubmitFrame(
     session_->Present();
   }
 
-  // Render the recorded SkPictures into the surfaces.
-  {
-    TRACE_EVENT0("flutter", "RasterizeSurfaces");
-
-    for (const auto& surface_index : frame_surface_indices) {
-      TRACE_EVENT0("flutter", "RasterizeSurface");
-
-      FML_CHECK(surface_index.second < frame_surfaces.size());
-      SurfaceProducerSurface* surface =
-          frame_surfaces[surface_index.second].get();
-      FML_CHECK(surface != nullptr);
-
-      sk_sp<SkSurface> sk_surface = surface->GetSkiaSurface();
-      FML_CHECK(sk_surface != nullptr);
-      FML_CHECK(SkISize::Make(sk_surface->width(), sk_surface->height()) ==
-                frame_size_);
-      SkCanvas* canvas = sk_surface->getCanvas();
-      FML_CHECK(canvas != nullptr);
-
-      const auto& layer = frame_layers_.find(surface_index.first);
-      FML_CHECK(layer != frame_layers_.end());
-      sk_sp<SkPicture> picture =
-          layer->second.recorder->finishRecordingAsPicture();
-      FML_CHECK(picture != nullptr);
-
-      canvas->setMatrix(SkMatrix::I());
-      canvas->clear(SK_ColorTRANSPARENT);
-      canvas->drawPicture(picture);
-      canvas->flush();
-    }
-  }
-
   // Flush deferred Skia work and inform Scenic that render targets are ready.
   {
     TRACE_EVENT0("flutter", "PresentSurfaces");

shell/platform/fuchsia/flutter/gfx_external_view_embedder.h

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "flutter/flow/embedded_views.h"
+#include "flutter/flow/rtree.h"
 #include "flutter/fml/logging.h"
 #include "flutter/fml/macros.h"
 #include "flutter/shell/common/canvas_spy.h"
@@ -138,14 +139,17 @@ class GfxExternalViewEmbedder final : public flutter::ExternalViewEmbedder {
 
   struct EmbedderLayer {
     EmbedderLayer(const SkISize& frame_size,
-                  std::optional<flutter::EmbeddedViewParams> view_params)
-        : embedded_view_params(std::move(view_params)),
+                  std::optional<flutter::EmbeddedViewParams> view_params,
+                  flutter::RTreeFactory rtree_factory)
+        : rtree(rtree_factory.getInstance()),
+          embedded_view_params(std::move(view_params)),
           recorder(std::make_unique<SkPictureRecorder>()),
           canvas_spy(std::make_unique<flutter::CanvasSpy>(
-              recorder->beginRecording(frame_size.width(),
-                                       frame_size.height()))),
+              recorder->beginRecording(SkRect::Make(frame_size),
+                                       &rtree_factory))),
           surface_size(frame_size) {}
 
+    sk_sp<flutter::RTree> rtree;
     std::optional<flutter::EmbeddedViewParams> embedded_view_params;
     std::unique_ptr<SkPictureRecorder> recorder;
     std::unique_ptr<flutter::CanvasSpy> canvas_spy;