Track if textLength spacing is in effect while walking the line box tree

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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/layout/svg/SVGTextLayoutEngine.h"
 
 #include "core/layout/svg/LayoutSVGInlineText.h"
 #include "core/layout/svg/LayoutSVGTextPath.h"
 #include "core/layout/svg/SVGTextChunkBuilder.h"
 #include "core/layout/svg/SVGTextLayoutEngineBaseline.h"
 #include "core/layout/svg/SVGTextLayoutEngineSpacing.h"
+#include "core/layout/svg/line/SVGInlineFlowBox.h"
 #include "core/layout/svg/line/SVGInlineTextBox.h"
 #include "core/svg/SVGElement.h"
 #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_textPathCalculator(0)
     , m_textPathLength(0)
     , m_textPathCurrentOffset(0)
     , m_textPathSpacing(0)
     , m_textPathScaling(1)
 {
     ASSERT(!m_layoutAttributes.isEmpty());
 }
 
 void SVGTextLayoutEngine::updateCharacterPositionIfNeeded(float& x, float& y)
@@ skipping 77 matching lines @@
             for (unsigned i = m_currentTextFragment.metricsListOffset; i < visualMetricsListOffset; ++i)
                 length += textMetricsValues.at(i).width();
             m_currentTextFragment.width = length;
         }
     }
 
     textBox->textFragments().append(m_currentTextFragment);
     m_currentTextFragment = SVGTextFragment();
 }
 
-bool SVGTextLayoutEngine::parentDefinesTextLength(LayoutObject* parent) const
+void SVGTextLayoutEngine::beginTextPathLayout(SVGInlineFlowBox* flowBox)
 {
-    LayoutObject* currentParent = parent;
-    while (currentParent) {
-        if (SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromLayoutObject(currentParent)) {
-            SVGLengthContext lengthContext(textContentElement);
-            if (textContentElement->lengthAdjust()->currentValue()->enumValue() == SVGLengthAdjustSpacing && textContentElement->textLengthIsSpecifiedByUser())
-                return true;
-        }
-
-        if (currentParent->isSVGText())
-            return false;
-
-        currentParent = currentParent->parent();
-    }
-
-    ASSERT_NOT_REACHED();
-    return false;
-}
-
-void SVGTextLayoutEngine::beginTextPathLayout(LayoutObject* object, SVGTextLayoutEngine& lineLayout)
-{
-    ASSERT(object);
+    // 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;
-    LayoutSVGTextPath* textPath = toLayoutSVGTextPath(object);
+    LayoutSVGTextPath* textPath = &toLayoutSVGTextPath(flowBox->layoutObject());
 
     Path path = textPath->layoutPath();
     if (path.isEmpty())
         return;
     m_textPathCalculator = new Path::PositionCalculator(path);
     m_textPathStartOffset = textPath->startOffset();
     m_textPathLength = path.length();
     if (m_textPathStartOffset > 0 && m_textPathStartOffset <= 1)
         m_textPathStartOffset *= m_textPathLength;
 
@@ skipping 52 matching lines @@
     textBox->clearTextFragments();
     m_isVerticalText = style.svgStyle().isVerticalWritingMode();
     layoutTextOnLineOrPath(textBox, text, style);
 
     if (m_inPathLayout)
         return;
 
     m_lineLayoutBoxes.append(textBox);
 }
 
+static bool definesTextLengthWithSpacing(const InlineFlowBox* start)
+{
+    SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromLayoutObject(&start->layoutObject());
+    return textContentElement
+        && textContentElement->lengthAdjust()->currentValue()->enumValue() == SVGLengthAdjustSpacing
+        && textContentElement->textLengthIsSpecifiedByUser();
+}
+
+void SVGTextLayoutEngine::layoutCharactersInTextBoxes(InlineFlowBox* start)
+{
+    bool textLengthSpacingInEffect = m_textLengthSpacingInEffect || definesTextLengthWithSpacing(start);
+    TemporaryChange<bool> textLengthSpacingScope(m_textLengthSpacingInEffect, textLengthSpacingInEffect);
+
+    for (InlineBox* child = start->firstChild(); child; child = child->nextOnLine()) {
+        if (child->isSVGInlineTextBox()) {
+            ASSERT(child->layoutObject().isSVGInlineText());
+            layoutInlineTextBox(toSVGInlineTextBox(child));
+        } else {
+            // Skip generated content.
+            Node* node = child->layoutObject().node();
+            if (!node)
+                continue;
+
+            SVGInlineFlowBox* flowBox = toSVGInlineFlowBox(child);
+            bool isTextPath = isSVGTextPathElement(*node);
+            if (isTextPath)
+                beginTextPathLayout(flowBox);
+
+            layoutCharactersInTextBoxes(flowBox);
+
+            if (isTextPath)
+                endTextPathLayout();
+        }
+    }
+}
+
 void SVGTextLayoutEngine::finishLayout()
 {
     m_visualMetricsIterator = SVGInlineTextMetricsIterator();
 
     // After all text fragments are stored in their correpsonding SVGInlineTextBoxes, we can layout individual text chunks.
     // Chunk layouting is only performed for line layout boxes, not for path layout, where it has already been done.
     SVGTextChunkBuilder chunkLayoutBuilder;
     chunkLayoutBuilder.processTextChunks(m_lineLayoutBoxes);
 
     // Finalize transform matrices, after the chunk layout corrections have been applied, and all fragment x/y positions are finalized.
@@ skipping 58 matching lines @@
 {
     ++m_logicalMetricsListOffset;
     m_logicalCharacterOffset += logicalMetrics.length();
 }
 
 void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, const LayoutSVGInlineText& text, const ComputedStyle& style)
 {
     if (m_inPathLayout && !m_textPathCalculator)
         return;
 
-    LayoutObject* textParent = text.parent();
-    bool definesTextLength = textParent ? parentDefinesTextLength(textParent) : false;
-
     const SVGComputedStyle& svgStyle = style.svgStyle();
 
     // Find the start of the current text box in the metrics list.
     m_visualMetricsIterator.advanceToTextStart(&text, textBox->start());
 
     const Font& font = style.font();
 
     SVGTextLayoutEngineSpacing spacingLayout(font, style.effectiveZoom());
     SVGTextLayoutEngineBaseline baselineLayout(font, style.effectiveZoom());
 
@@ skipping 115 matching lines @@
                 x += baselineShift;
             else
                 y -= baselineShift;
 
             x += m_dx;
             y += m_dy;
         }
 
         // Determine whether we have to start a new fragment.
         bool shouldStartNewFragment = m_dx || m_dy || m_isVerticalText || m_inPathLayout || angle || angle != lastAngle
-            || orientationAngle || applySpacingToNextCharacter || definesTextLength;
+            || orientationAngle || applySpacingToNextCharacter || m_textLengthSpacingInEffect;
 
         // 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);
@@ skipping 49 matching lines @@
     }
 
     if (!didStartTextFragment)
         return;
 
     // Close last open fragment, if needed.
     recordTextFragment(textBox);
 }
 
 }