Optimize glyph positioning for SVG <textPath> layout

Source/platform/graphics/Path.cpp

 /*
  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
  *                     2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 18 matching lines @@
 
 #include "config.h"
 #include "platform/graphics/Path.h"
 
 #include <math.h>
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/transforms/AffineTransform.h"
-#include "third_party/skia/include/core/SkPathMeasure.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "wtf/MathExtras.h"
 
 namespace WebCore {
 
 Path::Path()
     : m_path()
 {
 }
 
@@ skipping 120 matching lines @@
 }
 
 float Path::normalAngleAtLength(float length, bool& ok) const
 {
     FloatPoint point;
     float normal;
     ok = pointAndNormalAtLength(length, point, normal);
     return normal;
 }
 
-bool Path::pointAndNormalAtLength(float length, FloatPoint& point, float& normal) const
+static bool calculatePointAndNormalOnPath(SkPathMeasure& measure, SkScalar length, FloatPoint& point, float& normalAngle, SkScalar* accumulatedLength = 0)
 {
-    SkPathMeasure measure(m_path, false);
-
     do {
         SkScalar contourLength = measure.getLength();
         if (length <= contourLength) {
             SkVector tangent;
             SkPoint position;
 
             if (measure.getPosTan(length, &position, &tangent)) {
-                normal = rad2deg(SkScalarToFloat(SkScalarATan2(tangent.fY, tangent.fX)));
+                normalAngle = rad2deg(SkScalarToFloat(SkScalarATan2(tangent.fY, tangent.fX)));
                 point = FloatPoint(SkScalarToFloat(position.fX), SkScalarToFloat(position.fY));
                 return true;
             }
         }
         length -= contourLength;
+        if (accumulatedLength)
+            *accumulatedLength += contourLength;
     } while (measure.nextContour());
+    return false;
+}
+
+bool Path::pointAndNormalAtLength(float length, FloatPoint& point, float& normal) const
+{
+    SkPathMeasure measure(m_path, false);
+
+    if (calculatePointAndNormalOnPath(measure, WebCoreFloatToSkScalar(length), point, normal))
+        return true;
 
     normal = 0;
     point = FloatPoint(0, 0);
     return false;
 }
 
+Path::PositionCalculator::PositionCalculator(const Path& path)
+    : m_path(path.skPath())
+    , m_pathMeasure(path.skPath(), false)
+    , m_accumulatedLength(0)
+{
+}
+
+bool Path::PositionCalculator::pointAndNormalAtLength(float length, FloatPoint& point, float& normalAngle)
+{
+    SkScalar skLength = WebCoreFloatToSkScalar(length);
+    if (skLength >= 0) {
+        if (skLength < m_accumulatedLength) {
+            // Reset path measurer to rewind (and restart from 0).
+            m_pathMeasure.setPath(&m_path, false);
+            m_accumulatedLength = 0;
+        } else {
+            skLength -= m_accumulatedLength;
+        }
+
+        if (calculatePointAndNormalOnPath(m_pathMeasure, skLength, point, normalAngle, &m_accumulatedLength))
+            return true;
+    }
+
+    normalAngle = 0;
+    point = FloatPoint(0, 0);
+    return false;
+}
+
 void Path::clear()
 {
     m_path.reset();
 }
 
 bool Path::isEmpty() const
 {
     return m_path.isEmpty();
 }
 
@@ skipping 234 matching lines @@
 
 #if !ASSERT_DISABLED
 bool ellipseIsRenderable(float startAngle, float endAngle)
 {
     return (std::abs(endAngle - startAngle) < 2 * piFloat)
         || WebCoreFloatNearlyEqual(std::abs(endAngle - startAngle), 2 * piFloat);
 }
 #endif
 
 }