Add SVG Text to support the CSS 'text-orientation' property

third_party/WebKit/Source/core/layout/svg/SVGTextLayoutEngine.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 316 matching lines @@
 {
     ++m_logicalMetricsListOffset;
     m_logicalCharacterOffset += logicalMetrics.length();
 }
 
 void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, const LayoutSVGInlineText& text, const ComputedStyle& style)
 {
     if (m_inPathLayout && !m_textPathCalculator)
         return;
 
-    const SVGComputedStyle& svgStyle = style.svgStyle();
-
     // Find the start of the current text box in the metrics list.
     m_visualMetricsIterator.advanceToTextStart(&text, textBox->start());
 
     const Font& font = style.font();
 
     SVGTextLayoutEngineSpacing spacingLayout(font, style.effectiveZoom());
     SVGTextLayoutEngineBaseline baselineLayout(font, style.effectiveZoom());
 
     bool didStartTextFragment = false;
     bool applySpacingToNextCharacter = false;
@@ skipping 30 matching lines @@
         float y = data.y;
 
         // When we've advanced to the box start offset, determine using the original x/y values,
         // whether this character starts a new text chunk, before doing any further processing.
         if (m_visualMetricsIterator.characterOffset() == textBox->start())
             textBox->setStartsNewTextChunk(logicalAttributes->context()->characterStartsNewTextChunk(m_logicalCharacterOffset));
 
         float angle = SVGTextLayoutAttributes::isEmptyValue(data.rotate) ? 0 : data.rotate;
 
         // Calculate glyph orientation angle.
+        // Font::width() calculates the resolved FontOrientation for each character,
+        // but does not expose today to avoid the API becomes too complex.

[fs, 2015/10/16 10:54:50]

Nit: "but does not expose today" -> "but is not exposed today" (and "becomes" ->
"becoming" or just "avoid API complexity" or something maybe)

Also, should this be a TODO for the SVGTextMetricsBuilder (i.e. SVGTextMetrics
would store logical values instead of width7height as it does today)?

         UChar32 currentCharacter = text.codepointAt(m_visualMetricsIterator.characterOffset());
-        float orientationAngle = baselineLayout.calculateGlyphOrientationAngle(m_isVerticalText, svgStyle, currentCharacter);
+        FontOrientation fontOrientation = font.fontDescription().orientation();
+        fontOrientation = resolveMixedFontOrientation(fontOrientation, currentCharacter);
 
-        // Calculate glyph advance & x/y orientation shifts.
+        // Calculate glyph advance.
+        // Shaping engine takes care of x/y orientation shifts for different fontOrientation values.
         float xOrientationShift = 0;
         float yOrientationShift = 0;

[fs, 2015/10/16 10:54:50]

These two are now only used for <textPath> related adjustments - could you move
them down to just before the m_inPathLayout check and maybe rename them to
textPath<something> (textPathGlyphMidpointX/Y maybe. I think I have a patch
somewhere that would be able to simplify that even more.)

-        float glyphAdvance = baselineLayout.calculateGlyphAdvanceAndOrientation(m_isVerticalText, visualMetrics, orientationAngle, xOrientationShift, yOrientationShift);
+        float glyphAdvance = visualMetrics.advance(fontOrientation);
 
         // Assign current text position to x/y values, if needed.
         updateCharacterPositionIfNeeded(x, y);
 
         // Apply dx/dy value adjustments to current text position, if needed.
         updateRelativePositionAdjustmentsIfNeeded(data.dx, data.dy);
 
         // Calculate CSS 'letter-spacing' and 'word-spacing' for next character, if needed.
         float spacing = spacingLayout.calculateCSSSpacing(currentCharacter);
 
@@ skipping 56 matching lines @@
                 x += baselineShift;
             else
                 y -= baselineShift;
 
             x += m_dx;
             y += m_dy;
         }
 
         // Determine whether we have to start a new fragment.
         bool shouldStartNewFragment = m_dx || m_dy || m_isVerticalText || m_inPathLayout || angle || angle != lastAngle
-            || orientationAngle || applySpacingToNextCharacter || m_textLengthSpacingInEffect;
+            || applySpacingToNextCharacter || m_textLengthSpacingInEffect;
 
         // If we already started a fragment, close it now.
         if (didStartTextFragment && shouldStartNewFragment) {
             applySpacingToNextCharacter = false;
             recordTextFragment(textBox);
         }
 
         // Eventually start a new fragment, if not yet done.
         if (!didStartTextFragment || shouldStartNewFragment) {
             ASSERT(!m_currentTextFragment.characterOffset);
             ASSERT(!m_currentTextFragment.length);
 
             didStartTextFragment = true;
             m_currentTextFragment.characterOffset = m_visualMetricsIterator.characterOffset();
             m_currentTextFragment.metricsListOffset = m_visualMetricsIterator.metricsListOffset();
             m_currentTextFragment.x = x;
             m_currentTextFragment.y = y;
 
             // Build fragment transformation.
             if (angle)
                 m_currentTextFragment.transform.rotate(angle);
 
             if (xOrientationShift || yOrientationShift)
                 m_currentTextFragment.transform.translate(xOrientationShift, yOrientationShift);
 
-            if (orientationAngle)
-                m_currentTextFragment.transform.rotate(orientationAngle);
+            // In vertical text, always rotate by 90 degrees regardless of fontOrientation.
+            // Shaping engine takes care of the necessary orientation.
+            if (m_isVerticalText)
+                m_currentTextFragment.transform.rotate(90);
 
             m_currentTextFragment.isTextOnPath = m_inPathLayout && m_textPathScaling != 1;
             if (m_currentTextFragment.isTextOnPath) {
                 if (m_isVerticalText)
                     m_currentTextFragment.lengthAdjustTransform.scaleNonUniform(1, m_textPathScaling);
                 else
                     m_currentTextFragment.lengthAdjustTransform.scaleNonUniform(m_textPathScaling, 1);
             }
         }
 
@@ skipping 22 matching lines @@
     }
 
     if (!didStartTextFragment)
         return;
 
     // Close last open fragment, if needed.
     recordTextFragment(textBox);
 }
 
 }