Replace ENABLE_OPENTYPE_VERTICAL implementation with HarfBuzz

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 324 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 426 matching lines @@
         SkPaint paint = textFillPaint(gc, font);
         gc->drawPosTextH(glyphs, numGlyphs * sizeof(Glyph), xpos, constY, textRect, paint);
     }
 
     if ((textMode & TextModeStroke) && gc->hasStroke()) {
         SkPaint paint = textStrokePaint(gc, font, textMode & TextModeFill);
         gc->drawPosTextH(glyphs, numGlyphs * sizeof(Glyph), xpos, constY, textRect, paint);
     }
 }
 
-void Font::paintGlyphsVertical(GraphicsContext* gc, const SimpleFontData* font,
-    const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs, const FloatPoint& point,
-    const FloatRect& textRect) const
-{
-    const OpenTypeVerticalData* verticalData = font->verticalData();
-
-    SkAutoSTMalloc<32, SkPoint> storage(numGlyphs);
-    SkPoint* pos = storage.get();
-
-    // Bend over backwards to preserve legacy rounding.
-    float initialAdvance = glyphBuffer.xOffsetAt(from);
-    FloatPoint adjustedPoint(point.x() + initialAdvance, point.y());
-
-    AffineTransform savedMatrix = gc->getCTM();
-    gc->concatCTM(AffineTransform(0, -1, 1, 0, adjustedPoint.x(), adjustedPoint.y()));
-    gc->concatCTM(AffineTransform(1, 0, 0, 1, -adjustedPoint.x(), -adjustedPoint.y()));
-
-    const unsigned kMaxBufferLength = 256;
-    Vector<FloatPoint, kMaxBufferLength> translations;
-
-    const FontMetrics& metrics = font->fontMetrics();
-    float verticalOriginX = adjustedPoint.x() + metrics.floatAscent() - metrics.floatAscent(IdeographicBaseline);
-
-    unsigned glyphIndex = 0;
-    while (glyphIndex < numGlyphs) {
-        unsigned chunkLength = std::min(kMaxBufferLength, numGlyphs - glyphIndex);
-
-        const Glyph* glyphs = glyphBuffer.glyphs(from + glyphIndex);
-
-        translations.resize(chunkLength);
-        verticalData->getVerticalTranslationsForGlyphs(font, glyphs, chunkLength,
-            reinterpret_cast<float*>(&translations[0]));
-
-        for (unsigned i = 0; i < chunkLength; ++i, ++glyphIndex) {
-            SkScalar x = verticalOriginX + lroundf(translations[i].x());
-            SkScalar y = adjustedPoint.y() - SkIntToScalar(
-                -lroundf(glyphBuffer.xOffsetAt(from + glyphIndex) - initialAdvance - translations[i].y()));
-            pos[i].set(x, y);
-        }
-        paintGlyphs(gc, font, glyphs, chunkLength, pos, textRect);
-    }
-
-    gc->setCTM(savedMatrix);
-}
-
 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 (font->platformData().orientation() == Vertical && font->verticalData()) {
-        paintGlyphsVertical(gc, font, glyphBuffer, from, numGlyphs, point, textRect);
-        return;
-    }
-
     if (!glyphBuffer.hasVerticalOffsets()) {
         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();
+
+    AffineTransform savedMatrix = gc->getCTM();

[fs, 2014/12/03 09:40:39]

In https://codereview.chromium.org/748863004/ this getCTM/setCTM pair (at its
"previous location" that is) was replaced by a GraphicsContextStateSaver, so
this needs to be updated to something like:

GraphicsContextStateSaver stateSaver(*gc, false);
if (drawVertically) {
    stateSaver.save();
    gc->concatCTM(...);
    ...
}

(and the call to setCTM can be dropped.)

+    if (drawVertically) {
+        gc->concatCTM(AffineTransform(0, -1, 1, 0, point.x(), point.y()));
+        gc->concatCTM(AffineTransform(1, 0, 0, 1, -point.x(), -point.y()));
+    }
+
+    const float verticalBaselineXOffset = drawVertically ? SkFloatToScalar(font->fontMetrics().floatAscent() - font->fontMetrics().floatAscent(IdeographicBaseline)) : 0;
+
     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() + glyphBuffer.xOffsetAt(from + i)),
+            SkFloatToScalar(point.x() + verticalBaselineXOffset + glyphBuffer.xOffsetAt(from + i)),
             SkFloatToScalar(point.y() + glyphBuffer.yOffsetAt(from + i)));
     }
 
     paintGlyphs(gc, font, glyphBuffer.glyphs(from), numGlyphs, pos, textRect);
+
+    if (drawVertically) {
+        gc->setCTM(savedMatrix);
+    }
 }
 
 void Font::drawTextBlob(GraphicsContext* gc, const SkTextBlob* blob, const SkPoint& origin) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     TextDrawingModeFlags textMode = gc->textDrawingMode();
     if (textMode & TextModeFill)
         gc->drawTextBlob(blob, origin, gc->fillPaint());
 
@@ skipping 36 matching lines @@
     HarfBuzzShaper shaper(this, run);
     if (!shaper.shape())
         return FloatRect();
     return shaper.selectionRect(point, height, from, to);
 }
 
 void Font::drawGlyphBuffer(GraphicsContext* context,
     const TextRunPaintInfo& runInfo, const GlyphBuffer& glyphBuffer,
     const FloatPoint& point) const
 {
+    if (!glyphBuffer.size())
+        return;
+
     // Draw each contiguous run of glyphs that use the same font data.
     const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
     unsigned lastFrom = 0;
     unsigned nextGlyph;
 
     for (nextGlyph = 0; nextGlyph < glyphBuffer.size(); ++nextGlyph) {
         const SimpleFontData* nextFontData = glyphBuffer.fontDataAt(nextGlyph);
 
         if (nextFontData != fontData) {
             drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, point,
                 runInfo.bounds);
 
             lastFrom = nextGlyph;
             fontData = nextFontData;
         }
     }
 
     drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, point,
         runInfo.bounds);
 }
 
-inline static float offsetToMiddleOfGlyph(const SimpleFontData* fontData, Glyph glyph)
+inline static float offsetToMiddleOfGlyph(const SimpleFontData* fontData, Glyph glyph, FontOrientation orientation = Horizontal)
 {
-    if (fontData->platformData().orientation() == Horizontal) {
-        FloatRect bounds = fontData->boundsForGlyph(glyph);
+    FloatRect bounds = fontData->boundsForGlyph(glyph);
+    if (orientation == Horizontal)
         return bounds.x() + bounds.width() / 2;
-    }
-    // FIXME: Use glyph bounds once they make sense for vertical fonts.
-    return fontData->widthForGlyph(glyph) / 2;
+    return bounds.y() + bounds.height() / 2;
 }
 
 void Font::drawEmphasisMarks(GraphicsContext* context, const TextRunPaintInfo& runInfo, const GlyphBuffer& glyphBuffer, const AtomicString& mark, const FloatPoint& point) const
 {
     FontCachePurgePreventer purgePreventer;
 
     GlyphData markGlyphData;
     if (!getEmphasisMarkGlyphData(mark, markGlyphData))
         return;
 
     const SimpleFontData* markFontData = markGlyphData.fontData;
     ASSERT(markFontData);
     if (!markFontData)
         return;
 
     GlyphBuffer markBuffer;
-    float midMarkOffset = offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph);
+    bool drawVertically = markFontData->platformData().orientation() == Vertical && markFontData->verticalData();
     for (unsigned i = 0; i < glyphBuffer.size(); ++i) {
         // Skip marks for suppressed glyphs.
         if (!glyphBuffer.glyphAt(i))
             continue;
 
         // We want the middle of the emphasis mark aligned with the middle of the glyph.
         // The input offsets are already adjusted to point to the middle of the glyph, so all
         // is left to do is adjust for 1/2 mark width.
         // FIXME: we could avoid this by passing some additional info to the shaper,
         //        and perform all adjustments at buffer build time.
-        markBuffer.add(markGlyphData.glyph, markFontData, glyphBuffer.xOffsetAt(i) - midMarkOffset);
+        if (!drawVertically) {
+            markBuffer.add(markGlyphData.glyph, markFontData, glyphBuffer.xOffsetAt(i) - offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph));
+        } else {
+            markBuffer.add(markGlyphData.glyph, markFontData, FloatPoint(- offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph),
+                glyphBuffer.xOffsetAt(i) - offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph, Vertical)));
+        }
     }
 
     drawGlyphBuffer(context, runInfo, markBuffer, point);
 }
 
 float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, IntRectExtent* glyphBounds) const
 {
     SimpleShaper::GlyphBounds bounds;
     SimpleShaper shaper(this, run, fallbackFonts, glyphBounds ? &bounds : 0);
     shaper.advance(run.length());
@@ skipping 68 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink