Remove the LayoutSVGInlineText* context in SVGTextLayoutAttributes

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 15 matching lines @@
 #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)
+SVGTextLayoutEngine::SVGTextLayoutEngine(const Vector<LayoutSVGInlineText*>& descendantTextNodes)
+    : m_descendantTextNodes(descendantTextNodes)
+    , m_currentLogicalTextNodeIndex(0)
     , m_logicalCharacterOffset(0)
     , m_logicalMetricsListOffset(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());
+    ASSERT(!m_descendantTextNodes.isEmpty());
 }
 
 SVGTextLayoutEngine::~SVGTextLayoutEngine() = default;
 
 bool SVGTextLayoutEngine::setCurrentTextPosition(const SVGCharacterData& data)
 {
     bool hasX = data.hasX();
     if (hasX)
         m_textPosition.setX(data.x);
 
@@ skipping 88 matching lines @@
     computeCurrentFragmentMetrics(textBox);
 
     textBox->textFragments().append(m_currentTextFragment);
     m_currentTextFragment = SVGTextFragment();
 }
 
 void SVGTextLayoutEngine::beginTextPathLayout(SVGInlineFlowBox* flowBox)
 {
     // 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);
+    SVGTextLayoutEngine lineLayout(m_descendantTextNodes);
     lineLayout.m_textLengthSpacingInEffect = m_textLengthSpacingInEffect;
     lineLayout.layoutCharactersInTextBoxes(flowBox);
 
     m_inPathLayout = true;
     LineLayoutSVGTextPath textPath = LineLayoutSVGTextPath(flowBox->getLineLayoutItem());
 
     m_textPath = textPath.layoutPath();
     if (!m_textPath)
         return;
     m_textPathStartOffset = textPath.calculateStartOffset(m_textPath->length());
@@ skipping 99 matching lines @@
     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);
 
     m_lineLayoutBoxes.clear();
 }
 
-const SVGTextLayoutAttributes* SVGTextLayoutEngine::nextLogicalAttributes()
+const LayoutSVGInlineText* SVGTextLayoutEngine::nextLogicalTextNode()
 {
-    ASSERT(m_layoutAttributesPosition < m_layoutAttributes.size());
-    ++m_layoutAttributesPosition;
-    if (m_layoutAttributesPosition == m_layoutAttributes.size())
+    ASSERT(m_currentLogicalTextNodeIndex < m_descendantTextNodes.size());
+    ++m_currentLogicalTextNodeIndex;
+    if (m_currentLogicalTextNodeIndex == m_descendantTextNodes.size())
         return nullptr;
 
     m_logicalMetricsListOffset = 0;
     m_logicalCharacterOffset = 0;
-    return m_layoutAttributes[m_layoutAttributesPosition];
+    return m_descendantTextNodes[m_currentLogicalTextNodeIndex];
 }
 
-const SVGTextLayoutAttributes* SVGTextLayoutEngine::currentLogicalCharacterMetrics(SVGTextMetrics& logicalMetrics)
+const LayoutSVGInlineText* SVGTextLayoutEngine::currentLogicalCharacterMetrics(SVGTextMetrics& logicalMetrics)
 {
-    // If we're consumed all layout attributes, there can be no more metrics.
-    if (m_layoutAttributesPosition == m_layoutAttributes.size())
+    // If we're consumed all text nodes, there can be no more metrics.
+    if (m_currentLogicalTextNodeIndex == m_descendantTextNodes.size())
         return nullptr;
 
-    const SVGTextLayoutAttributes* logicalAttributes = m_layoutAttributes[m_layoutAttributesPosition];
+    const LayoutSVGInlineText* logicalTextNode = m_descendantTextNodes[m_currentLogicalTextNodeIndex];
     // If we reached the end of the text node associated with the current set
     // of layout attributes, try to move to the next text node/set of layout
     // attributes.
-    ASSERT(m_logicalCharacterOffset <= logicalAttributes->context()->textLength());
-    if (m_logicalCharacterOffset == logicalAttributes->context()->textLength()) {
-        logicalAttributes = nextLogicalAttributes();
-        if (!logicalAttributes)
+    ASSERT(m_logicalCharacterOffset <= logicalTextNode->textLength());
+    if (m_logicalCharacterOffset == logicalTextNode->textLength()) {
+        logicalTextNode = nextLogicalTextNode();
+        if (!logicalTextNode)
             return nullptr;
     }
 
     // We have set of layout attributes. Find the first non-collapsed text
     // metrics cell.
-    const Vector<SVGTextMetrics>* metricsList = &logicalAttributes->context()->metricsList();
+    const Vector<SVGTextMetrics>* metricsList = &logicalTextNode->metricsList();
     unsigned metricsListSize = metricsList->size();
     while (true) {
         // If we run out of metrics, move to the next set of layout attributes.
         if (m_logicalMetricsListOffset == metricsListSize) {
-            logicalAttributes = nextLogicalAttributes();
-            if (!logicalAttributes)
+            logicalTextNode = nextLogicalTextNode();
+            if (!logicalTextNode)
                 return nullptr;
 
-            metricsList = &logicalAttributes->context()->metricsList();
+            metricsList = &logicalTextNode->metricsList();
             metricsListSize = metricsList->size();
             continue;
         }
 
         ASSERT(metricsListSize);
         ASSERT(m_logicalMetricsListOffset < metricsListSize);
         logicalMetrics = metricsList->at(m_logicalMetricsListOffset);
         if (logicalMetrics.isEmpty() || (!logicalMetrics.width() && !logicalMetrics.height())) {
             advanceToNextLogicalCharacter(logicalMetrics);
             continue;
         }
 
         // Stop if we found the next valid logical text metrics object.
-        return logicalAttributes;
+        return logicalTextNode;
     }
 
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 void SVGTextLayoutEngine::advanceToNextLogicalCharacter(const SVGTextMetrics& logicalMetrics)
 {
     ++m_logicalMetricsListOffset;
     m_logicalCharacterOffset += logicalMetrics.length();
@@ skipping 28 matching lines @@
     // 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;
         }
 
         SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
-        const SVGTextLayoutAttributes* logicalAttributes = currentLogicalCharacterMetrics(logicalMetrics);
-        if (!logicalAttributes)
+        const LayoutSVGInlineText* logicalTextNode = currentLogicalCharacterMetrics(logicalMetrics);
+        if (!logicalTextNode)
             break;
 
-        const SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
-        SVGCharacterData data;
-        SVGCharacterDataMap::const_iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
-        if (it != characterDataMap.end())
-            data = it->value;
+        const SVGCharacterData data = logicalTextNode->characterDataMap().get(m_logicalCharacterOffset + 1);
 
         // 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.
         setCurrentTextPosition(data);
 
         // When we've advanced to the box start offset, determine using the original x/y values,
         // 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));
+            textBox->setStartsNewTextChunk(logicalTextNode->characterStartsNewTextChunk(m_logicalCharacterOffset));
 
         bool hasRelativePosition = applyRelativePositionAdjustmentsIfNeeded(data);
 
         // Determine the orientation of the current glyph.
         // Font::width() calculates the resolved FontOrientation for each character,
         // 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);
 
@@ skipping 99 matching lines @@
     }
 
     if (!didStartTextFragment)
         return;
 
     // Close last open fragment, if needed.
     recordTextFragment(textBox);
 }
 
 } // namespace blink