Perform SVG text chunk processing on-the-fly

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 {
 
 SVGTextChunkBuilder::SVGTextChunkBuilder()
 {
 }
 
-void SVGTextChunkBuilder::buildTextChunks(Vector<SVGInlineTextBox*>& lineLayoutBoxes)
+void SVGTextChunkBuilder::processTextChunks(const Vector<SVGInlineTextBox*>& lineLayoutBoxes)
 {
     if (lineLayoutBoxes.isEmpty())
         return;
 
     bool foundStart = false;
     unsigned lastChunkStartPosition = 0;
     unsigned boxPosition = 0;
     unsigned boxCount = lineLayoutBoxes.size();
     for (; boxPosition < boxCount; ++boxPosition) {
         SVGInlineTextBox* textBox = lineLayoutBoxes[boxPosition];
         if (!textBox->startsNewTextChunk())
             continue;
 
         if (!foundStart) {
-            lastChunkStartPosition = boxPosition;
             foundStart = true;
         } else {
             ASSERT(boxPosition > lastChunkStartPosition);
-            addTextChunk(lineLayoutBoxes, lastChunkStartPosition, boxPosition - lastChunkStartPosition);
-            lastChunkStartPosition = boxPosition;
+            handleTextChunk(lineLayoutBoxes, lastChunkStartPosition, boxPosition);
         }
+        lastChunkStartPosition = boxPosition;
     }
 
     if (!foundStart)
         return;
 
     if (boxPosition - lastChunkStartPosition > 0)
-        addTextChunk(lineLayoutBoxes, lastChunkStartPosition, boxPosition - lastChunkStartPosition);
+        handleTextChunk(lineLayoutBoxes, lastChunkStartPosition, boxPosition);
 }
 
-void SVGTextChunkBuilder::layoutTextChunks(Vector<SVGInlineTextBox*>& lineLayoutBoxes)
+SVGTextPathChunkBuilder::SVGTextPathChunkBuilder()
+    : SVGTextChunkBuilder()
+    , m_totalLength(0)
+    , m_totalCharacters(0)
+    , m_totalTextAnchorShift(0)
 {
-    buildTextChunks(lineLayoutBoxes);
-    if (m_textChunks.isEmpty())
-        return;
-
-    unsigned chunkCount = m_textChunks.size();
-    for (unsigned i = 0; i < chunkCount; ++i)
-        processTextChunk(m_textChunks[i]);
-
-    m_textChunks.clear();
 }
 
-void SVGTextChunkBuilder::addTextChunk(Vector<SVGInlineTextBox*>& lineLayoutBoxes, unsigned boxStart, unsigned boxCount)
+static SVGTextChunk createTextChunk(const Vector<SVGInlineTextBox*>& lineLayoutBoxes, unsigned boxStart, unsigned boxCount)

[f(malita), 2015/05/27 15:19:13]

Can we fold this into the SVGTextChunk ctor and just use that instead?

 {
     SVGInlineTextBox* textBox = lineLayoutBoxes[boxStart];
     ASSERT(textBox);
 
     LayoutSVGInlineText& textLayoutObject = toLayoutSVGInlineText(textBox->layoutObject());
 
     const ComputedStyle& style = toLayoutSVGInlineText(textBox->layoutObject()).styleRef();
 
     const SVGComputedStyle& svgStyle = style.svgStyle();
 
@@ skipping 40 matching lines @@
             break;
         };
     }
 
     SVGTextChunk chunk(chunkStyle, desiredTextLength);
 
     Vector<SVGInlineTextBox*>& boxes = chunk.boxes();
     for (unsigned i = boxStart; i < boxStart + boxCount; ++i)
         boxes.append(lineLayoutBoxes[i]);
 
-    m_textChunks.append(chunk);
+    return chunk;
+}
+
+void SVGTextPathChunkBuilder::handleTextChunk(const Vector<SVGInlineTextBox*>& boxes, unsigned boxStart, unsigned boxEnd)
+{
+    SVGTextChunk chunk = createTextChunk(boxes, boxStart, boxEnd - boxStart);
+
+    float length = 0;
+    unsigned characters = 0;
+    chunk.calculateLength(length, characters);
+
+    // Handle text-anchor as additional start offset for text paths.
+    m_totalTextAnchorShift += chunk.calculateTextAnchorShift(length);
+
+    m_totalLength += length;
+    m_totalCharacters += characters;
 }
 
 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::processTextChunk(const SVGTextChunk& chunk)
+void SVGTextChunkBuilder::handleTextChunk(const Vector<SVGInlineTextBox*>& lineBoxes, unsigned boxStart, unsigned boxEnd)
 {
+    SVGTextChunk chunk = createTextChunk(lineBoxes, boxStart, boxEnd - boxStart);
+
     bool processTextLength = chunk.hasDesiredTextLength();
     bool processTextAnchor = chunk.hasTextAnchor();
     if (!processTextAnchor && !processTextLength)
         return;
 
     const Vector<SVGInlineTextBox*>& boxes = chunk.boxes();
     unsigned boxCount = boxes.size();
     if (!boxCount)
         return;
 
@@ skipping 90 matching lines @@
             continue;
 
         for (SVGTextFragment& fragment : textBox->textFragments()) {
             ASSERT(fragment.lengthAdjustTransform.isIdentity());
             fragment.lengthAdjustTransform = textBoxTransformation;
         }
     }
 }
 
 }