diff -r 000000000000 -r 6474c204b198 gfx/2d/PathSkia.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/2d/PathSkia.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,245 @@
+/* -*- 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/. */
+
+#include "PathSkia.h"
+#include <math.h>
+#include "DrawTargetSkia.h"
+#include "Logging.h"
+#include "HelpersSkia.h"
+#include "PathHelpers.h"
+
+namespace mozilla {
+namespace gfx {
+
+PathBuilderSkia::PathBuilderSkia(const Matrix& aTransform, const SkPath& aPath, FillRule aFillRule)
+  : mPath(aPath)
+{
+  SkMatrix matrix;
+  GfxMatrixToSkiaMatrix(aTransform, matrix);
+  mPath.transform(matrix);
+  SetFillRule(aFillRule);
+}
+
+PathBuilderSkia::PathBuilderSkia(FillRule aFillRule)
+{
+  SetFillRule(aFillRule);
+}
+
+void
+PathBuilderSkia::SetFillRule(FillRule aFillRule)
+{
+  mFillRule = aFillRule;
+  if (mFillRule == FillRule::FILL_WINDING) {
+    mPath.setFillType(SkPath::kWinding_FillType);
+  } else {
+    mPath.setFillType(SkPath::kEvenOdd_FillType);
+  }
+}
+
+void
+PathBuilderSkia::MoveTo(const Point &aPoint)
+{
+  mPath.moveTo(SkFloatToScalar(aPoint.x), SkFloatToScalar(aPoint.y));
+}
+
+void
+PathBuilderSkia::LineTo(const Point &aPoint)
+{
+  if (!mPath.countPoints()) {
+    MoveTo(aPoint);
+  } else {
+    mPath.lineTo(SkFloatToScalar(aPoint.x), SkFloatToScalar(aPoint.y));
+  }
+}
+
+void
+PathBuilderSkia::BezierTo(const Point &aCP1,
+                          const Point &aCP2,
+                          const Point &aCP3)
+{
+  if (!mPath.countPoints()) {
+    MoveTo(aCP1);
+  }
+  mPath.cubicTo(SkFloatToScalar(aCP1.x), SkFloatToScalar(aCP1.y),
+                SkFloatToScalar(aCP2.x), SkFloatToScalar(aCP2.y),
+                SkFloatToScalar(aCP3.x), SkFloatToScalar(aCP3.y));
+}
+
+void
+PathBuilderSkia::QuadraticBezierTo(const Point &aCP1,
+                                   const Point &aCP2)
+{
+  if (!mPath.countPoints()) {
+    MoveTo(aCP1);
+  }
+  mPath.quadTo(SkFloatToScalar(aCP1.x), SkFloatToScalar(aCP1.y),
+               SkFloatToScalar(aCP2.x), SkFloatToScalar(aCP2.y));
+}
+
+void
+PathBuilderSkia::Close()
+{
+  mPath.close();
+}
+
+void
+PathBuilderSkia::Arc(const Point &aOrigin, float aRadius, float aStartAngle,
+                     float aEndAngle, bool aAntiClockwise)
+{
+  ArcToBezier(this, aOrigin, Size(aRadius, aRadius), aStartAngle, aEndAngle, aAntiClockwise);
+}
+
+Point
+PathBuilderSkia::CurrentPoint() const
+{
+  int pointCount = mPath.countPoints();
+  if (!pointCount) {
+    return Point(0, 0);
+  }
+  SkPoint point = mPath.getPoint(pointCount - 1);
+  return Point(SkScalarToFloat(point.fX), SkScalarToFloat(point.fY));
+}
+
+TemporaryRef<Path>
+PathBuilderSkia::Finish()
+{
+  RefPtr<PathSkia> path = new PathSkia(mPath, mFillRule);
+  return path;
+}
+
+void
+PathBuilderSkia::AppendPath(const SkPath &aPath)
+{
+  mPath.addPath(aPath);
+}
+
+TemporaryRef<PathBuilder>
+PathSkia::CopyToBuilder(FillRule aFillRule) const
+{
+  return TransformedCopyToBuilder(Matrix(), aFillRule);
+}
+
+TemporaryRef<PathBuilder>
+PathSkia::TransformedCopyToBuilder(const Matrix &aTransform, FillRule aFillRule) const
+{
+  RefPtr<PathBuilderSkia> builder = new PathBuilderSkia(aTransform, mPath, aFillRule);
+  return builder;
+}
+
+bool
+PathSkia::ContainsPoint(const Point &aPoint, const Matrix &aTransform) const
+{
+  Matrix inverse = aTransform;
+  inverse.Invert();
+  Point transformed = inverse * aPoint;
+
+  Rect bounds = GetBounds(aTransform);
+
+  if (aPoint.x < bounds.x || aPoint.y < bounds.y ||
+      aPoint.x > bounds.XMost() || aPoint.y > bounds.YMost()) {
+    return false;
+  }
+
+  SkRegion pointRect;
+  pointRect.setRect(int32_t(SkFloatToScalar(transformed.x - 1)),
+                    int32_t(SkFloatToScalar(transformed.y - 1)),
+                    int32_t(SkFloatToScalar(transformed.x + 1)),
+                    int32_t(SkFloatToScalar(transformed.y + 1)));
+
+  SkRegion pathRegion;
+  
+  return pathRegion.setPath(mPath, pointRect);
+}
+
+bool
+PathSkia::StrokeContainsPoint(const StrokeOptions &aStrokeOptions,
+                              const Point &aPoint,
+                              const Matrix &aTransform) const
+{
+  Matrix inverse = aTransform;
+  inverse.Invert();
+  Point transformed = inverse * aPoint;
+
+  SkPaint paint;
+  StrokeOptionsToPaint(paint, aStrokeOptions);
+
+  SkPath strokePath;
+  paint.getFillPath(mPath, &strokePath);
+
+  Rect bounds = aTransform.TransformBounds(SkRectToRect(strokePath.getBounds()));
+
+  if (aPoint.x < bounds.x || aPoint.y < bounds.y ||
+      aPoint.x > bounds.XMost() || aPoint.y > bounds.YMost()) {
+    return false;
+  }
+
+  SkRegion pointRect;
+  pointRect.setRect(int32_t(SkFloatToScalar(transformed.x - 1)),
+                    int32_t(SkFloatToScalar(transformed.y - 1)),
+                    int32_t(SkFloatToScalar(transformed.x + 1)),
+                    int32_t(SkFloatToScalar(transformed.y + 1)));
+
+  SkRegion pathRegion;
+  
+  return pathRegion.setPath(strokePath, pointRect);
+}
+
+Rect
+PathSkia::GetBounds(const Matrix &aTransform) const
+{
+  Rect bounds = SkRectToRect(mPath.getBounds());
+  return aTransform.TransformBounds(bounds);
+}
+
+Rect
+PathSkia::GetStrokedBounds(const StrokeOptions &aStrokeOptions,
+                           const Matrix &aTransform) const
+{
+  SkPaint paint;
+  StrokeOptionsToPaint(paint, aStrokeOptions);
+  
+  SkPath result;
+  paint.getFillPath(mPath, &result);
+
+  Rect bounds = SkRectToRect(result.getBounds());
+  return aTransform.TransformBounds(bounds);
+}
+
+void
+PathSkia::StreamToSink(PathSink *aSink) const
+{
+  SkPath::RawIter iter(mPath);
+
+  SkPoint points[4];
+  SkPath::Verb currentVerb;
+  while ((currentVerb = iter.next(points)) != SkPath::kDone_Verb) {
+    switch (currentVerb) {
+    case SkPath::kMove_Verb:
+      aSink->MoveTo(SkPointToPoint(points[0]));
+      break;
+    case SkPath::kLine_Verb:
+      aSink->LineTo(SkPointToPoint(points[1]));
+      break;
+    case SkPath::kCubic_Verb:
+      aSink->BezierTo(SkPointToPoint(points[1]),
+                      SkPointToPoint(points[2]),
+                      SkPointToPoint(points[3]));
+      break;
+    case SkPath::kQuad_Verb:
+      aSink->QuadraticBezierTo(SkPointToPoint(points[1]),
+                               SkPointToPoint(points[2]));
+      break;
+    case SkPath::kClose_Verb:
+      aSink->Close();
+      break;
+    default:
+      MOZ_ASSERT(false);
+      // Unexpected verb found in path!
+    }
+  }
+}
+
+}
+}