diff -r 000000000000 -r 6474c204b198 gfx/2d/PathHelpers.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/2d/PathHelpers.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,143 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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/. */
+
+#ifndef MOZILLA_GFX_PATHHELPERS_H_
+#define MOZILLA_GFX_PATHHELPERS_H_
+
+#include "2D.h"
+#include "mozilla/Constants.h"
+
+namespace mozilla {
+namespace gfx {
+
+template <typename T>
+void ArcToBezier(T* aSink, const Point &aOrigin, const Size &aRadius,
+                 float aStartAngle, float aEndAngle, bool aAntiClockwise)
+{
+  Point startPoint(aOrigin.x + cos(aStartAngle) * aRadius.width,
+                   aOrigin.y + sin(aStartAngle) * aRadius.height);
+
+  aSink->LineTo(startPoint);
+
+  // Clockwise we always sweep from the smaller to the larger angle, ccw
+  // it's vice versa.
+  if (!aAntiClockwise && (aEndAngle < aStartAngle)) {
+    Float correction = Float(ceil((aStartAngle - aEndAngle) / (2.0f * M_PI)));
+    aEndAngle += float(correction * 2.0f * M_PI);
+  } else if (aAntiClockwise && (aStartAngle < aEndAngle)) {
+    Float correction = (Float)ceil((aEndAngle - aStartAngle) / (2.0f * M_PI));
+    aStartAngle += float(correction * 2.0f * M_PI);
+  }
+
+  // Sweeping more than 2 * pi is a full circle.
+  if (!aAntiClockwise && (aEndAngle - aStartAngle > 2 * M_PI)) {
+    aEndAngle = float(aStartAngle + 2.0f * M_PI);
+  } else if (aAntiClockwise && (aStartAngle - aEndAngle > 2.0f * M_PI)) {
+    aEndAngle = float(aStartAngle - 2.0f * M_PI);
+  }
+
+  // Calculate the total arc we're going to sweep.
+  Float arcSweepLeft = fabs(aEndAngle - aStartAngle);
+
+  Float sweepDirection = aAntiClockwise ? -1.0f : 1.0f;
+
+  Float currentStartAngle = aStartAngle;
+
+  while (arcSweepLeft > 0) {
+    // We guarantee here the current point is the start point of the next
+    // curve segment.
+    Float currentEndAngle;
+
+    if (arcSweepLeft > M_PI / 2.0f) {
+      currentEndAngle = Float(currentStartAngle + M_PI / 2.0f * sweepDirection);
+    } else {
+      currentEndAngle = currentStartAngle + arcSweepLeft * sweepDirection;
+    }
+
+    Point currentStartPoint(aOrigin.x + cos(currentStartAngle) * aRadius.width,
+                            aOrigin.y + sin(currentStartAngle) * aRadius.height);
+    Point currentEndPoint(aOrigin.x + cos(currentEndAngle) * aRadius.width,
+                          aOrigin.y + sin(currentEndAngle) * aRadius.height);
+
+    // Calculate kappa constant for partial curve. The sign of angle in the
+    // tangent will actually ensure this is negative for a counter clockwise
+    // sweep, so changing signs later isn't needed.
+    Float kappaFactor = (4.0f / 3.0f) * tan((currentEndAngle - currentStartAngle) / 4.0f);
+    Float kappaX = kappaFactor * aRadius.width;
+    Float kappaY = kappaFactor * aRadius.height;
+
+    Point tangentStart(-sin(currentStartAngle), cos(currentStartAngle));
+    Point cp1 = currentStartPoint;
+    cp1 += Point(tangentStart.x * kappaX, tangentStart.y * kappaY);
+
+    Point revTangentEnd(sin(currentEndAngle), -cos(currentEndAngle));
+    Point cp2 = currentEndPoint;
+    cp2 += Point(revTangentEnd.x * kappaX, revTangentEnd.y * kappaY);
+
+    aSink->BezierTo(cp1, cp2, currentEndPoint);
+
+    arcSweepLeft -= Float(M_PI / 2.0f);
+    currentStartAngle = currentEndAngle;
+  }
+}
+
+/**
+ * Appends a path represending a rounded rectangle to the path being built by
+ * aPathBuilder.
+ *
+ * aRect           The rectangle to append.
+ * aCornerRadii    Contains the radii of the top-left, top-right, bottom-right
+ *                 and bottom-left corners, in that order.
+ * aDrawClockwise  If set to true, the path will start at the left of the top
+ *                 left edge and draw clockwise. If set to false the path will
+ *                 start at the right of the top left edge and draw counter-
+ *                 clockwise.
+ */
+GFX2D_API void AppendRoundedRectToPath(PathBuilder* aPathBuilder,
+                                       const Rect& aRect,
+                                       const Size(& aCornerRadii)[4],
+                                       bool aDrawClockwise = true);
+
+/**
+ * Appends a path represending an ellipse to the path being built by
+ * aPathBuilder.
+ *
+ * The ellipse extends aDimensions.width / 2.0 in the horizontal direction
+ * from aCenter, and aDimensions.height / 2.0 in the vertical direction.
+ */
+GFX2D_API void AppendEllipseToPath(PathBuilder* aPathBuilder,
+                                   const Point& aCenter,
+                                   const Size& aDimensions);
+
+static inline bool
+UserToDevicePixelSnapped(Rect& aRect, const Matrix& aTransform)
+{
+  Point p1 = aTransform * aRect.TopLeft();
+  Point p2 = aTransform * aRect.TopRight();
+  Point p3 = aTransform * aRect.BottomRight();
+
+  // Check that the rectangle is axis-aligned. For an axis-aligned rectangle,
+  // two opposite corners define the entire rectangle. So check if
+  // the axis-aligned rectangle with opposite corners p1 and p3
+  // define an axis-aligned rectangle whose other corners are p2 and p4.
+  // We actually only need to check one of p2 and p4, since an affine
+  // transform maps parallelograms to parallelograms.
+  if (p2 == Point(p1.x, p3.y) || p2 == Point(p3.x, p1.y)) {
+      p1.Round();
+      p3.Round();
+
+      aRect.MoveTo(Point(std::min(p1.x, p3.x), std::min(p1.y, p3.y)));
+      aRect.SizeTo(Size(std::max(p1.x, p3.x) - aRect.X(),
+                        std::max(p1.y, p3.y) - aRect.Y()));
+      return true;
+  }
+
+  return false;
+}
+
+} // namespace gfx
+} // namespace mozilla
+
+#endif /* MOZILLA_GFX_PATHHELPERS_H_ */