[DisplayList] DlPath supports generic path dispatching (#164753)

There are different ways to iterate over an SkPath or an impeller::Path
and various points in the engine source tree we have boilerplate
duplicates of this code to transfer the contents of the DlPath wrapper
object into some platform-specific path. This PR adds a
dispatch/receiver mechanism to read back the contents of a DlPath -
independent of whether it is backed by an SkPath or an impeller::Path -
in a simpler form that avoids potential mistakes in the various
conversion methods.

See DlPathReceiver and DlPath::Dispatch in the dl_path.h file

Author: flar

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

@@ -8,6 +8,29 @@
 #include "flutter/impeller/geometry/path_builder.h"
 #include "impeller/geometry/path.h"
 
+namespace {
+inline constexpr flutter::DlPathFillType ToDlFillType(SkPathFillType sk_type) {
+  switch (sk_type) {
+    case SkPathFillType::kEvenOdd:
+      return impeller::FillType::kOdd;
+    case SkPathFillType::kWinding:
+      return impeller::FillType::kNonZero;
+    case SkPathFillType::kInverseEvenOdd:
+    case SkPathFillType::kInverseWinding:
+      FML_UNREACHABLE();
+  }
+}
+
+inline constexpr SkPathFillType ToSkFillType(flutter::DlPathFillType dl_type) {
+  switch (dl_type) {
+    case impeller::FillType::kOdd:
+      return SkPathFillType::kEvenOdd;
+    case impeller::FillType::kNonZero:
+      return SkPathFillType::kWinding;
+  }
+}
+}  // namespace
+
 namespace flutter {
 
 using Path = impeller::Path;
@@ -120,6 +143,22 @@ const Path& DlPath::GetPath() const {
   return path.value();
 }
 
+void DlPath::Dispatch(DlPathReceiver& receiver) const {
+  if (data_->sk_path_original) {
+    auto& sk_path = data_->sk_path;
+    FML_DCHECK(sk_path.has_value());
+    if (sk_path.has_value()) {
+      DispatchFromSkiaPath(sk_path.value(), receiver);
+    }
+  } else {
+    auto& path = data_->path;
+    FML_DCHECK(path.has_value());
+    if (path.has_value()) {
+      DispatchFromImpellerPath(path.value(), receiver);
+    }
+  }
+}
+
 void DlPath::WillRenderSkPath() const {
   if (data_->render_count >= kMaxVolatileUses) {
     auto& sk_path = data_->sk_path;
@@ -252,26 +291,94 @@ DlPath DlPath::operator+(const DlPath& other) const {
   return DlPath(path);
 }
 
-SkPath DlPath::ConvertToSkiaPath(const Path& path, const DlPoint& shift) {
-  SkPath sk_path;
-  sk_path.setFillType(ToSkFillType(path.GetFillType()));
+static void ReduceConic(DlPathReceiver& receiver,
+                        const DlPoint& p1,
+                        const DlPoint& cp,
+                        const DlPoint& p2,
+                        DlScalar weight) {
+  // We might eventually have conic conversion math that deals with
+  // degenerate conics gracefully (or have all receivers just handle
+  // them directly). But, until then, we will just convert them to a
+  // pair of quads and accept the results as "close enough".
+  if (p1 != cp) {
+    if (cp != p2) {
+      std::array<DlPoint, 5> points;
+      impeller::ConicPathComponent conic(p1, cp, p2, weight);
+      conic.SubdivideToQuadraticPoints(points);
+      receiver.QuadTo(points[1], points[2]);
+      receiver.QuadTo(points[3], points[4]);
+    } else {
+      receiver.LineTo(cp);
+    }
+  } else if (cp != p2) {
+    receiver.LineTo(p2);
+  }
+}
+
+namespace {
+class SkiaPathReceiver final : public DlPathReceiver {
+ public:
+  void SetPathInfo(DlPathFillType fill_type, bool is_convex) override {
+    sk_path_.setFillType(ToSkFillType(fill_type));
+  }
+  void MoveTo(const DlPoint& p2) override { sk_path_.moveTo(ToSkPoint(p2)); }
+  void LineTo(const DlPoint& p2) override { sk_path_.lineTo(ToSkPoint(p2)); }
+  void QuadTo(const DlPoint& cp, const DlPoint& p2) override {
+    sk_path_.quadTo(ToSkPoint(cp), ToSkPoint(p2));
+  }
+  bool ConicTo(const DlPoint& cp, const DlPoint& p2, DlScalar weight) override {
+    sk_path_.conicTo(ToSkPoint(cp), ToSkPoint(p2), weight);
+    return true;
+  }
+  void CubicTo(const DlPoint& cp1,
+               const DlPoint& cp2,
+               const DlPoint& p2) override {
+    sk_path_.cubicTo(ToSkPoint(cp1), ToSkPoint(cp2), ToSkPoint(p2));
+  }
+  void Close() override { sk_path_.close(); }
+
+  SkPath TakePath() { return sk_path_; }
+
+ private:
+  SkPath sk_path_;
+};
+}  // namespace
+
+SkPath DlPath::ConvertToSkiaPath(const Path& path) {
+  SkiaPathReceiver receiver;
+
+  DispatchFromImpellerPath(path, receiver);
+
+  return receiver.TakePath();
+}
+
+void DlPath::DispatchFromImpellerPath(const impeller::Path& path,
+                                      DlPathReceiver& receiver) {
   bool subpath_needs_close = false;
   std::optional<DlPoint> pending_moveto;
 
-  auto resolve_moveto = [&pending_moveto, &sk_path]() {
+  auto resolve_moveto = [&receiver, &pending_moveto]() {
     if (pending_moveto.has_value()) {
-      sk_path.moveTo(ToSkPoint(pending_moveto.value()));
+      receiver.MoveTo(pending_moveto.value());
       pending_moveto.reset();
     }
   };
 
+  // The Impeller Point Count is way overestimated due to duplicate
+  // points between elements.
+  receiver.RecommendSizes(path.GetComponentCount(), path.GetPointCount());
+  std::optional<DlRect> bounds = path.GetBoundingBox();
+  if (bounds.has_value()) {
+    receiver.RecommendBounds(bounds.value());
+  }
+  receiver.SetPathInfo(path.GetFillType(), path.IsConvex());
   for (auto it = path.begin(), end = path.end(); it != end; ++it) {
     switch (it.type()) {
       case ComponentType::kContour: {
         const impeller::ContourComponent* contour = it.contour();
         FML_DCHECK(contour != nullptr);
         if (subpath_needs_close) {
-          sk_path.close();
+          receiver.Close();
         }
         pending_moveto = contour->destination;
         subpath_needs_close = contour->IsClosed();
@@ -281,45 +388,96 @@ SkPath DlPath::ConvertToSkiaPath(const Path& path, const DlPoint& shift) {
         const impeller::LinearPathComponent* linear = it.linear();
         FML_DCHECK(linear != nullptr);
         resolve_moveto();
-        sk_path.lineTo(ToSkPoint(linear->p2));
+        receiver.LineTo(linear->p2);
         break;
       }
       case ComponentType::kQuadratic: {
         const impeller::QuadraticPathComponent* quadratic = it.quadratic();
         FML_DCHECK(quadratic != nullptr);
         resolve_moveto();
-        sk_path.quadTo(ToSkPoint(quadratic->cp), ToSkPoint(quadratic->p2));
+        receiver.QuadTo(quadratic->cp, quadratic->p2);
         break;
       }
       case ComponentType::kConic: {
         const impeller::ConicPathComponent* conic = it.conic();
         FML_DCHECK(conic != nullptr);
         resolve_moveto();
-        sk_path.conicTo(ToSkPoint(conic->cp), ToSkPoint(conic->p2),
-                        conic->weight.x);
+        if (!receiver.ConicTo(conic->cp, conic->p2, conic->weight.x)) {
+          ReduceConic(receiver, conic->p1, conic->cp, conic->p2,
+                      conic->weight.x);
+        }
         break;
       }
       case ComponentType::kCubic: {
         const impeller::CubicPathComponent* cubic = it.cubic();
         FML_DCHECK(cubic != nullptr);
         resolve_moveto();
-        sk_path.cubicTo(ToSkPoint(cubic->cp1), ToSkPoint(cubic->cp2),
-                        ToSkPoint(cubic->p2));
+        receiver.CubicTo(cubic->cp1, cubic->cp2, cubic->p2);
         break;
       }
     }
   }
   if (subpath_needs_close) {
-    sk_path.close();
+    receiver.Close();
   }
-
-  return sk_path;
 }
 
-Path DlPath::ConvertToImpellerPath(const SkPath& path, const DlPoint& shift) {
-  if (path.isEmpty() || !shift.IsFinite()) {
+namespace {
+class ImpellerPathReceiver final : public DlPathReceiver {
+ public:
+  void RecommendSizes(size_t verb_count, size_t point_count) override {
+    // Reserve a path size with some arbitrarily additional padding.
+    builder_.Reserve(point_count + 8, verb_count + 8);
+  }
+  void RecommendBounds(const DlRect& bounds) override {
+    builder_.SetBounds(bounds);
+  }
+  void SetPathInfo(DlPathFillType fill_type, bool is_convex) override {
+    this->fill_type_ = fill_type;
+    builder_.SetConvexity(is_convex ? Convexity::kConvex  //
+                                    : Convexity::kUnknown);
+  }
+  void MoveTo(const DlPoint& p2) override { builder_.MoveTo(p2); }
+  void LineTo(const DlPoint& p2) override { builder_.LineTo(p2); }
+  void QuadTo(const DlPoint& cp, const DlPoint& p2) override {
+    builder_.QuadraticCurveTo(cp, p2);
+  }
+  // For legacy compatibility we do not override ConicTo to let the dispatcher
+  // convert conics to quads until we update Impeller for full support of
+  // rational quadratics
+  void CubicTo(const DlPoint& cp1,
+               const DlPoint& cp2,
+               const DlPoint& p2) override {
+    builder_.CubicCurveTo(cp1, cp2, p2);
+  }
+  void Close() override { builder_.Close(); }
+
+  impeller::Path TakePath() { return builder_.TakePath(fill_type_); }
+
+ private:
+  PathBuilder builder_;
+  DlPathFillType fill_type_;
+};
+}  // namespace
+
+Path DlPath::ConvertToImpellerPath(const SkPath& path) {
+  if (path.isEmpty()) {
     return Path{};
   }
+
+  ImpellerPathReceiver receiver;
+
+  DispatchFromSkiaPath(path, receiver);
+
+  return receiver.TakePath();
+}
+
+void DlPath::DispatchFromSkiaPath(const SkPath& path,
+                                  DlPathReceiver& receiver) {
+  if (path.isEmpty()) {
+    return;
+  }
+
   auto iterator = SkPath::Iter(path, false);
 
   struct PathData {
@@ -328,67 +486,47 @@ Path DlPath::ConvertToImpellerPath(const SkPath& path, const DlPoint& shift) {
     };
   };
 
-  PathBuilder builder;
   PathData data;
-  // Reserve a path size with some arbitrarily additional padding.
-  builder.Reserve(path.countPoints() + 8, path.countVerbs() + 8);
+
+  receiver.RecommendSizes(path.countVerbs(), path.countPoints());
+  receiver.RecommendBounds(ToDlRect(path.getBounds()));
+  receiver.SetPathInfo(ToDlFillType(path.getFillType()), path.isConvex());
   auto verb = SkPath::Verb::kDone_Verb;
   do {
     verb = iterator.next(data.points);
     switch (verb) {
       case SkPath::kMove_Verb:
-        builder.MoveTo(ToDlPoint(data.points[0]));
+        receiver.MoveTo(ToDlPoint(data.points[0]));
         break;
       case SkPath::kLine_Verb:
-        builder.LineTo(ToDlPoint(data.points[1]));
+        receiver.LineTo(ToDlPoint(data.points[1]));
         break;
       case SkPath::kQuad_Verb:
-        builder.QuadraticCurveTo(ToDlPoint(data.points[1]),
-                                 ToDlPoint(data.points[2]));
+        receiver.QuadTo(ToDlPoint(data.points[1]), ToDlPoint(data.points[2]));
         break;
       case SkPath::kConic_Verb:
-        // We might eventually have conic conversion math that deals with
-        // degenerate conics gracefully (or just handle them directly),
-        // but until then, we will detect and ignore them.
-        if (data.points[0] != data.points[1]) {
-          if (data.points[1] != data.points[2]) {
-            std::array<DlPoint, 5> points;
-            impeller::ConicPathComponent conic(
-                ToDlPoint(data.points[0]), ToDlPoint(data.points[1]),
-                ToDlPoint(data.points[2]), iterator.conicWeight());
-            conic.SubdivideToQuadraticPoints(points);
-            builder.QuadraticCurveTo(points[1], points[2]);
-            builder.QuadraticCurveTo(points[3], points[4]);
-          } else {
-            builder.LineTo(ToDlPoint(data.points[1]));
-          }
-        } else if (data.points[1] != data.points[2]) {
-          builder.LineTo(ToDlPoint(data.points[2]));
+        if (!receiver.ConicTo(ToDlPoint(data.points[1]),
+                              ToDlPoint(data.points[2]),
+                              iterator.conicWeight())) {
+          ReduceConic(receiver,                   //
+                      ToDlPoint(data.points[0]),  //
+                      ToDlPoint(data.points[1]),  //
+                      ToDlPoint(data.points[2]),  //
+                      iterator.conicWeight());
         }
         break;
       case SkPath::kCubic_Verb:
-        builder.CubicCurveTo(ToDlPoint(data.points[1]),
-                             ToDlPoint(data.points[2]),
-                             ToDlPoint(data.points[3]));
+        receiver.CubicTo(ToDlPoint(data.points[1]),  //
+                         ToDlPoint(data.points[2]),  //
+                         ToDlPoint(data.points[3]));
         break;
       case SkPath::kClose_Verb:
-        builder.Close();
+        receiver.Close();
         break;
       case SkPath::kDone_Verb:
         break;
     }
   } while (verb != SkPath::Verb::kDone_Verb);
-
-  DlRect bounds = ToDlRect(path.getBounds());
-  if (!shift.IsZero()) {
-    builder.Shift(shift);
-    bounds = bounds.Shift(shift);
-  }
-
-  builder.SetConvexity(path.isConvex() ? Convexity::kConvex
-                                       : Convexity::kUnknown);
-  builder.SetBounds(bounds);
-  return builder.TakePath(ToDlFillType(path.getFillType()));
 }
 
 }  // namespace flutter