Store a <scale, bias> tuple for textLength scale adjustment

third_party/WebKit/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 "core/layout/svg/SVGTextChunkBuilder.h"
 
 #include "core/layout/api/LineLayoutSVGInlineText.h"
-#include "core/layout/svg/LayoutSVGInlineText.h"
 #include "core/layout/svg/line/SVGInlineTextBox.h"
 #include "core/svg/SVGLengthContext.h"
 #include "core/svg/SVGTextContentElement.h"
-#include "platform/transforms/AffineTransform.h"
 
 namespace blink {
 
 namespace {
 
 float calculateTextAnchorShift(const ComputedStyle& style, float length)
 {
     bool isLTR = style.isLeftToRightDirection();
     switch (style.svgStyle().textAnchor()) {
     default:
@@ skipping 127 matching lines @@
     ChunkLengthAccumulator lengthAccumulator(!style.isHorizontalWritingMode());
     lengthAccumulator.processRange(boxStart, boxEnd);
 
     // Handle text-anchor as additional start offset for text paths.
     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)
+static float computeTextLengthBias(const SVGTextFragment& fragment, float scale)
 {
-    spacingAndGlyphsTransform.translate(fragment.x, fragment.y);
-
-    if (isVerticalText)
-        spacingAndGlyphsTransform.scaleNonUniform(1, scale);
-    else
-        spacingAndGlyphsTransform.scaleNonUniform(scale, 1);
-
-    spacingAndGlyphsTransform.translate(-fragment.x, -fragment.y);
+    float initialPosition = fragment.isVertical ? fragment.y : fragment.x;
+    return initialPosition + scale * -initialPosition;
 }
 
 void SVGTextChunkBuilder::handleTextChunk(BoxListConstIterator boxStart, BoxListConstIterator boxEnd)
 {
     ASSERT(*boxStart);
 
     const LineLayoutSVGInlineText textLineLayout = LineLayoutSVGInlineText((*boxStart)->lineLayoutItem());
     const ComputedStyle& style = textLineLayout.styleRef();
 
     // Handle 'lengthAdjust' property.
@@ skipping 34 matching lines @@
 
             // 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(lengthAdjust == SVGLengthAdjustSpacingAndGlyphs);
             float textLengthScale = desiredTextLength / chunkLength;
-            AffineTransform spacingAndGlyphsTransform;
+            float textLengthBias = 0;
 
             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);
+                    textLengthBias = computeTextLengthBias(fragments.first(), textLengthScale);
                 }
 
-                applyTextLengthScaleAdjustment(spacingAndGlyphsTransform, fragments);
+                applyTextLengthScaleAdjustment(textLengthScale, textLengthBias, fragments);
             }
         }
     }
 
     if (!processTextAnchor)
         return;
 
     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)
 {
     for (SVGTextFragment& fragment : fragments) {
         if (isVerticalText)
             fragment.y += textLengthShift * atCharacter;
         else
             fragment.x += textLengthShift * atCharacter;
 
         atCharacter += fragment.length;
     }
 }
 
-void SVGTextChunkBuilder::applyTextLengthScaleAdjustment(const AffineTransform& spacingAndGlyphsTransform, Vector<SVGTextFragment>& fragments)
+void SVGTextChunkBuilder::applyTextLengthScaleAdjustment(float textLengthScale, float textLengthBias, Vector<SVGTextFragment>& fragments)
 {
     for (SVGTextFragment& fragment : fragments) {
-        ASSERT(fragment.lengthAdjustTransform.isIdentity());
-        fragment.lengthAdjustTransform = spacingAndGlyphsTransform;
+        ASSERT(fragment.lengthAdjustScale == 1);
+        fragment.lengthAdjustScale = textLengthScale;
+        fragment.lengthAdjustBias = textLengthBias;
     }
 }
 
 void SVGTextChunkBuilder::processTextAnchorCorrection(bool isVerticalText, float textAnchorShift, Vector<SVGTextFragment>& fragments)
 {
     for (SVGTextFragment& fragment : fragments) {
         if (isVerticalText)
             fragment.y += textAnchorShift;
         else
             fragment.x += textAnchorShift;
     }
 }
 
 }