Move SVGTextMetrics::constructTextRun to SVGTextMetricsBuilder

third_party/WebKit/Source/core/layout/svg/SVGTextMetricsBuilder.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 16 matching lines @@
 #include "platform/fonts/CharacterRange.h"
 #include "platform/text/BidiCharacterRun.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextDirection.h"
 #include "platform/text/TextRun.h"
 #include "platform/text/TextRunIterator.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
+namespace {
+
 class SVGTextMetricsCalculator {
 public:
     SVGTextMetricsCalculator(LayoutSVGInlineText*);
     ~SVGTextMetricsCalculator();
 
     bool advancePosition();
     unsigned currentPosition() const { return m_currentPosition; }
 
     SVGTextMetrics currentCharacterMetrics();
 
     // TODO(pdr): Character-based iteration is ambiguous and error-prone. It
     // should be unified under a single concept. See: https://crbug.com/593570
     bool currentCharacterStartsSurrogatePair() const
     {
         return U16_IS_LEAD(m_run[m_currentPosition]) && m_currentPosition + 1 < characterCount() && U16_IS_TRAIL(m_run[m_currentPosition + 1]);
     }
     bool currentCharacterIsWhiteSpace() const
     {
         return m_run[m_currentPosition] == ' ';
     }
     unsigned characterCount() const
     {
         return static_cast<unsigned>(m_run.charactersLength());
     }
 
 private:
     void setupBidiRuns();
 
+    static TextRun constructTextRun(LineLayoutSVGInlineText, unsigned position, unsigned length, TextDirection);
+
     // Ensure |m_subrunRanges| is updated for the current bidi run, or the
     // complete m_run if no bidi runs are present. Returns the current position
     // in the subrun which can be used to index into |m_subrunRanges|.
     unsigned updateSubrunRangesForCurrentPosition();
 
     // Current character position in m_text.
     unsigned m_currentPosition;
 
     LineLayoutSVGInlineText m_text;
     TextRun m_run;
 
     BidiCharacterRun* m_bidiRun;
     BidiResolver<TextRunIterator, BidiCharacterRun> m_bidiResolver;
 
     // Ranges for the current bidi run if present, or the entire run otherwise.
     Vector<CharacterRange> m_subrunRanges;
 };
 
+TextRun SVGTextMetricsCalculator::constructTextRun(LineLayoutSVGInlineText textLayoutItem, unsigned position, unsigned length, TextDirection textDirection)
+{
+    const ComputedStyle& style = textLayoutItem.styleRef();
+
+    TextRun run(static_cast<const LChar*>(nullptr) // characters, will be set below if non-zero.
+        , 0 // length, will be set below if non-zero.
+        , 0 // xPos, only relevant with allowTabs=true
+        , 0 // padding, only relevant for justified text, not relevant for SVG
+        , TextRun::AllowTrailingExpansion
+        , textDirection
+        , isOverride(style.unicodeBidi()) /* directionalOverride */);
+
+    if (length) {
+        if (textLayoutItem.is8Bit())
+            run.setText(textLayoutItem.characters8() + position, length);
+        else
+            run.setText(textLayoutItem.characters16() + position, length);
+    }
+
+    // We handle letter & word spacing ourselves.
+    run.disableSpacing();
+
+    // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
+    run.setCharactersLength(textLayoutItem.textLength() - position);
+    ASSERT(run.charactersLength() >= run.length());
+    return run;
+}
+
 SVGTextMetricsCalculator::SVGTextMetricsCalculator(LayoutSVGInlineText* text)
     : m_currentPosition(0)
     , m_text(LineLayoutSVGInlineText(text))
-    , m_run(SVGTextMetrics::constructTextRun(m_text, 0, m_text.textLength(), m_text.styleRef().direction()))
+    , m_run(constructTextRun(m_text, 0, m_text.textLength(), m_text.styleRef().direction()))
     , m_bidiRun(nullptr)
 {
     setupBidiRuns();
 }
 
 SVGTextMetricsCalculator::~SVGTextMetricsCalculator()
 {
     if (m_bidiRun)
         m_bidiResolver.runs().deleteRuns();
 }
@@ skipping 29 matching lines @@
         }
         ASSERT(m_bidiRun);
         ASSERT(static_cast<int>(m_currentPosition) < m_bidiRun->stop());
     }
 
     unsigned positionInRun = m_bidiRun ? m_currentPosition - m_bidiRun->start() : m_currentPosition;
     if (positionInRun >= m_subrunRanges.size()) {
         unsigned subrunStart = m_bidiRun ? m_bidiRun->start() : 0;
         unsigned subrunEnd = m_bidiRun ? m_bidiRun->stop() : m_run.charactersLength();
         TextDirection subrunDirection = m_bidiRun ? m_bidiRun->direction() : m_text.styleRef().direction();
-        TextRun subRun = SVGTextMetrics::constructTextRun(m_text, subrunStart, subrunEnd - subrunStart, subrunDirection);
+        TextRun subRun = constructTextRun(m_text, subrunStart, subrunEnd - subrunStart, subrunDirection);
         m_subrunRanges = m_text.scaledFont().individualCharacterRanges(subRun);
 
         // TODO(pdr): We only have per-glyph data so we need to synthesize per-
         // grapheme data. E.g., if 'fi' is shaped into a single glyph, we do not
         // know the 'i' position. The code below synthesizes an average glyph
         // width when characters share a position. This will incorrectly split
         // combining diacritics. See: https://crbug.com/473476.
         unsigned distributeCount = 0;
         for (int rangeIndex = static_cast<int>(m_subrunRanges.size()) - 1; rangeIndex >= 0; --rangeIndex) {
             CharacterRange& currentRange = m_subrunRanges[rangeIndex];
@@ skipping 68 matching lines @@
             return;
         const SVGCharacterDataMap::const_iterator it = allCharactersMap->find(valueListPosition);
         if (it != allCharactersMap->end())
             attributes.characterDataMap().set(currentTextPosition, it->value);
     }
 
     SVGTextLayoutAttributes& attributes;
     const SVGCharacterDataMap* allCharactersMap;
 };
 
-static void walkInlineText(LayoutSVGInlineText* text, TreeWalkTextState& textState, UpdateAttributes* attributesToUpdate = nullptr)
+void walkInlineText(LayoutSVGInlineText* text, TreeWalkTextState& textState, UpdateAttributes* attributesToUpdate = nullptr)
 {
     if (attributesToUpdate)
         attributesToUpdate->clearExistingAttributes();
 
     if (!text->textLength())
         return;
 
     // TODO(pdr): This loop is too tightly coupled to SVGTextMetricsCalculator.
     // We should refactor SVGTextMetricsCalculator to be a simple bidi run
     // iterator and move all subrun logic to a single function.
@@ skipping 17 matching lines @@
         }
 
         if (calculator.currentCharacterStartsSurrogatePair())
             surrogatePairCharacters++;
         textState.lastCharacterWasWhiteSpace = currentCharacterIsWhiteSpace;
     } while (calculator.advancePosition());
 
     textState.valueListPosition += calculator.currentPosition() - skippedWhitespace;
 }
 
-static void walkTree(LayoutSVGText* start, LayoutSVGInlineText* stopAtText, SVGCharacterDataMap* allCharactersMap = nullptr)
+void walkTree(LayoutSVGText* start, LayoutSVGInlineText* stopAtText, SVGCharacterDataMap* allCharactersMap = nullptr)
 {
     TreeWalkTextState textState;
     LayoutObject* child = start->firstChild();
     while (child) {
         if (child->isSVGInlineText()) {
             LayoutSVGInlineText* text = toLayoutSVGInlineText(child);
             OwnPtr<UpdateAttributes> attributesToUpdate = nullptr;
             if (!stopAtText || stopAtText == text)
                 attributesToUpdate = adoptPtr(new UpdateAttributes(*text->layoutAttributes(), allCharactersMap));
             walkInlineText(text, textState, attributesToUpdate.get());
             if (stopAtText == text)
                 return;
         } else if (child->isSVGInline()) {
             // Visit children of text content elements.
             if (LayoutObject* inlineChild = toLayoutSVGInline(child)->firstChild()) {
                 child = inlineChild;
                 continue;
             }
         }
         child = child->nextInPreOrderAfterChildren(start);
     }
 }
 
+} // namespace
+
 void SVGTextMetricsBuilder::measureTextLayoutObject(LayoutSVGInlineText* text)
 {
     ASSERT(text);
     if (LayoutSVGText* textRoot = LayoutSVGText::locateLayoutSVGTextAncestor(text))
         walkTree(textRoot, text);
 }
 
 void SVGTextMetricsBuilder::buildMetricsAndLayoutAttributes(LayoutSVGText* textRoot, LayoutSVGInlineText* stopAtText, SVGCharacterDataMap& allCharactersMap)
 {
     ASSERT(textRoot);
     walkTree(textRoot, stopAtText, &allCharactersMap);
 }
 
 } // namespace blink