Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 576 insertions, 0 deletions

diff --git a/layout/base/MotionPathUtils.cpp b/layout/base/MotionPathUtils.cpp
new file mode 100644
index 0000000000..b472949094
--- /dev/null
+++ b/layout/base/MotionPathUtils.cpp
@@ -0,0 +1,576 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/MotionPathUtils.h"
+
+#include "gfxPlatform.h"
+#include "mozilla/dom/SVGPathData.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Matrix.h"
+#include "mozilla/layers/LayersMessages.h"
+#include "mozilla/RefPtr.h"
+#include "nsIFrame.h"
+#include "nsStyleTransformMatrix.h"
+
+#include <math.h>
+
+namespace mozilla {
+
+using nsStyleTransformMatrix::TransformReferenceBox;
+
+RayReferenceData::RayReferenceData(const nsIFrame* aFrame) {
+  // We use GetContainingBlock() for now. TYLin said this function is buggy in
+  // modern CSS layout, but is ok for most cases.
+  // FIXME: Bug 1581237: This is still not clear that which box we should use
+  // for calculating the path length. We may need to update this.
+  // https://github.com/w3c/fxtf-drafts/issues/369
+  // FIXME: Bug 1579294: SVG layout may get a |container| with empty mRect
+  // (e.g. SVGOuterSVGAnonChildFrame), which makes the path length zero.
+  const nsIFrame* container = aFrame->GetContainingBlock();
+  if (!container) {
+    // If there is no parent frame, it's impossible to calculate the path
+    // length, so does the path.
+    return;
+  }
+
+  // The initial position is (0, 0) in |aFrame|, and we have to transform it
+  // into the space of |container|, so use GetOffsetsTo() to get the delta
+  // value.
+  // FIXME: Bug 1559232: The initial position will be adjusted after
+  // supporting `offset-position`.
+  mInitialPosition = CSSPoint::FromAppUnits(aFrame->GetOffsetTo(container));
+  // FIXME: We need a better definition for containing box in the spec. For now,
+  // we use border box for calculation.
+  // https://github.com/w3c/fxtf-drafts/issues/369
+  mContainingBlockRect =
+      CSSRect::FromAppUnits(container->GetRectRelativeToSelf());
+}
+
+// The distance is measured between the initial position and the intersection of
+// the ray with the box
+// https://drafts.fxtf.org/motion-1/#size-sides
+static CSSCoord ComputeSides(const CSSPoint& aInitialPosition,
+                             const CSSSize& aContainerSize,
+                             const StyleAngle& aAngle) {
+  // Given an acute angle |theta| (i.e. |t|) of a right-angled triangle, the
+  // hypotenuse |h| is the side that connects the two acute angles. The side
+  // |b| adjacent to |theta| is the side of the triangle that connects |theta|
+  // to the right angle.
+  //
+  // e.g. if the angle |t| is 0 ~ 90 degrees, and b * tan(theta) <= b',
+  //      h = b / cos(t):
+  //                       b*tan(t)
+  //       (0, 0) #--------*-----*--# (aContainerSize.width, 0)
+  //              |        |    /   |
+  //              |        |   /    |
+  //              |        b  h     |
+  //              |        |t/      |
+  //              |        |/       |
+  //    (aInitialPosition) *---b'---* (aContainerSize.width, aInitialPosition.y)
+  //              |        |        |
+  //              |        |        |
+  //              |        |        |
+  //              |        |        |
+  //              |        |        |
+  //              #-----------------# (aContainerSize.width,
+  //  (0, aContainerSize.height)       aContainerSize.height)
+  double theta = aAngle.ToRadians();
+  double sint = std::sin(theta);
+  double cost = std::cos(theta);
+
+  double b = cost >= 0 ? aInitialPosition.y
+                       : aContainerSize.height - aInitialPosition.y;
+  double bPrime = sint >= 0 ? aContainerSize.width - aInitialPosition.x
+                            : aInitialPosition.x;
+  sint = std::fabs(sint);
+  cost = std::fabs(cost);
+
+  // If |b * tan(theta)| is larger than |bPrime|, the intersection is
+  // on the other side, and |b'| is the opposite side of angle |theta| in this
+  // case.
+  //
+  // e.g. If b * tan(theta) > b', h = b' / sin(theta):
+  //   *----*
+  //   |    |
+  //   |   /|
+  //   b  /t|
+  //   |t/  |
+  //   |/   |
+  //   *-b'-*
+  if (b * sint > bPrime * cost) {
+    return bPrime / sint;
+  }
+  return b / cost;
+}
+
+static CSSCoord ComputeRayPathLength(const StyleRaySize aRaySizeType,
+                                     const StyleAngle& aAngle,
+                                     const RayReferenceData& aRayData) {
+  if (aRaySizeType == StyleRaySize::Sides) {
+    // If the initial position is not within the box, the distance is 0.
+    if (!aRayData.mContainingBlockRect.Contains(aRayData.mInitialPosition)) {
+      return 0.0;
+    }
+
+    return ComputeSides(aRayData.mInitialPosition,
+                        aRayData.mContainingBlockRect.Size(), aAngle);
+  }
+
+  // left: the length between the initial point and the left side.
+  // right: the length between the initial point and the right side.
+  // top: the length between the initial point and the top side.
+  // bottom: the lenght between the initial point and the bottom side.
+  CSSCoord left = std::abs(aRayData.mInitialPosition.x);
+  CSSCoord right = std::abs(aRayData.mContainingBlockRect.width -
+                            aRayData.mInitialPosition.x);
+  CSSCoord top = std::abs(aRayData.mInitialPosition.y);
+  CSSCoord bottom = std::abs(aRayData.mContainingBlockRect.height -
+                             aRayData.mInitialPosition.y);
+
+  switch (aRaySizeType) {
+    case StyleRaySize::ClosestSide:
+      return std::min({left, right, top, bottom});
+
+    case StyleRaySize::FarthestSide:
+      return std::max({left, right, top, bottom});
+
+    case StyleRaySize::ClosestCorner:
+    case StyleRaySize::FarthestCorner: {
+      CSSCoord h = 0;
+      CSSCoord v = 0;
+      if (aRaySizeType == StyleRaySize::ClosestCorner) {
+        h = std::min(left, right);
+        v = std::min(top, bottom);
+      } else {
+        h = std::max(left, right);
+        v = std::max(top, bottom);
+      }
+      return sqrt(h.value * h.value + v.value * v.value);
+    }
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unsupported ray size");
+  }
+
+  return 0.0;
+}
+
+static void ApplyRotationAndMoveRayToXAxis(
+    const StyleOffsetRotate& aOffsetRotate, const StyleAngle& aRayAngle,
+    AutoTArray<gfx::Point, 4>& aVertices) {
+  const StyleAngle directionAngle = aRayAngle - StyleAngle{90.0f};
+  // Get the final rotation which includes the direction angle and
+  // offset-rotate.
+  const StyleAngle rotateAngle =
+      (aOffsetRotate.auto_ ? directionAngle : StyleAngle{0.0f}) +
+      aOffsetRotate.angle;
+  // This is the rotation to rotate ray to positive x-axis (i.e. 90deg).
+  const StyleAngle rayToXAxis = StyleAngle{90.0} - aRayAngle;
+
+  gfx::Matrix m;
+  m.PreRotate((rotateAngle + rayToXAxis).ToRadians());
+  for (gfx::Point& p : aVertices) {
+    p = m.TransformPoint(p);
+  }
+}
+
+class RayPointComparator {
+ public:
+  bool Equals(const gfx::Point& a, const gfx::Point& b) const {
+    return std::fabs(a.y) == std::fabs(b.y);
+  }
+
+  bool LessThan(const gfx::Point& a, const gfx::Point& b) const {
+    return std::fabs(a.y) > std::fabs(b.y);
+  }
+};
+// Note: the calculation of contain doesn't take other transform-like properties
+// into account. The spec doesn't mention the co-operation for this, so for now,
+// we assume we only need to take motion-path into account.
+static CSSCoord ComputeRayUsedDistance(const RayFunction& aRay,
+                                       const LengthPercentage& aDistance,
+                                       const StyleOffsetRotate& aRotate,
+                                       const StylePositionOrAuto& aAnchor,
+                                       const CSSPoint& aTransformOrigin,
+                                       TransformReferenceBox& aRefBox,
+                                       const CSSCoord& aPathLength) {
+  CSSCoord usedDistance = aDistance.ResolveToCSSPixels(aPathLength);
+  if (!aRay.contain) {
+    return usedDistance;
+  }
+
+  // We have to simulate the 4 vertices to check if any of them is outside the
+  // path circle. Here, we create a 2D Cartesian coordinate system and its
+  // origin is at the anchor point of the box. And then apply the rotation on
+  // these 4 vertices, calculate the range of |usedDistance| which makes the box
+  // entirely contained within the path.
+  // Note:
+  // "Contained within the path" means the rectangle is inside a circle whose
+  // radius is |aPathLength|.
+  CSSPoint usedAnchor = aTransformOrigin;
+  CSSSize size =
+      CSSPixel::FromAppUnits(nsSize(aRefBox.Width(), aRefBox.Height()));
+  if (!aAnchor.IsAuto()) {
+    const StylePosition& anchor = aAnchor.AsPosition();
+    usedAnchor.x = anchor.horizontal.ResolveToCSSPixels(size.width);
+    usedAnchor.y = anchor.vertical.ResolveToCSSPixels(size.height);
+  }
+  AutoTArray<gfx::Point, 4> vertices = {
+      {-usedAnchor.x, -usedAnchor.y},
+      {size.width - usedAnchor.x, -usedAnchor.y},
+      {size.width - usedAnchor.x, size.height - usedAnchor.y},
+      {-usedAnchor.x, size.height - usedAnchor.y}};
+
+  ApplyRotationAndMoveRayToXAxis(aRotate, aRay.angle, vertices);
+
+  // We have to check if all 4 vertices are inside the circle with radius |r|.
+  // Assume the position of the vertex is (x, y), and the box is moved by
+  // |usedDistance| along the path:
+  //
+  //       (usedDistance + x)^2 + y^2 <= r^2
+  //   ==> (usedDistance + x)^2 <= r^2 - y^2 = d
+  //   ==> -x - sqrt(d) <= used distance <= -x + sqrt(d)
+  //
+  // Note: |usedDistance| is added into |x| because we convert the ray function
+  // to 90deg, x-axis):
+  float upperMin = std::numeric_limits<float>::max();
+  float lowerMax = std::numeric_limits<float>::min();
+  bool shouldIncreasePathLength = false;
+  for (const gfx::Point& p : vertices) {
+    float d = aPathLength.value * aPathLength.value - p.y * p.y;
+    if (d < 0) {
+      // Impossible to make the box inside the path circle. Need to increase
+      // the path length.
+      shouldIncreasePathLength = true;
+      break;
+    }
+    float sqrtD = sqrt(d);
+    upperMin = std::min(upperMin, -p.x + sqrtD);
+    lowerMax = std::max(lowerMax, -p.x - sqrtD);
+  }
+
+  if (!shouldIncreasePathLength) {
+    return std::max(lowerMax, std::min(upperMin, (float)usedDistance));
+  }
+
+  // Sort by the absolute value of y, so the first vertex of the each pair of
+  // vertices we check has a larger y value. (i.e. |yi| is always larger than or
+  // equal to |yj|.)
+  vertices.Sort(RayPointComparator());
+
+  // Assume we set |usedDistance| to |-vertices[0].x|, so the current radius is
+  // fabs(vertices[0].y). This is a possible solution.
+  double radius = std::fabs(vertices[0].y);
+  usedDistance = -vertices[0].x;
+  const double epsilon = 1e-5;
+
+  for (size_t i = 0; i < 3; ++i) {
+    for (size_t j = i + 1; j < 4; ++j) {
+      double xi = vertices[i].x;
+      double yi = vertices[i].y;
+      double xj = vertices[j].x;
+      double yj = vertices[j].y;
+      double dx = xi - xj;
+
+      // Check if any path that enclosed vertices[i] would also enclose
+      // vertices[j].
+      //
+      // For example, the initial setup:
+      //                 * (0, yi)
+      //                 |
+      //                 r
+      //                 |          * (xj - xi, yj)
+      //           xi    |     dx
+      // ----*-----------*----------*---
+      // (anchor point)  | (0, 0)
+      //
+      // Assuming (0, yi) is on the path and (xj - xi, yj) is inside the path
+      // circle, we should use the inequality to check this:
+      //   (xj - xi)^2 + yj^2 <= yi^2
+      //
+      // After the first iterations, the updated inequality is:
+      //       (dx + d)^2 + yj^2 <= yi^2 + d^2
+      //   ==> dx^2 + 2dx*d + yj^2 <= yi^2
+      //   ==> dx^2 + yj^2 <= yi^2 - 2dx*d <= yi^2
+      // , |d| is the difference (or offset) between the old |usedDistance| and
+      // new |usedDistance|.
+      //
+      // Note: `2dx * d` must be positive because
+      // 1. if |xj| is larger than |xi|, only negative |d| could be used to get
+      //    a new path length which encloses both vertices.
+      // 2. if |xj| is smaller than |xi|, only positive |d| could be used to get
+      //    a new path length which encloses both vertices.
+      if (dx * dx + yj * yj <= yi * yi + epsilon) {
+        continue;
+      }
+
+      // We have to find a new usedDistance which let both vertices[i] and
+      // vertices[j] be on the path.
+      //       (usedDistance + xi)^2 + yi^2 = (usedDistance + xj)^2 + yj^2
+      //                                    = radius^2
+      //   ==> usedDistance = (xj^2 + yj^2 - xi^2 - yi^2) / 2(xi-xj)
+      //
+      // Note: it's impossible to have a "divide by zero" problem here.
+      // If |dx| is zero, the if-condition above should always be true and so
+      // we skip the calculation.
+      double newUsedDistance =
+          (xj * xj + yj * yj - xi * xi - yi * yi) / dx / 2.0;
+      // Then, move vertices[i] and vertices[j] by |newUsedDistance|.
+      xi += newUsedDistance;  // or xj += newUsedDistance; if we use |xj| to get
+                              // |newRadius|.
+      double newRadius = sqrt(xi * xi + yi * yi);
+      if (newRadius > radius) {
+        // We have to increase the path length to make sure both vertices[i] and
+        // vertices[j] are contained by this new path length.
+        radius = newRadius;
+        usedDistance = (float)newUsedDistance;
+      }
+    }
+  }
+
+  return usedDistance;
+}
+
+/* static */
+CSSPoint MotionPathUtils::ComputeAnchorPointAdjustment(const nsIFrame& aFrame) {
+  if (!aFrame.HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
+    return {};
+  }
+
+  auto transformBox = aFrame.StyleDisplay()->mTransformBox;
+  if (transformBox == StyleGeometryBox::ViewBox ||
+      transformBox == StyleGeometryBox::BorderBox) {
+    return {};
+  }
+
+  if (aFrame.IsFrameOfType(nsIFrame::eSVGContainer)) {
+    nsRect boxRect = nsLayoutUtils::ComputeGeometryBox(
+        const_cast<nsIFrame*>(&aFrame), StyleGeometryBox::FillBox);
+    return CSSPoint::FromAppUnits(boxRect.TopLeft());
+  }
+  return CSSPoint::FromAppUnits(aFrame.GetPosition());
+}
+
+/* static */
+Maybe<ResolvedMotionPathData> MotionPathUtils::ResolveMotionPath(
+    const OffsetPathData& aPath, const LengthPercentage& aDistance,
+    const StyleOffsetRotate& aRotate, const StylePositionOrAuto& aAnchor,
+    const CSSPoint& aTransformOrigin, TransformReferenceBox& aRefBox,
+    const CSSPoint& aAnchorPointAdjustment) {
+  if (aPath.IsNone()) {
+    return Nothing();
+  }
+
+  // Compute the point and angle for creating the equivalent translate and
+  // rotate.
+  double directionAngle = 0.0;
+  gfx::Point point;
+  if (aPath.IsPath()) {
+    const auto& path = aPath.AsPath();
+    if (!path.mGfxPath) {
+      // Empty gfx::Path means it is path('') (i.e. empty path string).
+      return Nothing();
+    }
+
+    // Per the spec, we have to convert offset distance to pixels, with 100%
+    // being converted to total length. So here |gfxPath| is built with CSS
+    // pixel, and we calculate |pathLength| and |computedDistance| with CSS
+    // pixel as well.
+    gfx::Float pathLength = path.mGfxPath->ComputeLength();
+    gfx::Float usedDistance =
+        aDistance.ResolveToCSSPixels(CSSCoord(pathLength));
+    if (path.mIsClosedIntervals) {
+      // Per the spec, let used offset distance be equal to offset distance
+      // modulus the total length of the path. If the total length of the path
+      // is 0, used offset distance is also 0.
+      usedDistance = pathLength > 0.0 ? fmod(usedDistance, pathLength) : 0.0;
+      // We make sure |usedDistance| is 0.0 or a positive value.
+      // https://github.com/w3c/fxtf-drafts/issues/339
+      if (usedDistance < 0.0) {
+        usedDistance += pathLength;
+      }
+    } else {
+      // Per the spec, for unclosed interval, let used offset distance be equal
+      // to offset distance clamped by 0 and the total length of the path.
+      usedDistance = clamped(usedDistance, 0.0f, pathLength);
+    }
+    gfx::Point tangent;
+    point = path.mGfxPath->ComputePointAtLength(usedDistance, &tangent);
+    directionAngle = (double)atan2(tangent.y, tangent.x);  // In Radian.
+  } else if (aPath.IsRay()) {
+    const auto& ray = aPath.AsRay();
+    MOZ_ASSERT(ray.mRay);
+
+    CSSCoord pathLength =
+        ComputeRayPathLength(ray.mRay->size, ray.mRay->angle, ray.mData);
+    CSSCoord usedDistance =
+        ComputeRayUsedDistance(*ray.mRay, aDistance, aRotate, aAnchor,
+                               aTransformOrigin, aRefBox, pathLength);
+
+    // 0deg pointing up and positive angles representing clockwise rotation.
+    directionAngle =
+        StyleAngle{ray.mRay->angle.ToDegrees() - 90.0f}.ToRadians();
+
+    point.x = usedDistance * cos(directionAngle);
+    point.y = usedDistance * sin(directionAngle);
+  } else {
+    MOZ_ASSERT_UNREACHABLE("Unsupported offset-path value");
+    return Nothing();
+  }
+
+  // If |rotate.auto_| is true, the element should be rotated by the angle of
+  // the direction (i.e. directional tangent vector) of the offset-path, and the
+  // computed value of <angle> is added to this.
+  // Otherwise, the element has a constant clockwise rotation transformation
+  // applied to it by the specified rotation angle. (i.e. Don't need to
+  // consider the direction of the path.)
+  gfx::Float angle = static_cast<gfx::Float>(
+      (aRotate.auto_ ? directionAngle : 0.0) + aRotate.angle.ToRadians());
+
+  // Compute the offset for motion path translate.
+  // Bug 1559232: the translate parameters will be adjusted more after we
+  // support offset-position.
+  // Per the spec, the default offset-anchor is `auto`, so initialize the anchor
+  // point to transform-origin.
+  CSSPoint anchorPoint(aTransformOrigin);
+  gfx::Point shift;
+  if (!aAnchor.IsAuto()) {
+    const auto& pos = aAnchor.AsPosition();
+    anchorPoint = nsStyleTransformMatrix::Convert2DPosition(
+        pos.horizontal, pos.vertical, aRefBox);
+    // We need this value to shift the origin from transform-origin to
+    // offset-anchor (and vice versa).
+    // See nsStyleTransformMatrix::ReadTransform for more details.
+    shift = (anchorPoint - aTransformOrigin).ToUnknownPoint();
+  }
+
+  anchorPoint += aAnchorPointAdjustment;
+
+  return Some(ResolvedMotionPathData{point - anchorPoint.ToUnknownPoint(),
+                                     angle, shift});
+}
+
+static OffsetPathData GenerateOffsetPathData(const nsIFrame* aFrame) {
+  const StyleOffsetPath& path = aFrame->StyleDisplay()->mOffsetPath;
+  switch (path.tag) {
+    case StyleOffsetPath::Tag::Path: {
+      const StyleSVGPathData& pathData = path.AsPath();
+      RefPtr<gfx::Path> gfxPath =
+          aFrame->GetProperty(nsIFrame::OffsetPathCache());
+      MOZ_ASSERT(
+          gfxPath || pathData._0.IsEmpty(),
+          "Should have a valid cached gfx::Path or an empty path string");
+      return OffsetPathData::Path(pathData, gfxPath.forget());
+    }
+    case StyleOffsetPath::Tag::Ray:
+      return OffsetPathData::Ray(path.AsRay(), RayReferenceData(aFrame));
+    case StyleOffsetPath::Tag::None:
+      return OffsetPathData::None();
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unknown offset-path");
+      return OffsetPathData::None();
+  }
+}
+
+/* static*/
+Maybe<ResolvedMotionPathData> MotionPathUtils::ResolveMotionPath(
+    const nsIFrame* aFrame, TransformReferenceBox& aRefBox) {
+  MOZ_ASSERT(aFrame);
+
+  const nsStyleDisplay* display = aFrame->StyleDisplay();
+
+  // FIXME: It's possible to refactor the calculation of transform-origin, so we
+  // could calculate from the caller, and reuse the value in nsDisplayList.cpp.
+  CSSPoint transformOrigin = nsStyleTransformMatrix::Convert2DPosition(
+      display->mTransformOrigin.horizontal, display->mTransformOrigin.vertical,
+      aRefBox);
+
+  return ResolveMotionPath(GenerateOffsetPathData(aFrame),
+                           display->mOffsetDistance, display->mOffsetRotate,
+                           display->mOffsetAnchor, transformOrigin, aRefBox,
+                           ComputeAnchorPointAdjustment(*aFrame));
+}
+
+static OffsetPathData GenerateOffsetPathData(
+    const StyleOffsetPath& aPath, const RayReferenceData& aRayReferenceData,
+    gfx::Path* aCachedMotionPath) {
+  switch (aPath.tag) {
+    case StyleOffsetPath::Tag::Path: {
+      const StyleSVGPathData& pathData = aPath.AsPath();
+      // If aCachedMotionPath is valid, we have a fixed path.
+      // This means we have pre-built it already and no need to update.
+      RefPtr<gfx::Path> path = aCachedMotionPath;
+      if (!path) {
+        RefPtr<gfx::PathBuilder> builder =
+            MotionPathUtils::GetCompositorPathBuilder();
+        path = MotionPathUtils::BuildPath(pathData, builder);
+      }
+      return OffsetPathData::Path(pathData, path.forget());
+    }
+    case StyleOffsetPath::Tag::Ray:
+      return OffsetPathData::Ray(aPath.AsRay(), aRayReferenceData);
+    case StyleOffsetPath::Tag::None:
+    default:
+      return OffsetPathData::None();
+  }
+}
+
+/* static */
+Maybe<ResolvedMotionPathData> MotionPathUtils::ResolveMotionPath(
+    const StyleOffsetPath* aPath, const StyleLengthPercentage* aDistance,
+    const StyleOffsetRotate* aRotate, const StylePositionOrAuto* aAnchor,
+    const Maybe<layers::MotionPathData>& aMotionPathData,
+    TransformReferenceBox& aRefBox, gfx::Path* aCachedMotionPath) {
+  if (!aPath) {
+    return Nothing();
+  }
+
+  MOZ_ASSERT(aMotionPathData);
+
+  auto zeroOffsetDistance = LengthPercentage::Zero();
+  auto autoOffsetRotate = StyleOffsetRotate{true, StyleAngle::Zero()};
+  auto autoOffsetAnchor = StylePositionOrAuto::Auto();
+  return ResolveMotionPath(
+      GenerateOffsetPathData(*aPath, aMotionPathData->rayReferenceData(),
+                             aCachedMotionPath),
+      aDistance ? *aDistance : zeroOffsetDistance,
+      aRotate ? *aRotate : autoOffsetRotate,
+      aAnchor ? *aAnchor : autoOffsetAnchor, aMotionPathData->origin(), aRefBox,
+      aMotionPathData->anchorAdjustment());
+}
+
+/* static */
+StyleSVGPathData MotionPathUtils::NormalizeSVGPathData(
+    const StyleSVGPathData& aPath) {
+  StyleSVGPathData n;
+  Servo_SVGPathData_Normalize(&aPath, &n);
+  return n;
+}
+
+/* static */
+already_AddRefed<gfx::Path> MotionPathUtils::BuildPath(
+    const StyleSVGPathData& aPath, gfx::PathBuilder* aPathBuilder) {
+  if (!aPathBuilder) {
+    return nullptr;
+  }
+
+  const Span<const StylePathCommand>& path = aPath._0.AsSpan();
+  return SVGPathData::BuildPath(path, aPathBuilder, StyleStrokeLinecap::Butt,
+                                0.0);
+}
+
+/* static */
+already_AddRefed<gfx::PathBuilder> MotionPathUtils::GetCompositorPathBuilder() {
+  // FIXME: Perhaps we need a PathBuilder which is independent on the backend.
+  RefPtr<gfx::PathBuilder> builder =
+      gfxPlatform::Initialized()
+          ? gfxPlatform::GetPlatform()
+                ->ScreenReferenceDrawTarget()
+                ->CreatePathBuilder(gfx::FillRule::FILL_WINDING)
+          : gfx::Factory::CreateSimplePathBuilder();
+  return builder.forget();
+}
+
+}  // namespace mozilla