Use characters (not code units) when computing value list positions

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

 /*
  * Copyright (C) Research In Motion Limited 2010-2011. 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 17 matching lines @@
 
 namespace {
 
 void updateLayoutAttributes(LayoutSVGInlineText& text, unsigned& valueListPosition, const SVGCharacterDataMap& allCharactersMap)
 {
     SVGTextLayoutAttributes& attributes = *text.layoutAttributes();
     attributes.clear();
 
     const Vector<SVGTextMetrics>& metricsList = text.metricsList();
     auto metricsEnd = metricsList.end();
-    unsigned surrogatePairCharacters = 0;
-    unsigned skippedWhitespace = 0;
     unsigned currentPosition = 0;
     for (auto metrics = metricsList.begin(); metrics != metricsEnd; currentPosition += metrics->length(), ++metrics) {
-        if (metrics->isEmpty()) {
-            skippedWhitespace++;
+        if (metrics->isEmpty())
             continue;
-        }
 
-        unsigned currentValueListPosition = valueListPosition - skippedWhitespace - surrogatePairCharacters + currentPosition + 1;
-        auto it = allCharactersMap.find(currentValueListPosition);
+        auto it = allCharactersMap.find(valueListPosition + 1);
         if (it != allCharactersMap.end())
             attributes.characterDataMap().set(currentPosition + 1, it->value);
 
-        // At the moment, only surrogates will be length == 2 (or even > 1).
-        if (metrics->length() == 2)
-            surrogatePairCharacters++;
+        // Increase the position in the value/attribute list with one for each
+        // "character unit" (that will be displayed.)
+        valueListPosition++;
     }
-
-    // TODO(fs): currentPosition ought to always equal text.textLength() here.
-    valueListPosition += currentPosition - skippedWhitespace;
 }
 
 } // namespace
 
 SVGTextLayoutAttributesBuilder::SVGTextLayoutAttributesBuilder()
-    : m_textLength(0)
+    : m_characterCount(0)
 {
 }
 
 void SVGTextLayoutAttributesBuilder::buildLayoutAttributes(LayoutSVGText& textRoot) const
 {
     unsigned valueListPosition = 0;
     LayoutObject* child = textRoot.firstChild();
     while (child) {
         if (child->isSVGInlineText()) {
             updateLayoutAttributes(toLayoutSVGInlineText(*child), valueListPosition, m_characterDataMap);
         } else if (child->isSVGInline()) {
             // Visit children of text content elements.
             if (LayoutObject* inlineChild = toLayoutSVGInline(child)->firstChild()) {
                 child = inlineChild;
                 continue;
             }
         }
         child = child->nextInPreOrderAfterChildren(&textRoot);
     }
 }
 
 void SVGTextLayoutAttributesBuilder::buildLayoutAttributesForTextRoot(LayoutSVGText& textRoot)
 {
     m_characterDataMap.clear();
 
     if (m_textPositions.isEmpty()) {
-        m_textLength = 0;
-        UChar lastCharacter = ' ';
-        collectTextPositioningElements(textRoot, lastCharacter);
+        m_characterCount = 0;
+        collectTextPositioningElements(textRoot);
     }
 
-    if (!m_textLength)
+    if (!m_characterCount)
         return;
 
     buildCharacterDataMap(textRoot);
     buildLayoutAttributes(textRoot);
 }
 
-static inline void processLayoutSVGInlineText(LayoutSVGInlineText* text, unsigned& atCharacter, UChar& lastCharacter)
+static inline unsigned countCharactersInTextNode(const LayoutSVGInlineText& text)
 {
-    if (text->style()->whiteSpace() == PRE) {
-        atCharacter += text->textLength();
-        return;
+    unsigned numCharacters = 0;
+    for (const SVGTextMetrics& metrics : text.metricsList()) {
+        if (metrics.isEmpty())
+            continue;
+        numCharacters++;
     }
-
-    unsigned textLength = text->textLength();
-    for (unsigned textPosition = 0; textPosition < textLength; ++textPosition) {
-        UChar currentCharacter = text->characterAt(textPosition);
-        if (currentCharacter == ' ' && lastCharacter == ' ')
-            continue;
-
-        lastCharacter = currentCharacter;
-        ++atCharacter;
-    }
+    return numCharacters;
 }
 
 static SVGTextPositioningElement* positioningElementFromLayoutObject(LayoutObject& layoutObject)
 {
     ASSERT(layoutObject.isSVGText() || layoutObject.isSVGInline());
 
     Node* node = layoutObject.node();
     ASSERT(node);
     ASSERT(node->isSVGElement());
 
     return isSVGTextPositioningElement(*node) ? toSVGTextPositioningElement(node) : nullptr;
 }
 
-void SVGTextLayoutAttributesBuilder::collectTextPositioningElements(LayoutBoxModelObject& start, UChar& lastCharacter)
+void SVGTextLayoutAttributesBuilder::collectTextPositioningElements(LayoutBoxModelObject& start)
 {
     ASSERT(!start.isSVGText() || m_textPositions.isEmpty());
 
     for (LayoutObject* child = start.slowFirstChild(); child; child = child->nextSibling()) {
         if (child->isSVGInlineText()) {
-            processLayoutSVGInlineText(toLayoutSVGInlineText(child), m_textLength, lastCharacter);
+            m_characterCount += countCharactersInTextNode(toLayoutSVGInlineText(*child));
             continue;
         }
 
         if (!child->isSVGInline())
             continue;
 
         LayoutSVGInline& inlineChild = toLayoutSVGInline(*child);
         SVGTextPositioningElement* element = positioningElementFromLayoutObject(inlineChild);
         unsigned atPosition = m_textPositions.size();
         if (element)
-            m_textPositions.append(TextPosition(element, m_textLength));
+            m_textPositions.append(TextPosition(element, m_characterCount));
 
-        collectTextPositioningElements(inlineChild, lastCharacter);
+        collectTextPositioningElements(inlineChild);
 
         if (!element)
             continue;
 
         // Update text position, after we're back from recursion.
         TextPosition& position = m_textPositions[atPosition];
         ASSERT(!position.length);
-        position.length = m_textLength - position.start;
+        position.length = m_characterCount - position.start;
     }
 }
 
 void SVGTextLayoutAttributesBuilder::buildCharacterDataMap(LayoutSVGText& textRoot)
 {
     SVGTextPositioningElement* outermostTextElement = positioningElementFromLayoutObject(textRoot);
     ASSERT(outermostTextElement);
 
     // Grab outermost <text> element value lists and insert them in the character data map.
-    TextPosition wholeTextPosition(outermostTextElement, 0, m_textLength);
+    TextPosition wholeTextPosition(outermostTextElement, 0, m_characterCount);
     fillCharacterDataMap(wholeTextPosition);
 
     // Fill character data map using child text positioning elements in top-down order.
     unsigned size = m_textPositions.size();
     for (unsigned i = 0; i < size; ++i)
         fillCharacterDataMap(m_textPositions[i]);
 
     // Handle x/y default attributes.
     SVGCharacterData& data = m_characterDataMap.add(1, SVGCharacterData()).storedValue->value;
     if (SVGTextLayoutAttributes::isEmptyValue(data.x))
@@ skipping 82 matching lines @@
         attrLists.updateCharacterData(i, data);
     }
 }
 
 DEFINE_TRACE(SVGTextLayoutAttributesBuilder::TextPosition)
 {
     visitor->trace(element);
 }
 
 } // namespace blink