Migrate Mutators to DisplayList/Impeller geometry (#164258)

Mutator types and MutatorsStack will now use DisplayList/Impeller
geometry objects.

Author: flar

engine/src/flutter/display_list/geometry/dl_path.cc

@@ -106,7 +106,7 @@ const SkPath& DlPath::GetSkPath() const {
   return sk_path.value();
 }
 
-Path DlPath::GetPath() const {
+const Path& DlPath::GetPath() const {
   auto& sk_path = data_->sk_path;
   auto& path = data_->path;
   if (path.has_value()) {

engine/src/flutter/display_list/geometry/dl_path.h

@@ -67,7 +67,7 @@ class DlPath {
   DlPath& operator=(const DlPath&) = default;
 
   const SkPath& GetSkPath() const;
-  impeller::Path GetPath() const;
+  const impeller::Path& GetPath() const;
 
   /// Intent to render an SkPath multiple times will make the path
   /// non-volatile to enable caching in Skia. Calling this method

engine/src/flutter/display_list/skia/dl_sk_conversions_unittests.cc

@@ -422,7 +422,7 @@ TEST(DisplayListSkConversions, ConicPathToQuads) {
     sk_path.conicTo(20, 10, 20, 20, weight);
 
     DlPath dl_path(sk_path);
-    impeller::Path i_path = dl_path.GetPath();
+    const impeller::Path& i_path = dl_path.GetPath();
 
     auto it = i_path.begin();
     ASSERT_EQ(it.type(), impeller::Path::ComponentType::kContour);

engine/src/flutter/display_list/utils/dl_matrix_clip_tracker.cc

@@ -246,45 +246,59 @@ DlRect DisplayListMatrixClipState::GetLocalCullCoverage() const {
 }
 
 bool DisplayListMatrixClipState::rect_covers_cull(const DlRect& content) const {
-  if (content.IsEmpty()) {
+  return TransformedRectCoversBounds(content, matrix_, cull_rect_);
+}
+
+bool DisplayListMatrixClipState::TransformedRectCoversBounds(
+    const DlRect& local_rect,
+    const DlMatrix& matrix,
+    const DlRect& cull_bounds) {
+  if (local_rect.IsEmpty()) {
     return false;
   }
-  if (cull_rect_.IsEmpty()) {
+  if (cull_bounds.IsEmpty()) {
     return true;
   }
-  if (matrix_.IsAligned2D()) {
+  if (matrix.IsAligned2D()) {
     // This transform-to-device calculation is faster and more accurate
     // for rect-to-rect aligned transformations, but not accurate under
     // (non-quadrant) rotations and skews.
-    return content.TransformAndClipBounds(matrix_).Contains(cull_rect_);
+    return local_rect.TransformAndClipBounds(matrix).Contains(cull_bounds);
   }
   DlPoint corners[4];
-  if (!getLocalCullCorners(corners)) {
+  if (!GetLocalCorners(corners, cull_bounds, matrix)) {
     return false;
   }
   for (auto corner : corners) {
-    if (!content.ContainsInclusive(corner)) {
+    if (!local_rect.ContainsInclusive(corner)) {
       return false;
     }
   }
   return true;
 }
 
 bool DisplayListMatrixClipState::oval_covers_cull(const DlRect& bounds) const {
-  if (bounds.IsEmpty()) {
+  return TransformedOvalCoversBounds(bounds, matrix_, cull_rect_);
+}
+
+bool DisplayListMatrixClipState::TransformedOvalCoversBounds(
+    const DlRect& local_oval_bounds,
+    const DlMatrix& matrix,
+    const DlRect& cull_bounds) {
+  if (local_oval_bounds.IsEmpty()) {
     return false;
   }
-  if (cull_rect_.IsEmpty()) {
+  if (cull_bounds.IsEmpty()) {
     return true;
   }
   DlPoint corners[4];
-  if (!getLocalCullCorners(corners)) {
+  if (!GetLocalCorners(corners, cull_bounds, matrix)) {
     return false;
   }
-  DlPoint center = bounds.GetCenter();
-  DlSize scale = 2.0 / bounds.GetSize();
+  DlPoint center = local_oval_bounds.GetCenter();
+  DlSize scale = 2.0 / local_oval_bounds.GetSize();
   for (auto corner : corners) {
-    if (!bounds.Contains(corner)) {
+    if (!local_oval_bounds.Contains(corner)) {
       return false;
     }
     if (((corner - center) * scale).GetLengthSquared() >= 1.0) {
@@ -296,28 +310,37 @@ bool DisplayListMatrixClipState::oval_covers_cull(const DlRect& bounds) const {
 
 bool DisplayListMatrixClipState::rrect_covers_cull(
     const DlRoundRect& content) const {
-  if (content.IsEmpty()) {
+  return TransformedRRectCoversBounds(content, matrix_, cull_rect_);
+}
+
+bool DisplayListMatrixClipState::TransformedRRectCoversBounds(
+    const DlRoundRect& local_rrect,
+    const DlMatrix& matrix,
+    const DlRect& cull_bounds) {
+  if (local_rrect.IsEmpty()) {
     return false;
   }
-  if (cull_rect_.IsEmpty()) {
+  if (cull_bounds.IsEmpty()) {
     return true;
   }
-  if (content.IsRect()) {
-    return rect_covers_cull(content.GetBounds());
+  if (local_rrect.IsRect()) {
+    return TransformedRectCoversBounds(local_rrect.GetBounds(), matrix,
+                                       cull_bounds);
   }
-  if (content.IsOval()) {
-    return oval_covers_cull(content.GetBounds());
+  if (local_rrect.IsOval()) {
+    return TransformedOvalCoversBounds(local_rrect.GetBounds(), matrix,
+                                       cull_bounds);
   }
-  if (!content.GetRadii().AreAllCornersSame()) {
+  if (!local_rrect.GetRadii().AreAllCornersSame()) {
     return false;
   }
   DlPoint corners[4];
-  if (!getLocalCullCorners(corners)) {
+  if (!GetLocalCorners(corners, cull_bounds, matrix)) {
     return false;
   }
-  auto outer = content.GetBounds();
+  auto outer = local_rrect.GetBounds();
   auto center = outer.GetCenter();
-  auto radii = content.GetRadii().top_left;
+  auto radii = local_rrect.GetRadii().top_left;
   auto inner = outer.GetSize() * 0.5 - radii;
   auto scale = 1.0 / radii;
   for (auto corner : corners) {
@@ -335,25 +358,34 @@ bool DisplayListMatrixClipState::rrect_covers_cull(
 
 bool DisplayListMatrixClipState::rsuperellipse_covers_cull(
     const DlRoundSuperellipse& content) const {
-  if (content.IsEmpty()) {
+  return TransformedRoundSuperellipseCoversBounds(content, matrix_, cull_rect_);
+}
+
+bool DisplayListMatrixClipState::TransformedRoundSuperellipseCoversBounds(
+    const DlRoundSuperellipse& local_rse,
+    const DlMatrix& matrix,
+    const DlRect& cull_bounds) {
+  if (local_rse.IsEmpty()) {
     return false;
   }
-  if (cull_rect_.IsEmpty()) {
+  if (cull_bounds.IsEmpty()) {
     return true;
   }
-  if (content.IsRect()) {
-    return rect_covers_cull(content.GetBounds());
+  if (local_rse.IsRect()) {
+    return TransformedRectCoversBounds(local_rse.GetBounds(), matrix,
+                                       cull_bounds);
   }
-  if (content.IsOval()) {
-    return oval_covers_cull(content.GetBounds());
+  if (local_rse.IsOval()) {
+    return TransformedOvalCoversBounds(local_rse.GetBounds(), matrix,
+                                       cull_bounds);
   }
   DlPoint corners[4];
-  if (!getLocalCullCorners(corners)) {
+  if (!GetLocalCorners(corners, cull_bounds, matrix)) {
     return false;
   }
-  auto outer = content.GetBounds();
+  auto outer = local_rse.GetBounds();
   auto param = impeller::RoundSuperellipseParam::MakeBoundsRadii(
-      outer, content.GetRadii());
+      outer, local_rse.GetRadii());
   for (auto corner : corners) {
     if (!outer.Contains(corner)) {
       return false;
@@ -365,15 +397,17 @@ bool DisplayListMatrixClipState::rsuperellipse_covers_cull(
   return true;
 }
 
-bool DisplayListMatrixClipState::getLocalCullCorners(DlPoint corners[4]) const {
-  if (!is_matrix_invertable()) {
+bool DisplayListMatrixClipState::GetLocalCorners(DlPoint corners[4],
+                                                 const DlRect& rect,
+                                                 const DlMatrix& matrix) {
+  if (!matrix.IsInvertible()) {
     return false;
   }
-  DlMatrix inverse = matrix_.Invert();
-  corners[0] = inverse * cull_rect_.GetLeftTop();
-  corners[1] = inverse * cull_rect_.GetRightTop();
-  corners[2] = inverse * cull_rect_.GetRightBottom();
-  corners[3] = inverse * cull_rect_.GetLeftBottom();
+  DlMatrix inverse = matrix.Invert();
+  corners[0] = inverse * rect.GetLeftTop();
+  corners[1] = inverse * rect.GetRightTop();
+  corners[2] = inverse * rect.GetRightBottom();
+  corners[3] = inverse * rect.GetLeftBottom();
   return true;
 }
 

engine/src/flutter/display_list/utils/dl_matrix_clip_tracker.h

@@ -113,12 +113,60 @@ class DisplayListMatrixClipState {
                          bool is_aa);
   void clipPath(const DlPath& path, DlClipOp op, bool is_aa);
 
+  /// @brief Checks if the local rect, when transformed by the matrix,
+  ///        completely covers the indicated culling bounds.
+  ///
+  /// This utility method helps answer the question of whether a clip
+  /// rectangle being intersected under a transform is essentially obsolete
+  /// because it will not reduce the already existing clip culling bounds.
+  [[nodiscard]]
+  static bool TransformedRectCoversBounds(const DlRect& local_rect,
+                                          const DlMatrix& matrix,
+                                          const DlRect& cull_bounds);
+
+  /// @brief Checks if an oval defined by the local bounds, when transformed
+  ///        by the matrix, completely covers the indicated culling bounds.
+  ///
+  /// This utility method helps answer the question of whether a clip
+  /// oval being intersected under a transform is essentially obsolete
+  /// because it will not reduce the already existing clip culling bounds.
+  [[nodiscard]]
+  static bool TransformedOvalCoversBounds(const DlRect& local_oval_bounds,
+                                          const DlMatrix& matrix,
+                                          const DlRect& cull_bounds);
+
+  /// @brief Checks if the local round rect, when transformed by the matrix,
+  ///        completely covers the indicated culling bounds.
+  ///
+  /// This utility method helps answer the question of whether a clip
+  /// rrect being intersected under a transform is essentially obsolete
+  /// because it will not reduce the already existing clip culling bounds.
+  [[nodiscard]]
+  static bool TransformedRRectCoversBounds(const DlRoundRect& local_rrect,
+                                           const DlMatrix& matrix,
+                                           const DlRect& cull_bounds);
+
+  /// @brief Checks if the local round superellipse, when transformed by the
+  ///        matrix, completely covers the indicated culling bounds.
+  ///
+  /// This utility method helps answer the question of whether a clip round
+  /// superellipse being intersected under a transform is essentially obsolete
+  /// because it will not reduce the already existing clip culling bounds.
+  [[nodiscard]]
+  static bool TransformedRoundSuperellipseCoversBounds(
+      const DlRoundSuperellipse& local_rse,
+      const DlMatrix& matrix,
+      const DlRect& cull_bounds);
+
  private:
   DlRect cull_rect_;
   DlMatrix matrix_;
 
-  bool getLocalCullCorners(DlPoint corners[4]) const;
   void adjustCullRect(const DlRect& clip, DlClipOp op, bool is_aa);
+
+  static bool GetLocalCorners(DlPoint corners[4],
+                              const DlRect& rect,
+                              const DlMatrix& matrix);
 };
 
 }  // namespace flutter