Re-enable vertical flow in SimplePath

Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. 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
@@ skipping 321 matching lines @@
 CodePath Font::codePath(const TextRunPaintInfo& runInfo) const
 {
     const TextRun& run = runInfo.run;
 
     if (fontDescription().typesettingFeatures() && (runInfo.from || runInfo.to != run.length()))
         return ComplexPath;
 
     if (m_fontDescription.featureSettings() && m_fontDescription.featureSettings()->size() > 0 && m_fontDescription.letterSpacing() == 0)
         return ComplexPath;
 
-    if (m_fontDescription.orientation() == Vertical)
-        return ComplexPath;
-
     if (m_fontDescription.widthVariant() != RegularWidth)
         return ComplexPath;
 
     if (run.length() > 1 && fontDescription().typesettingFeatures())
         return ComplexPath;
 
     // FIXME: This really shouldn't be needed but for some reason the
     // TextRendering setting doesn't propagate to typesettingFeatures in time
     // for the prefs width calculation.
     if (fontDescription().textRendering() == OptimizeLegibility || fontDescription().textRendering() == GeometricPrecision)
@@ skipping 354 matching lines @@
         gc->drawPosTextH(glyphs, numGlyphs * sizeof(Glyph), xpos, constY, textRect, paint);
     }
 }
 
 void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font,
     const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs,
     const FloatPoint& point, const FloatRect& textRect) const
 {
     ASSERT(glyphBuffer.size() >= from + numGlyphs);
 
-    if (!glyphBuffer.hasVerticalOffsets()) {
+    bool drawVertically = font->platformData().orientation() == Vertical && font->verticalData();
+    if (!glyphBuffer.hasVerticalOffsets() && !drawVertically) {
         SkAutoSTMalloc<64, SkScalar> storage(numGlyphs);
         SkScalar* xpos = storage.get();
         for (unsigned i = 0; i < numGlyphs; i++)
             xpos[i] = SkFloatToScalar(point.x() + glyphBuffer.xOffsetAt(from + i));
 
         paintGlyphsHorizontal(gc, font, glyphBuffer.glyphs(from), numGlyphs, xpos,
             SkFloatToScalar(point.y()), textRect);
         return;
     }
 
-    bool drawVertically = font->platformData().orientation() == Vertical && font->verticalData();
+    GraphicsContextStateSaver stateSaver(*gc);
+    if (drawVertically) {
+        const float initialAdvance = glyphBuffer.hasVerticalOffsets() ? 0 : glyphBuffer.xOffsetAt(from);
+        const FloatPoint adjustedPoint(point.x() + initialAdvance, point.y());
+        const float verticalBaselineXOffset = font->fontMetrics().floatAscent() - font->fontMetrics().floatAscent(IdeographicBaseline);
+        const FloatPoint verticalOrigin(adjustedPoint.x() + verticalBaselineXOffset, adjustedPoint.y() - initialAdvance);
 
-    GraphicsContextStateSaver stateSaver(*gc, false);
-    if (drawVertically) {
-        stateSaver.save();
-        gc->concatCTM(AffineTransform(0, -1, 1, 0, point.x(), point.y()));
-        gc->concatCTM(AffineTransform(1, 0, 0, 1, -point.x(), -point.y()));
+        // Multiple matrices are needed to convert between multiple coordinate systems, so they are pre-concatenated.
+        // First, rotate back the rotated baseline in the rendering coordinates to the glyph baseline:
+        // gc->concatCTM(AffineTransform(0, -1, 1, 0, adjustedPoint.x(), adjustedPoint.y()));
+        // gc->concatCTM(AffineTransform(1, 0, 0, 1, -adjustedPoint.x(), -adjustedPoint.y()));
+        // then move to the text origin to use the glyph coordinate system.
+        // gc->concatCTM(AffineTransform(1, 0, 0, 1, verticalOrigin.x(), verticalOrigin.y()));
+        gc->concatCTM(AffineTransform(0, -1, 1, 0,
+            -adjustedPoint.y() + adjustedPoint.x() + verticalOrigin.y(),
+            adjustedPoint.x() + adjustedPoint.y() - verticalOrigin.x()));
+    } else {
+        gc->concatCTM(AffineTransform::translation(point.x(), point.y()));
     }
 
-    const float verticalBaselineXOffset = drawVertically ? SkFloatToScalar(font->fontMetrics().floatAscent() - font->fontMetrics().floatAscent(IdeographicBaseline)) : 0;
+    SkAutoSTMalloc<64, SkPoint> storage(numGlyphs);
+    SkPoint* pos = storage.get();
 
-    ASSERT(glyphBuffer.hasVerticalOffsets());
-    SkAutoSTMalloc<32, SkPoint> storage(numGlyphs);
-    SkPoint* pos = storage.get();
-    for (unsigned i = 0; i < numGlyphs; i++) {
-        pos[i].set(
-            SkFloatToScalar(point.x() + verticalBaselineXOffset + glyphBuffer.xOffsetAt(from + i)),
-            SkFloatToScalar(point.y() + glyphBuffer.yOffsetAt(from + i)));
+    if (!glyphBuffer.hasVerticalOffsets()) { // Simple path, vertical
+        ASSERT(drawVertically);
+
+        Vector<FloatPoint, 64> translations(numGlyphs);
+        font->verticalData()->getVerticalTranslationsForGlyphs(font, glyphBuffer.glyphs(from), numGlyphs, reinterpret_cast<float*>(&translations[0]));
+
+        for (unsigned i = 0; i < numGlyphs; ++i)
+            pos[i].set(SkFloatToScalar(translations[i].x()), SkFloatToScalar(glyphBuffer.xOffsetAt(from + i) - translations[i].y()));
+    } else { // Complex path, either horizontal or vertical
+        for (unsigned i = 0; i < numGlyphs; i++)
+            pos[i].set(SkFloatToScalar(glyphBuffer.xOffsetAt(from + i)), SkFloatToScalar(glyphBuffer.yOffsetAt(from + i)));
     }
 
     paintGlyphs(gc, font, glyphBuffer.glyphs(from), numGlyphs, pos, textRect);
 }
 
 void Font::drawTextBlob(GraphicsContext* gc, const SkTextBlob* blob, const SkPoint& origin) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     TextDrawingModeFlags textMode = gc->textDrawingMode();
@@ skipping 191 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink