Refactor the current text position update in SVGTextLayoutEngine

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 20 matching lines @@
 #include "core/svg/SVGLengthContext.h"
 #include "core/svg/SVGTextContentElement.h"
 
 namespace blink {
 
 SVGTextLayoutEngine::SVGTextLayoutEngine(Vector<SVGTextLayoutAttributes*>& layoutAttributes)
     : m_layoutAttributes(layoutAttributes)
     , 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_textPath(nullptr)
     , m_textPathCurrentOffset(0)
+    , m_textPathDisplacement(0)
     , m_textPathSpacing(0)
     , m_textPathScaling(1)
 {
     ASSERT(!m_layoutAttributes.isEmpty());
 }
 
 SVGTextLayoutEngine::~SVGTextLayoutEngine() = default;
 
-void SVGTextLayoutEngine::updateCharacterPositionIfNeeded(float& x, float& y)
+bool SVGTextLayoutEngine::setCurrentTextPositionIfNeeded(const SVGCharacterData& data)
 {
-    if (m_inPathLayout)
-        return;
+    bool hasX = !SVGTextLayoutAttributes::isEmptyValue(data.x);
+    if (hasX)
+        m_ctp.setX(data.x);
 
-    // 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;
+    bool hasY = !SVGTextLayoutAttributes::isEmptyValue(data.y);
+    if (hasY)
+        m_ctp.setY(data.y);
 
-    if (SVGTextLayoutAttributes::isEmptyValue(y))
-        y = m_y + m_dy;
-
-    m_dx = 0;
-    m_dy = 0;
+    // If there's an absolute x/y position available, it marks the beginning of
+    // a new position along the path.
+    if (m_inPathLayout) {
+        // TODO(fs): If a new chunk (== absolute position) is defined while in
+        // path layout mode, alignment should be based on that chunk and not
+        // the path as a whole. (Re: the addition of m_textPathStartOffset
+        // below.)
+        if (m_isVerticalText) {
+            if (hasY)
+                m_textPathCurrentOffset = data.y + m_textPathStartOffset;
+        } else {
+            if (hasX)
+                m_textPathCurrentOffset = data.x + m_textPathStartOffset;
+        }
+    }
+    return hasX || hasY;
 }
 
-void SVGTextLayoutEngine::updateCurrentTextPosition(float x, float y, float glyphAdvance)
+void SVGTextLayoutEngine::advanceCurrentTextPosition(float glyphAdvance)
 {
-    // Update current text position after processing the character.
-    if (m_isVerticalText) {
-        m_x = x;
-        m_y = y + glyphAdvance;
-    } else {
-        m_x = x + glyphAdvance;
-        m_y = y;
-    }
+    // TODO(fs): m_textPathCurrentOffset should preferably also be updated
+    // here, but that requires a bit more untangling yet.
+    if (m_isVerticalText)
+        m_ctp.setY(m_ctp.y() + glyphAdvance);
+    else
+        m_ctp.setX(m_ctp.x() + glyphAdvance);
 }
 
-void SVGTextLayoutEngine::updateRelativePositionAdjustmentsIfNeeded(float dx, float dy)
+bool SVGTextLayoutEngine::applyRelativePositionAdjustmentsIfNeeded(const SVGCharacterData& data)
 {
-    // Update relative positioning information.
-    if (SVGTextLayoutAttributes::isEmptyValue(dx) && SVGTextLayoutAttributes::isEmptyValue(dy))
-        return;
+    FloatPoint delta;
+    bool hasDx = !SVGTextLayoutAttributes::isEmptyValue(data.dx);
+    if (hasDx)
+        delta.setX(data.dx);
 
-    if (SVGTextLayoutAttributes::isEmptyValue(dx))
-        dx = 0;
-    if (SVGTextLayoutAttributes::isEmptyValue(dy))
-        dy = 0;
+    bool hasDy = !SVGTextLayoutAttributes::isEmptyValue(data.dy);
+    if (hasDy)
+        delta.setY(data.dy);
+
+    // Apply dx/dy value adjustments to current text position, if needed.
+    m_ctp.moveBy(delta);
 
     if (m_inPathLayout) {
-        if (m_isVerticalText) {
-            m_dx += dx;
-            m_dy = dy;
-        } else {
-            m_dx = dx;
-            m_dy += dy;
-        }
+        if (m_isVerticalText)
+            delta = delta.transposedPoint();
 
-        return;
+        m_textPathCurrentOffset += delta.x();
+        m_textPathDisplacement += delta.y();
     }
-
-    m_dx = dx;
-    m_dy = dy;
+    return hasDx || hasDy;
 }
 
 void SVGTextLayoutEngine::computeCurrentFragmentMetrics(SVGInlineTextBox* textBox)
 {
     LineLayoutSVGInlineText textLineLayout = LineLayoutSVGInlineText(textBox->getLineLayoutItem());
     TextRun run = textBox->constructTextRun(textLineLayout.styleRef(), m_currentTextFragment);
 
     float scalingFactor = textLineLayout.scalingFactor();
     ASSERT(scalingFactor);
     const Font& scaledFont = textLineLayout.scaledFont();
@@ skipping 216 matching lines @@
     // 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());
 
     bool didStartTextFragment = false;
     bool applySpacingToNextCharacter = false;
+    bool needsFragmentPerGlyph = m_isVerticalText || m_inPathLayout || m_textLengthSpacingInEffect;
 
     float lastAngle = 0;
-    float baselineShift = baselineLayout.calculateBaselineShift(style);
-    baselineShift -= baselineLayout.calculateAlignmentBaselineShift(m_isVerticalText, textLineLayout);
+    float baselineShiftValue = baselineLayout.calculateBaselineShift(style);
+    baselineShiftValue -= baselineLayout.calculateAlignmentBaselineShift(m_isVerticalText, textLineLayout);
+    FloatPoint baselineShift;
+    if (m_isVerticalText)
+        baselineShift.setX(baselineShiftValue);
+    else
+        baselineShift.setY(-baselineShiftValue);
 
     // Main layout algorithm.
     const unsigned boxEndOffset = textBox->start() + textBox->len();
     while (!m_visualMetricsIterator.isAtEnd() && m_visualMetricsIterator.characterOffset() < boxEndOffset) {
         const SVGTextMetrics& visualMetrics = m_visualMetricsIterator.metrics();
         if (visualMetrics.isEmpty()) {
             m_visualMetricsIterator.next();
             continue;
         }
 
         SVGTextLayoutAttributes* logicalAttributes = nullptr;
         if (!currentLogicalCharacterAttributes(logicalAttributes))
             break;
 
         ASSERT(logicalAttributes);
         SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
         if (!currentLogicalCharacterMetrics(logicalAttributes, logicalMetrics))
             break;
 
         SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
         SVGCharacterData data;
         SVGCharacterDataMap::iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
         if (it != characterDataMap.end())
             data = it->value;
 
-        float x = data.x;
-        float y = data.y;
+        // TODO(fs): Use the return value to eliminate the additional
+        // hash-lookup below when determining if this text box should be tagged
+        // as starting a new text chunk.
+        setCurrentTextPositionIfNeeded(data);
 
         // When we've advanced to the box start offset, determine using the original x/y values,

[pdr., 2016/04/14 01:05:51]

This code is sandwiched between setCurrentTextPositionIfNeeded and
applyRelativePositionAdjustmentsIfNeeded but neither function affects it. WDYT
of joining setCurrentTextPositionIfNeeded and
applyRelativePositionAdjustmentsIfNeeded into a single function, or moving the
calls next to each other?

[fs, 2016/04/14 08:56:42]

As I tried to note in the TODO above, I intend for the result of
setCurrentTextPosition to feed into this - so the  sandwich structure is
intentional. (I'm also pondering if this and the above can be hoisted out of the
loop.)

         // whether this character starts a new text chunk, before doing any further processing.
         if (m_visualMetricsIterator.characterOffset() == textBox->start())
             textBox->setStartsNewTextChunk(logicalAttributes->context()->characterStartsNewTextChunk(m_logicalCharacterOffset));
 
-        float angle = SVGTextLayoutAttributes::isEmptyValue(data.rotate) ? 0 : data.rotate;
+        bool hasRelativePosition = applyRelativePositionAdjustmentsIfNeeded(data);
 
-        // Calculate glyph orientation angle.
+        // Determine the orientation of the current glyph.
         // Font::width() calculates the resolved FontOrientation for each character,
-        // but is not exposed today to avoid the API complexity.
+        // but that value is not exposed today to avoid the API complexity.
         UChar32 currentCharacter = textLineLayout.codepointAt(m_visualMetricsIterator.characterOffset());
         FontOrientation fontOrientation = font.getFontDescription().orientation();
         fontOrientation = adjustOrientationForCharacterInMixedVertical(fontOrientation, currentCharacter);
 
         // Calculate glyph advance.
-        // Shaping engine takes care of x/y orientation shifts for different fontOrientation values.
+        // The shaping engine takes care of x/y orientation shifts for different fontOrientation values.
         float glyphAdvance = visualMetrics.advance(fontOrientation);
 
-        // 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.
+        // Calculate CSS 'letter-spacing' and 'word-spacing' for the character, if needed.
         float spacing = spacingLayout.calculateCSSSpacing(currentCharacter);
 
-        float textPathShiftX = 0;
-        float textPathShiftY = 0;
+        FloatPoint textPathShift;
+        float angle = 0;
+        FloatPoint position;
         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;
-            }
+            // Setup translations that move to the glyph midpoint.
+            textPathShift.set(-scaledGlyphAdvance / 2, m_textPathDisplacement);
+            if (m_isVerticalText)
+                textPathShift = textPathShift.transposedPoint();
+            textPathShift += baselineShift;
 
             // Calculate current offset along path.
             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);
+            PathPositionMapper::PositionType positionType = m_textPath->pointAndNormalAtLength(textPathOffset, position, angle);
 
             // Skip character, if we're before the path.
             if (positionType == PathPositionMapper::BeforePath) {
                 advanceToNextLogicalCharacter(logicalMetrics);
                 m_visualMetricsIterator.next();
                 continue;
             }
 
             // Stop processing if the next character lies behind the path.
             if (positionType == PathPositionMapper::AfterPath)
                 break;
 
-            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;
-            else
-                y -= baselineShift;
-
-            x += m_dx;
-            y += m_dy;
+            position = m_ctp;
+            position += baselineShift;
         }
 
+        if (!SVGTextLayoutAttributes::isEmptyValue(data.rotate))
+            angle += data.rotate;
+
         // Determine whether we have to start a new fragment.
-        bool shouldStartNewFragment = m_dx || m_dy || m_isVerticalText || m_inPathLayout || angle || angle != lastAngle
-            || applySpacingToNextCharacter || m_textLengthSpacingInEffect;
+        bool shouldStartNewFragment = needsFragmentPerGlyph || hasRelativePosition
+            || angle || angle != lastAngle || applySpacingToNextCharacter;
 
         // If we already started a fragment, close it now.
         if (didStartTextFragment && shouldStartNewFragment) {
             applySpacingToNextCharacter = false;
             recordTextFragment(textBox);
         }
 
         // Eventually start a new fragment, if not yet done.
         if (!didStartTextFragment || shouldStartNewFragment) {
             ASSERT(!m_currentTextFragment.characterOffset);
             ASSERT(!m_currentTextFragment.length);
 
             didStartTextFragment = true;
             m_currentTextFragment.characterOffset = m_visualMetricsIterator.characterOffset();
             m_currentTextFragment.metricsListOffset = m_visualMetricsIterator.metricsListOffset();
-            m_currentTextFragment.x = x;
-            m_currentTextFragment.y = y;
+            m_currentTextFragment.x = position.x();
+            m_currentTextFragment.y = position.y();
 
             // Build fragment transformation.
             if (angle)
                 m_currentTextFragment.transform.rotate(angle);
 
-            if (textPathShiftX || textPathShiftY)
-                m_currentTextFragment.transform.translate(textPathShiftX, textPathShiftY);
+            if (textPathShift.x() || textPathShift.y())
+                m_currentTextFragment.transform.translate(textPathShift.x(), textPathShift.y());
 
-            // In vertical text, always rotate by 90 degrees regardless of fontOrientation.
-            // Shaping engine takes care of the necessary orientation.
+            // For vertical text, always rotate by 90 degrees regardless of fontOrientation.
+            // The shaping engine takes care of the necessary orientation.
             if (m_isVerticalText)
                 m_currentTextFragment.transform.rotate(90);
 
             m_currentTextFragment.isVertical = m_isVerticalText;
             m_currentTextFragment.isTextOnPath = m_inPathLayout && m_textPathScaling != 1;
             if (m_currentTextFragment.isTextOnPath)
                 m_currentTextFragment.lengthAdjustScale = m_textPathScaling;
         }
 
-        // Update current text position, after processing of the current character finished.
-        if (m_inPathLayout) {
-            updateCurrentTextPosition(x, y, glyphAdvance);
-        } else {
-            // Apply CSS 'kerning', 'letter-spacing' and 'word-spacing' to next character, if needed.
-            if (spacing)
-                applySpacingToNextCharacter = true;
+        // Advance current text position after processing of the current character finished.
+        advanceCurrentTextPosition(glyphAdvance + spacing);
 
-            float xNew = x - m_dx;
-            float yNew = y - m_dy;
-
-            if (m_isVerticalText)
-                xNew -= baselineShift;
-            else
-                yNew += baselineShift;
-
-            updateCurrentTextPosition(xNew, yNew, glyphAdvance + spacing);
-        }
+        // Apply CSS 'letter-spacing' and 'word-spacing' to the next character, if needed.
+        if (!m_inPathLayout && spacing)
+            applySpacingToNextCharacter = true;
 
         advanceToNextLogicalCharacter(logicalMetrics);
         m_visualMetricsIterator.next();
         lastAngle = angle;
     }
 
     if (!didStartTextFragment)
         return;
 
     // Close last open fragment, if needed.
     recordTextFragment(textBox);
 }
 
 } // namespace blink