[Impeller] Migrate unit tests off of Skia geometry classes (flutter#161855)

Handles the impeller unittests line in
flutter#161456

This PR is focused on the unit tests in Impeller. There are still some
uses in other non-test areas which will be handled in a separate PR.

Author: flar

engine/src/flutter/display_list/display_list_unittests.cc

@@ -1793,7 +1793,7 @@ TEST_F(DisplayListTest, FlutterSvgIssue661BoundsWereEmpty) {
                              {32.3f, 14.615f},    //
                              {32.3f, 19.34f});
   path_builder1.Close();
-  DlPath dl_path1 = DlPath(path_builder1.TakePath(DlPathFillType::kNonZero));
+  DlPath dl_path1 = DlPath(path_builder1, DlPathFillType::kNonZero);
 
   DlPathBuilder path_builder2;
   path_builder2.MoveTo({37.5f, 19.33f});
@@ -1806,7 +1806,7 @@ TEST_F(DisplayListTest, FlutterSvgIssue661BoundsWereEmpty) {
                              {37.495f, 11.756f},  //
                              {37.5f, 19.33f});
   path_builder2.Close();
-  DlPath dl_path2 = DlPath(path_builder2.TakePath(DlPathFillType::kNonZero));
+  DlPath dl_path2 = DlPath(path_builder2, DlPathFillType::kNonZero);
 
   DisplayListBuilder builder;
   DlPaint paint = DlPaint(DlColor::kWhite()).setAntiAlias(true);
@@ -4878,7 +4878,7 @@ TEST_F(DisplayListTest, ClipPathNonCulling) {
   path_builder.LineTo({1000.0f, 0.0f});
   path_builder.LineTo({0.0f, 1000.0f});
   path_builder.Close();
-  DlPath path = DlPath(path_builder.TakePath());
+  DlPath path = DlPath(path_builder);
 
   // Double checking that the path does indeed contain the clip. But,
   // sadly, the Builder will not check paths for coverage to this level

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

@@ -62,6 +62,33 @@ DlPath DlPath::MakeRoundRectXY(const DlRect& rect,
       counter_clock_wise ? SkPathDirection::kCCW : SkPathDirection::kCW));
 }
 
+DlPath DlPath::MakeLine(const DlPoint& a, const DlPoint& b) {
+  return DlPath(SkPath::Line(ToSkPoint(a), ToSkPoint(b)));
+}
+
+DlPath DlPath::MakePoly(const DlPoint pts[],
+                        int count,
+                        bool close,
+                        DlPathFillType fill_type) {
+  return DlPath(
+      SkPath::Polygon(ToSkPoints(pts), count, close, ToSkFillType(fill_type)));
+}
+
+DlPath DlPath::MakeArc(const DlRect& bounds,
+                       DlDegrees start,
+                       DlDegrees end,
+                       bool use_center) {
+  SkPath path;
+  if (use_center) {
+    path.moveTo(ToSkPoint(bounds.GetCenter()));
+  }
+  path.arcTo(ToSkRect(bounds), start.degrees, end.degrees, !use_center);
+  if (use_center) {
+    path.close();
+  }
+  return DlPath(path);
+}
+
 const SkPath& DlPath::GetSkPath() const {
   auto& sk_path = data_->sk_path;
   auto& path = data_->path;
@@ -207,16 +234,24 @@ bool DlPath::IsVolatile() const {
   return GetSkPath().isVolatile();
 }
 
+bool DlPath::IsConvex() const {
+  if (data_->sk_path_original) {
+    auto& sk_path = data_->sk_path;
+    FML_DCHECK(sk_path.has_value());
+    return sk_path.has_value() && sk_path->isConvex();
+  } else {
+    auto& path = data_->path;
+    FML_DCHECK(path.has_value());
+    return path.has_value() && path->IsConvex();
+  }
+}
+
 DlPath DlPath::operator+(const DlPath& other) const {
   SkPath path = GetSkPath();
   path.addPath(other.GetSkPath());
   return DlPath(path);
 }
 
-DlPath::Data::Data(const SkPath& path) : sk_path(path) {
-  FML_DCHECK(!SkPathFillType_IsInverse(path.getFillType()));
-}
-
 SkPath DlPath::ConvertToSkiaPath(const Path& path, const DlPoint& shift) {
   SkPath sk_path;
   sk_path.setFillType(ToSkFillType(path.GetFillType()));
@@ -338,26 +373,16 @@ Path DlPath::ConvertToImpellerPath(const SkPath& path, const DlPoint& shift) {
     }
   } while (verb != SkPath::Verb::kDone_Verb);
 
-  FillType fill_type;
-  switch (path.getFillType()) {
-    case SkPathFillType::kWinding:
-      fill_type = FillType::kNonZero;
-      break;
-    case SkPathFillType::kEvenOdd:
-      fill_type = FillType::kOdd;
-      break;
-    case SkPathFillType::kInverseWinding:
-    case SkPathFillType::kInverseEvenOdd:
-      FML_UNREACHABLE();
-  }
-  builder.SetConvexity(path.isConvex() ? Convexity::kConvex
-                                       : Convexity::kUnknown);
+  DlRect bounds = ToDlRect(path.getBounds());
   if (!shift.IsZero()) {
     builder.Shift(shift);
+    bounds = bounds.Shift(shift);
   }
-  auto sk_bounds = path.getBounds().makeOutset(shift.x, shift.y);
-  builder.SetBounds(ToDlRect(sk_bounds));
-  return builder.TakePath(fill_type);
+
+  builder.SetConvexity(path.isConvex() ? Convexity::kConvex
+                                       : Convexity::kUnknown);
+  builder.SetBounds(bounds);
+  return builder.TakePath(ToDlFillType(path.getFillType()));
 }
 
 }  // namespace flutter

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

@@ -43,10 +43,24 @@ class DlPath {
                                 DlScalar y_radius,
                                 bool counter_clock_wise = false);
 
+  static DlPath MakeLine(const DlPoint& a, const DlPoint& b);
+  static DlPath MakePoly(const DlPoint pts[],
+                         int count,
+                         bool close,
+                         DlPathFillType fill_type = DlPathFillType::kNonZero);
+
+  static DlPath MakeArc(const DlRect& bounds,
+                        DlDegrees start,
+                        DlDegrees end,
+                        bool use_center);
+
   DlPath() : data_(std::make_shared<Data>(SkPath())) {}
   explicit DlPath(const SkPath& path) : data_(std::make_shared<Data>(path)) {}
   explicit DlPath(const impeller::Path& path)
       : data_(std::make_shared<Data>(path)) {}
+  explicit DlPath(DlPathBuilder& builder,
+                  DlPathFillType fill_type = DlPathFillType::kNonZero)
+      : data_(std::make_shared<Data>(builder.TakePath(fill_type))) {}
 
   DlPath(const DlPath& path) = default;
   DlPath(DlPath&& path) = default;
@@ -84,18 +98,22 @@ class DlPath {
 
   bool IsConverted() const;
   bool IsVolatile() const;
-  bool IsEvenOdd() const;
+  bool IsConvex() const;
 
   DlPath operator+(const DlPath& other) const;
 
  private:
   struct Data {
-    explicit Data(const SkPath& path);
-    explicit Data(const impeller::Path& path) : path(path) {}
+    explicit Data(const SkPath& path) : sk_path(path), sk_path_original(true) {
+      FML_DCHECK(!SkPathFillType_IsInverse(path.getFillType()));
+    }
+    explicit Data(const impeller::Path& path)
+        : path(path), sk_path_original(false) {}
 
     std::optional<SkPath> sk_path;
     std::optional<impeller::Path> path;
     uint32_t render_count = 0u;
+    const bool sk_path_original;
   };
 
   inline constexpr static DlPathFillType ToDlFillType(SkPathFillType sk_type) {