8058747e70d598609541686faddb498ed7a4bc77
[WebKit-https.git] / Source / WebCore / rendering / svg / SVGTextLayoutEngine.cpp
1 /*
2  * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "SVGTextLayoutEngine.h"
22
23 #include "PathTraversalState.h"
24 #include "RenderSVGTextPath.h"
25 #include "SVGElement.h"
26 #include "SVGInlineTextBox.h"
27 #include "SVGLengthContext.h"
28 #include "SVGTextLayoutEngineBaseline.h"
29 #include "SVGTextLayoutEngineSpacing.h"
30
31 // Set to a value > 0 to dump the text fragments
32 #define DUMP_TEXT_FRAGMENTS 0
33
34 namespace WebCore {
35
36 SVGTextLayoutEngine::SVGTextLayoutEngine(Vector<SVGTextLayoutAttributes*>& layoutAttributes)
37     : m_layoutAttributes(layoutAttributes)
38     , m_layoutAttributesPosition(0)
39     , m_logicalCharacterOffset(0)
40     , m_logicalMetricsListOffset(0)
41     , m_visualCharacterOffset(0)
42     , m_visualMetricsListOffset(0)
43     , m_x(0)
44     , m_y(0)
45     , m_dx(0)
46     , m_dy(0)
47     , m_isVerticalText(false)
48     , m_inPathLayout(false)
49     , m_textPathLength(0)
50     , m_textPathCurrentOffset(0)
51     , m_textPathSpacing(0)
52     , m_textPathScaling(1)
53 {
54     ASSERT(!m_layoutAttributes.isEmpty());
55 }
56
57 void SVGTextLayoutEngine::updateCharacerPositionIfNeeded(float& x, float& y)
58 {
59     if (m_inPathLayout)
60         return;
61
62     // Replace characters x/y position, with the current text position plus any
63     // relative adjustments, if it doesn't specify an absolute position itself.
64     if (x == SVGTextLayoutAttributes::emptyValue()) 
65         x = m_x + m_dx;
66
67     if (y == SVGTextLayoutAttributes::emptyValue())
68         y = m_y + m_dy;
69
70     m_dx = 0;
71     m_dy = 0;
72 }
73
74 void SVGTextLayoutEngine::updateCurrentTextPosition(float x, float y, float glyphAdvance)
75 {
76     // Update current text position after processing the character.
77     if (m_isVerticalText) {
78         m_x = x;
79         m_y = y + glyphAdvance;
80     } else {
81         m_x = x + glyphAdvance;
82         m_y = y;
83     }
84 }
85
86 void SVGTextLayoutEngine::updateRelativePositionAdjustmentsIfNeeded(float dx, float dy)
87 {
88     // Update relative positioning information.
89     if (dx == SVGTextLayoutAttributes::emptyValue() && dy == SVGTextLayoutAttributes::emptyValue())
90         return;
91
92     if (dx == SVGTextLayoutAttributes::emptyValue())
93         dx = 0;
94     if (dy == SVGTextLayoutAttributes::emptyValue())
95         dy = 0;
96
97     if (m_inPathLayout) {
98         if (m_isVerticalText) {
99             m_dx += dx;
100             m_dy = dy;
101         } else {
102             m_dx = dx;
103             m_dy += dy;
104         }
105
106         return;
107     }
108
109     m_dx = dx;
110     m_dy = dy;
111 }
112
113 void SVGTextLayoutEngine::recordTextFragment(SVGInlineTextBox& textBox, Vector<SVGTextMetrics>& textMetricsValues)
114 {
115     ASSERT(!m_currentTextFragment.length);
116     ASSERT(m_visualMetricsListOffset > 0);
117
118     // Figure out length of fragment.
119     m_currentTextFragment.length = m_visualCharacterOffset - m_currentTextFragment.characterOffset;
120
121     // Figure out fragment metrics.
122     SVGTextMetrics& lastCharacterMetrics = textMetricsValues.at(m_visualMetricsListOffset - 1);
123     m_currentTextFragment.width = lastCharacterMetrics.width();
124     m_currentTextFragment.height = lastCharacterMetrics.height();
125
126     if (m_currentTextFragment.length > 1) {
127         // SVGTextLayoutAttributesBuilder assures that the length of the range is equal to the sum of the individual lengths of the glyphs.
128         float length = 0;
129         if (m_isVerticalText) {
130             for (unsigned i = m_currentTextFragment.metricsListOffset; i < m_visualMetricsListOffset; ++i)
131                 length += textMetricsValues.at(i).height();
132             m_currentTextFragment.height = length;
133         } else {
134             for (unsigned i = m_currentTextFragment.metricsListOffset; i < m_visualMetricsListOffset; ++i)
135                 length += textMetricsValues.at(i).width();
136             m_currentTextFragment.width = length;
137         }
138     }
139
140     textBox.textFragments().append(m_currentTextFragment);
141     m_currentTextFragment = SVGTextFragment();
142 }
143
144 bool SVGTextLayoutEngine::parentDefinesTextLength(RenderObject* parent) const
145 {
146     RenderObject* currentParent = parent;
147     while (currentParent) {
148         if (SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromRenderer(currentParent)) {
149             SVGLengthContext lengthContext(textContentElement);
150             if (textContentElement->lengthAdjust() == SVGLengthAdjustSpacing && textContentElement->specifiedTextLength().value(lengthContext) > 0)
151                 return true;
152         }
153
154         if (currentParent->isSVGText())
155             return false;
156
157         currentParent = currentParent->parent();
158     }
159
160     ASSERT_NOT_REACHED();
161     return false;
162 }
163
164 void SVGTextLayoutEngine::beginTextPathLayout(RenderSVGTextPath& textPath, SVGTextLayoutEngine& lineLayout)
165 {
166     m_inPathLayout = true;
167
168     m_textPath = textPath.layoutPath();
169     if (m_textPath.isEmpty())
170         return;
171
172     m_textPathStartOffset = textPath.startOffset();
173     m_textPathLength = m_textPath.length();
174     if (m_textPathStartOffset > 0 && m_textPathStartOffset <= 1)
175         m_textPathStartOffset *= m_textPathLength;
176
177     lineLayout.m_chunkLayoutBuilder.buildTextChunks(lineLayout.m_lineLayoutBoxes);
178
179     // Handle text-anchor as additional start offset for text paths.
180     m_textPathStartOffset += lineLayout.m_chunkLayoutBuilder.totalAnchorShift();
181     m_textPathCurrentOffset = m_textPathStartOffset;
182
183     // Eventually handle textLength adjustments.
184     auto* textContentElement = SVGTextContentElement::elementFromRenderer(&textPath);
185     if (!textContentElement)
186         return;
187
188     SVGLengthContext lengthContext(textContentElement);
189     float desiredTextLength = textContentElement->specifiedTextLength().value(lengthContext);
190     if (!desiredTextLength)
191         return;
192
193     float totalLength = lineLayout.m_chunkLayoutBuilder.totalLength();
194     unsigned totalCharacters = lineLayout.m_chunkLayoutBuilder.totalCharacters();
195
196     if (textContentElement->lengthAdjust() == SVGLengthAdjustSpacing)
197         m_textPathSpacing = (desiredTextLength - totalLength) / totalCharacters;
198     else
199         m_textPathScaling = desiredTextLength / totalLength;
200 }
201
202 void SVGTextLayoutEngine::endTextPathLayout()
203 {
204     m_inPathLayout = false;
205     m_textPath = Path();
206     m_textPathLength = 0;
207     m_textPathStartOffset = 0;
208     m_textPathCurrentOffset = 0;
209     m_textPathSpacing = 0;
210     m_textPathScaling = 1;
211 }
212
213 void SVGTextLayoutEngine::layoutInlineTextBox(SVGInlineTextBox& textBox)
214 {
215     RenderSVGInlineText& text = textBox.renderer();
216     ASSERT(text.parent());
217     ASSERT(text.parent()->element());
218     ASSERT(text.parent()->element()->isSVGElement());
219
220     const RenderStyle& style = text.style();
221
222     textBox.clearTextFragments();
223     m_isVerticalText = style.svgStyle().isVerticalWritingMode();
224     layoutTextOnLineOrPath(textBox, text, style);
225
226     if (m_inPathLayout) {
227         m_pathLayoutBoxes.append(&textBox);
228         return;
229     }
230
231     m_lineLayoutBoxes.append(&textBox);
232 }
233
234 #if DUMP_TEXT_FRAGMENTS > 0
235 static inline void dumpTextBoxes(Vector<SVGInlineTextBox*>& boxes)
236 {
237     unsigned boxCount = boxes.size();
238     fprintf(stderr, "Dumping all text fragments in text sub tree, %i boxes\n", boxCount);
239
240     for (unsigned boxPosition = 0; boxPosition < boxCount; ++boxPosition) {
241         SVGInlineTextBox* textBox = boxes.at(boxPosition);
242         Vector<SVGTextFragment>& fragments = textBox->textFragments();
243         fprintf(stderr, "-> Box %i: Dumping text fragments for SVGInlineTextBox, textBox=%p, textRenderer=%p\n", boxPosition, textBox, textBox->renderer());
244         fprintf(stderr, "        textBox properties, start=%i, len=%i, box direction=%i\n", textBox->start(), textBox->len(), textBox->direction());
245         fprintf(stderr, "   textRenderer properties, textLength=%i\n", textBox->renderer()->textLength());
246
247         const UChar* characters = textBox->renderer()->characters();
248
249         unsigned fragmentCount = fragments.size();
250         for (unsigned i = 0; i < fragmentCount; ++i) {
251             SVGTextFragment& fragment = fragments.at(i);
252             String fragmentString(characters + fragment.characterOffset, fragment.length);
253             fprintf(stderr, "    -> Fragment %i, x=%lf, y=%lf, width=%lf, height=%lf, characterOffset=%i, length=%i, characters='%s'\n"
254                           , i, fragment.x, fragment.y, fragment.width, fragment.height, fragment.characterOffset, fragment.length, fragmentString.utf8().data());
255         }
256     }
257 }
258 #endif
259
260 void SVGTextLayoutEngine::finalizeTransformMatrices(Vector<SVGInlineTextBox*>& boxes)
261 {
262     unsigned boxCount = boxes.size();
263     if (!boxCount)
264         return;
265
266     AffineTransform textBoxTransformation;
267     for (unsigned boxPosition = 0; boxPosition < boxCount; ++boxPosition) {
268         SVGInlineTextBox* textBox = boxes.at(boxPosition);
269         Vector<SVGTextFragment>& fragments = textBox->textFragments();
270
271         unsigned fragmentCount = fragments.size();
272         for (unsigned i = 0; i < fragmentCount; ++i) {
273             textBoxTransformation = m_chunkLayoutBuilder.transformationForTextBox(textBox);
274             if (textBoxTransformation.isIdentity())
275                 continue;
276             ASSERT(fragments[i].lengthAdjustTransform.isIdentity());
277             fragments[i].lengthAdjustTransform = textBoxTransformation;
278         }
279     }
280
281     boxes.clear();
282 }
283
284 void SVGTextLayoutEngine::finishLayout()
285 {
286     // After all text fragments are stored in their correpsonding SVGInlineTextBoxes, we can layout individual text chunks.
287     // Chunk layouting is only performed for line layout boxes, not for path layout, where it has already been done.
288     m_chunkLayoutBuilder.layoutTextChunks(m_lineLayoutBoxes);
289
290     // Finalize transform matrices, after the chunk layout corrections have been applied, and all fragment x/y positions are finalized.
291     if (!m_lineLayoutBoxes.isEmpty()) {
292 #if DUMP_TEXT_FRAGMENTS > 0
293         fprintf(stderr, "Line layout: ");
294         dumpTextBoxes(m_lineLayoutBoxes);
295 #endif
296
297         finalizeTransformMatrices(m_lineLayoutBoxes);
298     }
299
300     if (!m_pathLayoutBoxes.isEmpty()) {
301 #if DUMP_TEXT_FRAGMENTS > 0
302         fprintf(stderr, "Path layout: ");
303         dumpTextBoxes(m_pathLayoutBoxes);
304 #endif
305
306         finalizeTransformMatrices(m_pathLayoutBoxes);
307     }
308 }
309
310 bool SVGTextLayoutEngine::currentLogicalCharacterAttributes(SVGTextLayoutAttributes*& logicalAttributes)
311 {
312     if (m_layoutAttributesPosition == m_layoutAttributes.size())
313         return false;
314
315     logicalAttributes = m_layoutAttributes[m_layoutAttributesPosition];
316     ASSERT(logicalAttributes);
317
318     if (m_logicalCharacterOffset != logicalAttributes->context().textLength())
319         return true;
320
321     ++m_layoutAttributesPosition;
322     if (m_layoutAttributesPosition == m_layoutAttributes.size())
323         return false;
324
325     logicalAttributes = m_layoutAttributes[m_layoutAttributesPosition];
326     m_logicalMetricsListOffset = 0;
327     m_logicalCharacterOffset = 0;
328     return true;
329 }
330
331 bool SVGTextLayoutEngine::currentLogicalCharacterMetrics(SVGTextLayoutAttributes*& logicalAttributes, SVGTextMetrics& logicalMetrics)
332 {
333     Vector<SVGTextMetrics>* textMetricsValues = &logicalAttributes->textMetricsValues();
334     unsigned textMetricsSize = textMetricsValues->size();
335     while (true) {
336         if (m_logicalMetricsListOffset == textMetricsSize) {
337             if (!currentLogicalCharacterAttributes(logicalAttributes))
338                 return false;
339
340             textMetricsValues = &logicalAttributes->textMetricsValues();
341             textMetricsSize = textMetricsValues->size();
342             continue;
343         }
344
345         ASSERT(textMetricsSize);
346         ASSERT_WITH_SECURITY_IMPLICATION(m_logicalMetricsListOffset < textMetricsSize);
347         logicalMetrics = textMetricsValues->at(m_logicalMetricsListOffset);
348         if (logicalMetrics.isEmpty() || (!logicalMetrics.width() && !logicalMetrics.height())) {
349             advanceToNextLogicalCharacter(logicalMetrics);
350             continue;
351         }
352
353         // Stop if we found the next valid logical text metrics object.
354         return true;
355     }
356
357     ASSERT_NOT_REACHED();
358     return true;
359 }
360
361 bool SVGTextLayoutEngine::currentVisualCharacterMetrics(const SVGInlineTextBox& textBox, Vector<SVGTextMetrics>& visualMetricsValues, SVGTextMetrics& visualMetrics)
362 {
363     ASSERT(!visualMetricsValues.isEmpty());
364     unsigned textMetricsSize = visualMetricsValues.size();
365     unsigned boxStart = textBox.start();
366     unsigned boxLength = textBox.len();
367
368     if (m_visualMetricsListOffset == textMetricsSize)
369         return false;
370
371     while (m_visualMetricsListOffset < textMetricsSize) {
372         // Advance to text box start location.
373         if (m_visualCharacterOffset < boxStart) {
374             advanceToNextVisualCharacter(visualMetricsValues[m_visualMetricsListOffset]);
375             continue;
376         }
377
378         // Stop if we've finished processing this text box.
379         if (m_visualCharacterOffset >= boxStart + boxLength)
380             return false;
381
382         visualMetrics = visualMetricsValues[m_visualMetricsListOffset];
383         return true;
384     }
385
386     return false;
387 }
388
389 void SVGTextLayoutEngine::advanceToNextLogicalCharacter(const SVGTextMetrics& logicalMetrics)
390 {
391     ++m_logicalMetricsListOffset;
392     m_logicalCharacterOffset += logicalMetrics.length();
393 }
394
395 void SVGTextLayoutEngine::advanceToNextVisualCharacter(const SVGTextMetrics& visualMetrics)
396 {
397     ++m_visualMetricsListOffset;
398     m_visualCharacterOffset += visualMetrics.length();
399 }
400
401 void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox& textBox, RenderSVGInlineText& text, const RenderStyle& style)
402 {
403     if (m_inPathLayout && m_textPath.isEmpty())
404         return;
405
406     RenderElement* textParent = text.parent();
407     ASSERT(textParent);
408     SVGElement* lengthContext = downcast<SVGElement>(textParent->element());
409     
410     bool definesTextLength = parentDefinesTextLength(textParent);
411
412     const SVGRenderStyle& svgStyle = style.svgStyle();
413
414     m_visualMetricsListOffset = 0;
415     m_visualCharacterOffset = 0;
416
417     Vector<SVGTextMetrics>& visualMetricsValues = text.layoutAttributes()->textMetricsValues();
418     ASSERT(!visualMetricsValues.isEmpty());
419
420     auto upconvertedCharacters = StringView(text.text()).upconvertedCharacters();
421     const UChar* characters = upconvertedCharacters;
422     const FontCascade& font = style.fontCascade();
423
424     SVGTextLayoutEngineSpacing spacingLayout(font);
425     SVGTextLayoutEngineBaseline baselineLayout(font);
426
427     bool didStartTextFragment = false;
428     bool applySpacingToNextCharacter = false;
429
430     float lastAngle = 0;
431     float baselineShift = baselineLayout.calculateBaselineShift(svgStyle, lengthContext);
432     baselineShift -= baselineLayout.calculateAlignmentBaselineShift(m_isVerticalText, text);
433
434     // Main layout algorithm.
435     while (true) {
436         // Find the start of the current text box in this list, respecting ligatures.
437         SVGTextMetrics visualMetrics(SVGTextMetrics::SkippedSpaceMetrics);
438         if (!currentVisualCharacterMetrics(textBox, visualMetricsValues, visualMetrics))
439             break;
440
441         if (visualMetrics.isEmpty()) {
442             advanceToNextVisualCharacter(visualMetrics);
443             continue;
444         }
445
446         SVGTextLayoutAttributes* logicalAttributes = 0;
447         if (!currentLogicalCharacterAttributes(logicalAttributes))
448             break;
449
450         ASSERT(logicalAttributes);
451         SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
452         if (!currentLogicalCharacterMetrics(logicalAttributes, logicalMetrics))
453             break;
454
455         SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
456         SVGCharacterData data;
457         SVGCharacterDataMap::iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
458         if (it != characterDataMap.end())
459             data = it->value;
460
461         float x = data.x;
462         float y = data.y;
463
464         // When we've advanced to the box start offset, determine using the original x/y values
465         // whether this character starts a new text chunk before doing any further processing.
466         if (m_visualCharacterOffset == textBox.start())
467             textBox.setStartsNewTextChunk(logicalAttributes->context().characterStartsNewTextChunk(m_logicalCharacterOffset));
468
469         float angle = data.rotate == SVGTextLayoutAttributes::emptyValue() ? 0 : data.rotate;
470
471         // Calculate glyph orientation angle.
472         const UChar* currentCharacter = characters + m_visualCharacterOffset;
473         float orientationAngle = baselineLayout.calculateGlyphOrientationAngle(m_isVerticalText, svgStyle, *currentCharacter);
474
475         // Calculate glyph advance & x/y orientation shifts.
476         float xOrientationShift = 0;
477         float yOrientationShift = 0;
478         float glyphAdvance = baselineLayout.calculateGlyphAdvanceAndOrientation(m_isVerticalText, visualMetrics, orientationAngle, xOrientationShift, yOrientationShift);
479
480         // Assign current text position to x/y values, if needed.
481         updateCharacerPositionIfNeeded(x, y);
482
483         // Apply dx/dy value adjustments to current text position, if needed.
484         updateRelativePositionAdjustmentsIfNeeded(data.dx, data.dy);
485
486         // Calculate CSS 'kerning', 'letter-spacing' and 'word-spacing' for next character, if needed.
487         float spacing = spacingLayout.calculateCSSKerningAndSpacing(&svgStyle, lengthContext, currentCharacter);
488
489         float textPathOffset = 0;
490         if (m_inPathLayout) {
491             float scaledGlyphAdvance = glyphAdvance * m_textPathScaling;
492             if (m_isVerticalText) {
493                 // If there's an absolute y position available, it marks the beginning of a new position along the path.
494                 if (y != SVGTextLayoutAttributes::emptyValue())
495                     m_textPathCurrentOffset = y + m_textPathStartOffset;
496
497                 m_textPathCurrentOffset += m_dy;
498                 m_dy = 0;
499
500                 // Apply dx/dy correction and setup translations that move to the glyph midpoint.
501                 xOrientationShift += m_dx + baselineShift;
502                 yOrientationShift -= scaledGlyphAdvance / 2;
503             } else {
504                 // If there's an absolute x position available, it marks the beginning of a new position along the path.
505                 if (x != SVGTextLayoutAttributes::emptyValue())
506                     m_textPathCurrentOffset = x + m_textPathStartOffset;
507
508                 m_textPathCurrentOffset += m_dx;
509                 m_dx = 0;
510
511                 // Apply dx/dy correction and setup translations that move to the glyph midpoint.
512                 xOrientationShift -= scaledGlyphAdvance / 2;
513                 yOrientationShift += m_dy - baselineShift;
514             }
515
516             // Calculate current offset along path.
517             textPathOffset = m_textPathCurrentOffset + scaledGlyphAdvance / 2;
518
519             // Move to next character.
520             m_textPathCurrentOffset += scaledGlyphAdvance + m_textPathSpacing + spacing * m_textPathScaling;
521
522             // Skip character, if we're before the path.
523             if (textPathOffset < 0) {
524                 advanceToNextLogicalCharacter(logicalMetrics);
525                 advanceToNextVisualCharacter(visualMetrics);
526                 continue;
527             }
528
529             // Stop processing, if the next character lies behind the path.
530             if (textPathOffset > m_textPathLength)
531                 break;
532
533             bool success = false;
534             auto traversalState(m_textPath.traversalStateAtLength(textPathOffset, success));
535             ASSERT(success);
536
537             FloatPoint point = traversalState.current();
538             x = point.x();
539             y = point.y();
540
541             angle = traversalState.normalAngle();
542
543             // For vertical text on path, the actual angle has to be rotated 90 degrees anti-clockwise, not the orientation angle!
544             if (m_isVerticalText)
545                 angle -= 90;
546         } else {
547             // Apply all previously calculated shift values.
548             if (m_isVerticalText)
549                 x += baselineShift;
550             else
551                 y -= baselineShift;
552
553             x += m_dx;
554             y += m_dy;
555         }
556
557         // Determine whether we have to start a new fragment.
558         bool shouldStartNewFragment = m_dx || m_dy || m_isVerticalText || m_inPathLayout || angle || angle != lastAngle
559             || orientationAngle || applySpacingToNextCharacter || definesTextLength;
560
561         // If we already started a fragment, close it now.
562         if (didStartTextFragment && shouldStartNewFragment) {
563             applySpacingToNextCharacter = false;
564             recordTextFragment(textBox, visualMetricsValues);
565         }
566
567         // Eventually start a new fragment, if not yet done.
568         if (!didStartTextFragment || shouldStartNewFragment) {
569             ASSERT(!m_currentTextFragment.characterOffset);
570             ASSERT(!m_currentTextFragment.length);
571
572             didStartTextFragment = true;
573             m_currentTextFragment.characterOffset = m_visualCharacterOffset;
574             m_currentTextFragment.metricsListOffset = m_visualMetricsListOffset;
575             m_currentTextFragment.x = x;
576             m_currentTextFragment.y = y;
577
578             // Build fragment transformation.
579             if (angle)
580                 m_currentTextFragment.transform.rotate(angle);
581
582             if (xOrientationShift || yOrientationShift)
583                 m_currentTextFragment.transform.translate(xOrientationShift, yOrientationShift);
584
585             if (orientationAngle)
586                 m_currentTextFragment.transform.rotate(orientationAngle);
587
588             m_currentTextFragment.isTextOnPath = m_inPathLayout && m_textPathScaling != 1;
589             if (m_currentTextFragment.isTextOnPath) {
590                 if (m_isVerticalText)
591                     m_currentTextFragment.lengthAdjustTransform.scaleNonUniform(1, m_textPathScaling);
592                 else
593                     m_currentTextFragment.lengthAdjustTransform.scaleNonUniform(m_textPathScaling, 1);
594             }
595         }
596
597         // Update current text position, after processing of the current character finished.
598         if (m_inPathLayout)
599             updateCurrentTextPosition(x, y, glyphAdvance);
600         else {
601             // Apply CSS 'kerning', 'letter-spacing' and 'word-spacing' to next character, if needed.
602             if (spacing)
603                 applySpacingToNextCharacter = true;
604
605             float xNew = x - m_dx;
606             float yNew = y - m_dy;
607
608             if (m_isVerticalText)
609                 xNew -= baselineShift;
610             else
611                 yNew += baselineShift;
612
613             updateCurrentTextPosition(xNew, yNew, glyphAdvance + spacing);
614         }
615
616         advanceToNextLogicalCharacter(logicalMetrics);
617         advanceToNextVisualCharacter(visualMetrics);
618         lastAngle = angle;
619     }
620
621     if (!didStartTextFragment)
622         return;
623
624     // Close last open fragment, if needed.
625     recordTextFragment(textBox, visualMetricsValues);
626 }
627
628 }