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 is not exposed today to avoid the API complexity.
         UChar32 currentCharacter = text.codepointAt(m_visualMetricsIterator.characterOffset());
-        float orientationAngle = baselineLayout.calculateGlyphOrientationAngle(m_isVerticalText, svgStyle, currentCharacter);
+        FontOrientation fontOrientation = font.fontDescription().orientation();
+        fontOrientation = adjustOrientationForCharacterInMixedVertical(fontOrientation, currentCharacter);
 
-        // Calculate glyph advance & x/y orientation shifts.
-        float xOrientationShift = 0;
-        float yOrientationShift = 0;
-        float glyphAdvance = baselineLayout.calculateGlyphAdvanceAndOrientation(m_isVerticalText, visualMetrics, orientationAngle, xOrientationShift, yOrientationShift);
+        // Calculate glyph advance.
+        // Shaping engine takes care of x/y orientation shifts for different fontOrientation values.
+        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);
 
         float textPathOffset = 0;
+        float textPathShiftX = 0;
+        float textPathShiftY = 0;
         if (m_inPathLayout) {
             float scaledGlyphAdvance = glyphAdvance * m_textPathScaling;
             if (m_isVerticalText) {
                 // If there's an absolute y position available, it marks the beginning of a new position along the path.
                 if (!SVGTextLayoutAttributes::isEmptyValue(y))
                     m_textPathCurrentOffset = y + m_textPathStartOffset;
 
                 m_textPathCurrentOffset += m_dy;
                 m_dy = 0;
 
                 // Apply dx/dy correction and setup translations that move to the glyph midpoint.
-                xOrientationShift += m_dx + baselineShift;
-                yOrientationShift -= scaledGlyphAdvance / 2;
+                textPathShiftX += m_dx + baselineShift;
+                textPathShiftY -= scaledGlyphAdvance / 2;
             } else {
                 // If there's an absolute x position available, it marks the beginning of a new position along the path.
                 if (!SVGTextLayoutAttributes::isEmptyValue(x))
                     m_textPathCurrentOffset = x + m_textPathStartOffset;
 
                 m_textPathCurrentOffset += m_dx;
                 m_dx = 0;
 
                 // Apply dx/dy correction and setup translations that move to the glyph midpoint.
-                xOrientationShift -= scaledGlyphAdvance / 2;
-                yOrientationShift += m_dy - baselineShift;
+                textPathShiftX -= scaledGlyphAdvance / 2;
+                textPathShiftY += m_dy - baselineShift;
             }
 
             // Calculate current offset along path.
             textPathOffset = m_textPathCurrentOffset + scaledGlyphAdvance / 2;
 
             // Move to next character.
             m_textPathCurrentOffset += scaledGlyphAdvance + m_textPathSpacing + spacing * m_textPathScaling;
 
             // Skip character, if we're before the path.
             if (textPathOffset < 0) {
@@ skipping 21 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 (textPathShiftX || textPathShiftY)
+                m_currentTextFragment.transform.translate(textPathShiftX, textPathShiftY);
 
-            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);
 }
 
 }