Factor out the <textPath> positioning mapping code into a helper class

third_party/WebKit/Source/core/layout/svg/SVGTextLayoutEngine.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 27 matching lines @@
     , m_layoutAttributesPosition(0)
     , m_logicalCharacterOffset(0)
     , m_logicalMetricsListOffset(0)
     , m_x(0)
     , m_y(0)
     , m_dx(0)
     , m_dy(0)
     , m_isVerticalText(false)
     , m_inPathLayout(false)
     , m_textLengthSpacingInEffect(false)
-    , m_textPathCalculator(nullptr)
-    , m_textPathLength(0)
+    , m_textPath(nullptr)
     , m_textPathCurrentOffset(0)
     , m_textPathSpacing(0)
     , m_textPathScaling(1)
 {
     ASSERT(!m_layoutAttributes.isEmpty());
 }
 
+SVGTextLayoutEngine::~SVGTextLayoutEngine() = default;
+
 void SVGTextLayoutEngine::updateCharacterPositionIfNeeded(float& x, float& y)
 {
     if (m_inPathLayout)
         return;
 
     // Replace characters x/y position, with the current text position plus any
     // relative adjustments, if it doesn't specify an absolute position itself.
     if (SVGTextLayoutAttributes::isEmptyValue(x))
         x = m_x + m_dx;
 
@@ skipping 100 matching lines @@
 {
     // Build text chunks for all <textPath> children, using the line layout algorithm.
     // This is needeed as text-anchor is just an additional startOffset for text paths.
     SVGTextLayoutEngine lineLayout(m_layoutAttributes);
     lineLayout.m_textLengthSpacingInEffect = m_textLengthSpacingInEffect;
     lineLayout.layoutCharactersInTextBoxes(flowBox);
 
     m_inPathLayout = true;
     LineLayoutSVGTextPath textPath = LineLayoutSVGTextPath(flowBox->lineLayoutItem());
 
-    Path path = textPath.layoutPath();
-    if (path.isEmpty())
+    m_textPath = textPath.layoutPath();
+    if (!m_textPath)
         return;
-    m_textPathCalculator = new Path::PositionCalculator(path);
-    m_textPathLength = path.length();
-    m_textPathStartOffset = textPath.calculateStartOffset(m_textPathLength);
+    m_textPathStartOffset = textPath.calculateStartOffset(m_textPath->length());
 
     SVGTextPathChunkBuilder textPathChunkLayoutBuilder;
     textPathChunkLayoutBuilder.processTextChunks(lineLayout.m_lineLayoutBoxes);
 
     m_textPathStartOffset += textPathChunkLayoutBuilder.totalTextAnchorShift();
     m_textPathCurrentOffset = m_textPathStartOffset;
 
     // Eventually handle textLength adjustments.
     SVGLengthAdjustType lengthAdjust = SVGLengthAdjustUnknown;
     float desiredTextLength = 0;
@@ skipping 13 matching lines @@
     float totalLength = textPathChunkLayoutBuilder.totalLength();
     if (lengthAdjust == SVGLengthAdjustSpacing)
         m_textPathSpacing = (desiredTextLength - totalLength) / textPathChunkLayoutBuilder.totalCharacters();
     else
         m_textPathScaling = desiredTextLength / totalLength;
 }
 
 void SVGTextLayoutEngine::endTextPathLayout()
 {
     m_inPathLayout = false;
-    delete m_textPathCalculator;
-    m_textPathCalculator = 0;
-    m_textPathLength = 0;
+    m_textPath = nullptr;
     m_textPathStartOffset = 0;
     m_textPathCurrentOffset = 0;
     m_textPathSpacing = 0;
     m_textPathScaling = 1;
 }
 
 void SVGTextLayoutEngine::layoutInlineTextBox(SVGInlineTextBox* textBox)
 {
     ASSERT(textBox);
 
@@ skipping 114 matching lines @@
 }
 
 void SVGTextLayoutEngine::advanceToNextLogicalCharacter(const SVGTextMetrics& logicalMetrics)
 {
     ++m_logicalMetricsListOffset;
     m_logicalCharacterOffset += logicalMetrics.length();
 }
 
 void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, LineLayoutSVGInlineText textLineLayout, const ComputedStyle& style)
 {
-    if (m_inPathLayout && !m_textPathCalculator)
+    if (m_inPathLayout && !m_textPath)
         return;
 
     // Find the start of the current text box in the metrics list.
     m_visualMetricsIterator.advanceToTextStart(textLineLayout, textBox->start());
 
     const Font& font = style.font();
 
     SVGTextLayoutEngineSpacing spacingLayout(font, style.effectiveZoom());
     SVGTextLayoutEngineBaseline baselineLayout(font, style.effectiveZoom());
 
@@ skipping 51 matching lines @@
 
         // Assign current text position to x/y values, if needed.
         updateCharacterPositionIfNeeded(x, y);
 
         // Apply dx/dy value adjustments to current text position, if needed.
         updateRelativePositionAdjustmentsIfNeeded(data.dx, data.dy);
 
         // Calculate CSS 'letter-spacing' and 'word-spacing' for next character, if needed.
         float spacing = spacingLayout.calculateCSSSpacing(currentCharacter);
 
-        float textPathOffset = 0;
         float textPathShiftX = 0;
         float textPathShiftY = 0;
         if (m_inPathLayout) {
             float scaledGlyphAdvance = glyphAdvance * m_textPathScaling;
             if (m_isVerticalText) {
                 // If there's an absolute y position available, it marks the beginning of a new position along the path.
                 if (!SVGTextLayoutAttributes::isEmptyValue(y))
                     m_textPathCurrentOffset = y + m_textPathStartOffset;
 
                 m_textPathCurrentOffset += m_dy;
                 m_dy = 0;
 
                 // Apply dx/dy correction and setup translations that move to the glyph midpoint.
                 textPathShiftX += m_dx + baselineShift;
                 textPathShiftY -= scaledGlyphAdvance / 2;
             } else {
                 // If there's an absolute x position available, it marks the beginning of a new position along the path.
                 if (!SVGTextLayoutAttributes::isEmptyValue(x))
                     m_textPathCurrentOffset = x + m_textPathStartOffset;
 
                 m_textPathCurrentOffset += m_dx;
                 m_dx = 0;
 
                 // Apply dx/dy correction and setup translations that move to the glyph midpoint.
                 textPathShiftX -= scaledGlyphAdvance / 2;
                 textPathShiftY += m_dy - baselineShift;
             }
 
             // Calculate current offset along path.
-            textPathOffset = m_textPathCurrentOffset + scaledGlyphAdvance / 2;
+            float textPathOffset = m_textPathCurrentOffset + scaledGlyphAdvance / 2;
 
             // Move to next character.
             m_textPathCurrentOffset += scaledGlyphAdvance + m_textPathSpacing + spacing * m_textPathScaling;
 
+            FloatPoint point;
+            PathPositionMapper::PositionType positionType = m_textPath->pointAndNormalAtLength(textPathOffset, point, angle);
+
             // Skip character, if we're before the path.
-            if (textPathOffset < 0) {
+            if (positionType == PathPositionMapper::BeforePath) {
                 advanceToNextLogicalCharacter(logicalMetrics);
                 m_visualMetricsIterator.next();
                 continue;
             }
 
-            // Stop processing, if the next character lies behind the path.
-            if (textPathOffset > m_textPathLength)
+            // Stop processing if the next character lies behind the path.
+            if (positionType == PathPositionMapper::AfterPath)
                 break;
 
-            FloatPoint point;
-            m_textPathCalculator->pointAndNormalAtLength(textPathOffset, point, angle);
             x = point.x();
             y = point.y();
 
             // For vertical text on path, the actual angle has to be rotated 90 degrees anti-clockwise, not the orientation angle!
             if (m_isVerticalText)
                 angle -= 90;
         } else {
             // Apply all previously calculated shift values.
             if (m_isVerticalText)
                 x += baselineShift;
@@ skipping 68 matching lines @@
     }
 
     if (!didStartTextFragment)
         return;
 
     // Close last open fragment, if needed.
     recordTextFragment(textBox);
 }
 
 } // namespace blink