Fold and remove SVGTextChunk

Source/core/layout/svg/SVGTextChunkBuilder.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010. 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/SVGTextChunkBuilder.h"
 
 #include "core/layout/svg/LayoutSVGInlineText.h"
-#include "core/layout/svg/SVGTextChunk.h"
 #include "core/layout/svg/line/SVGInlineTextBox.h"
 #include "core/svg/SVGLengthContext.h"
 #include "core/svg/SVGTextContentElement.h"
 
 namespace blink {
 
 namespace {
 
-SVGTextChunk createTextChunk(const SVGInlineTextBox& textBox)
+float calculateTextAnchorShift(const ComputedStyle& style, float length)
 {
-    LayoutSVGInlineText& textLayoutObject = toLayoutSVGInlineText(textBox.layoutObject());
-    const ComputedStyle& style = textLayoutObject.styleRef();
-    const SVGComputedStyle& svgStyle = style.svgStyle();
+    ETextAnchor textAnchor = style.svgStyle().textAnchor();
+    if (textAnchor == TA_MIDDLE)
+        return -length / 2;
+    bool isLTR = style.isLeftToRightDirection();
+    if (textAnchor == TA_END)
+        return isLTR ? -length : 0;
+    return isLTR ? 0 : -length;
+}
 
-    // Build chunk style flags.
-    unsigned chunkStyle = SVGTextChunk::DefaultStyle;
-
-    // Handle 'direction' property.
-    if (!style.isLeftToRightDirection())
-        chunkStyle |= SVGTextChunk::RightToLeftText;
-
-    // Handle 'writing-mode' property.
-    if (svgStyle.isVerticalWritingMode())
-        chunkStyle |= SVGTextChunk::VerticalText;
-
-    // Handle 'text-anchor' property.
-    switch (svgStyle.textAnchor()) {
-    case TA_START:
-        break;
-    case TA_MIDDLE:
-        chunkStyle |= SVGTextChunk::MiddleAnchor;
-        break;
-    case TA_END:
-        chunkStyle |= SVGTextChunk::EndAnchor;
-        break;
-    }
-
-    // Handle 'lengthAdjust' property.
-    float desiredTextLength = 0;
-    if (SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromLayoutObject(textLayoutObject.parent())) {
-        SVGLengthContext lengthContext(textContentElement);
-        if (textContentElement->textLengthIsSpecifiedByUser())
-            desiredTextLength = textContentElement->textLength()->currentValue()->value(lengthContext);
-        else
-            desiredTextLength = 0;
-
-        switch (textContentElement->lengthAdjust()->currentValue()->enumValue()) {
-        case SVGLengthAdjustUnknown:
-            break;
-        case SVGLengthAdjustSpacing:
-            chunkStyle |= SVGTextChunk::LengthAdjustSpacing;
-            break;
-        case SVGLengthAdjustSpacingAndGlyphs:
-            chunkStyle |= SVGTextChunk::LengthAdjustSpacingAndGlyphs;
-            break;
-        }
-    }
-
-    return SVGTextChunk(chunkStyle, desiredTextLength);
+bool needsTextAnchorAdjustment(const ComputedStyle& style)
+{
+    ETextAnchor textAnchor = style.svgStyle().textAnchor();

[pdr., 2015/06/04 20:22:02]

Nit: These may be a little cleaner as a switch statement on
style.svgStyle().textAnchor() (here, and above). Up to your judgement.

[fs, 2015/06/05 08:42:32]

I had this in PS1, but then some of the bots bombed on it... I suppose I could
be more persuasive (add default case.) Done (hopefully.)

+    if (textAnchor == TA_MIDDLE)
+        return true;
+    bool isLTR = style.isLeftToRightDirection();
+    return (isLTR && textAnchor == TA_END)
+        || (!isLTR && textAnchor == TA_START);
 }
 
 class ChunkLengthAccumulator {
 public:
     ChunkLengthAccumulator(bool isVertical)
         : m_numCharacters(0)
         , m_length(0)
         , m_isVertical(isVertical)
     {
     }
@@ skipping 82 matching lines @@
 SVGTextPathChunkBuilder::SVGTextPathChunkBuilder()
     : SVGTextChunkBuilder()
     , m_totalLength(0)
     , m_totalCharacters(0)
     , m_totalTextAnchorShift(0)
 {
 }
 
 void SVGTextPathChunkBuilder::handleTextChunk(BoxListConstIterator boxStart, BoxListConstIterator boxEnd)
 {
-    SVGTextChunk chunk = createTextChunk(**boxStart);
+    const ComputedStyle& style = (*boxStart)->layoutObject().styleRef();
 
-    ChunkLengthAccumulator lengthAccumulator(chunk.isVerticalText());
+    ChunkLengthAccumulator lengthAccumulator(style.svgStyle().isVerticalWritingMode());
     lengthAccumulator.processRange(boxStart, boxEnd);
 
     // Handle text-anchor as additional start offset for text paths.
-    m_totalTextAnchorShift += chunk.calculateTextAnchorShift(lengthAccumulator.length());
+    m_totalTextAnchorShift += calculateTextAnchorShift(style, lengthAccumulator.length());
 
     m_totalLength += lengthAccumulator.length();
     m_totalCharacters += lengthAccumulator.numCharacters();
 }
 
 static void buildSpacingAndGlyphsTransform(bool isVerticalText, float scale, const SVGTextFragment& fragment, AffineTransform& spacingAndGlyphsTransform)
 {
     spacingAndGlyphsTransform.translate(fragment.x, fragment.y);
 
     if (isVerticalText)
         spacingAndGlyphsTransform.scaleNonUniform(1, scale);
     else
         spacingAndGlyphsTransform.scaleNonUniform(scale, 1);
 
     spacingAndGlyphsTransform.translate(-fragment.x, -fragment.y);
 }
 
 void SVGTextChunkBuilder::handleTextChunk(BoxListConstIterator boxStart, BoxListConstIterator boxEnd)
 {
-    SVGTextChunk chunk = createTextChunk(**boxStart);
+    ASSERT(*boxStart);
 
-    bool processTextLength = chunk.hasDesiredTextLength();
-    bool processTextAnchor = chunk.hasTextAnchor();
+    const LayoutSVGInlineText& textLayoutObject = toLayoutSVGInlineText((*boxStart)->layoutObject());
+    const ComputedStyle& style = textLayoutObject.styleRef();
+
+    // Handle 'lengthAdjust' property.
+    float desiredTextLength = 0;
+    SVGLengthAdjustType lengthAdjust = SVGLengthAdjustUnknown;
+    if (SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromLayoutObject(textLayoutObject.parent())) {
+        lengthAdjust = textContentElement->lengthAdjust()->currentValue()->enumValue();
+
+        SVGLengthContext lengthContext(textContentElement);
+        if (textContentElement->textLengthIsSpecifiedByUser())
+            desiredTextLength = textContentElement->textLength()->currentValue()->value(lengthContext);
+        else
+            desiredTextLength = 0;
+    }
+
+    bool processTextLength = desiredTextLength > 0;
+    bool processTextAnchor = needsTextAnchorAdjustment(style);
     if (!processTextAnchor && !processTextLength)
         return;
 
-    bool isVerticalText = chunk.isVerticalText();
+    bool isVerticalText = style.svgStyle().isVerticalWritingMode();
 
     // Calculate absolute length of whole text chunk (starting from text box 'start', spanning 'length' text boxes).
     ChunkLengthAccumulator lengthAccumulator(isVerticalText);
     lengthAccumulator.processRange(boxStart, boxEnd);
 
     if (processTextLength) {
         float chunkLength = lengthAccumulator.length();
-        if (chunk.hasLengthAdjustSpacing()) {
-            float textLengthShift = (chunk.desiredTextLength() - chunkLength) / lengthAccumulator.numCharacters();
+        if (lengthAdjust == SVGLengthAdjustSpacing) {
+            float textLengthShift = (desiredTextLength - chunkLength) / lengthAccumulator.numCharacters();
             unsigned atCharacter = 0;
             for (auto boxIter = boxStart; boxIter != boxEnd; ++boxIter) {
                 Vector<SVGTextFragment>& fragments = (*boxIter)->textFragments();
                 if (fragments.isEmpty())
                     continue;
                 processTextLengthSpacingCorrection(isVerticalText, textLengthShift, fragments, atCharacter);
             }
 
             // Fragments have been adjusted, we have to recalculate the chunk
             // length, to be able to apply the text-anchor shift.
             if (processTextAnchor) {
                 lengthAccumulator.reset();
                 lengthAccumulator.processRange(boxStart, boxEnd);
             }
         } else {
-            ASSERT(chunk.hasLengthAdjustSpacingAndGlyphs());
-            float textLengthScale = chunk.desiredTextLength() / chunkLength;
+            ASSERT(lengthAdjust == SVGLengthAdjustSpacingAndGlyphs);
+            float textLengthScale = desiredTextLength / chunkLength;
             AffineTransform spacingAndGlyphsTransform;
 
             bool foundFirstFragment = false;
             for (auto boxIter = boxStart; boxIter != boxEnd; ++boxIter) {
                 SVGInlineTextBox* textBox = *boxIter;
                 Vector<SVGTextFragment>& fragments = textBox->textFragments();
                 if (fragments.isEmpty())
                     continue;
 
                 if (!foundFirstFragment) {
                     foundFirstFragment = true;
                     buildSpacingAndGlyphsTransform(isVerticalText, textLengthScale, fragments.first(), spacingAndGlyphsTransform);
                 }
 
                 m_textBoxTransformations.set(textBox, spacingAndGlyphsTransform);
             }
         }
     }
 
     if (!processTextAnchor)
         return;
 
-    float textAnchorShift = chunk.calculateTextAnchorShift(lengthAccumulator.length());
+    float textAnchorShift = calculateTextAnchorShift(style, lengthAccumulator.length());
     for (auto boxIter = boxStart; boxIter != boxEnd; ++boxIter) {
         Vector<SVGTextFragment>& fragments = (*boxIter)->textFragments();
         if (fragments.isEmpty())
             continue;
         processTextAnchorCorrection(isVerticalText, textAnchorShift, fragments);
     }
 }
 
 void SVGTextChunkBuilder::processTextLengthSpacingCorrection(bool isVerticalText, float textLengthShift, Vector<SVGTextFragment>& fragments, unsigned& atCharacter)
 {
@@ skipping 34 matching lines @@
             continue;
 
         for (SVGTextFragment& fragment : textBox->textFragments()) {
             ASSERT(fragment.lengthAdjustTransform.isIdentity());
             fragment.lengthAdjustTransform = textBoxTransformation;
         }
     }
 }
 
 }