Replace ENABLE_OPENTYPE_VERTICAL implementation with HarfBuzz

Source/platform/fonts/shaping/HarfBuzzFace.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 24 matching lines @@
 #include "hb.h"
 #if OS(MACOSX)
 #include "hb-coretext.h"
 #endif
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPoint.h"
 #include "SkRect.h"
 #include "SkTypeface.h"
 #include "SkUtils.h"
+#include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontPlatformData.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "wtf/HashMap.h"
 
 namespace blink {
 
 const hb_tag_t HarfBuzzFace::vertTag = HB_TAG('v', 'e', 'r', 't');
 const hb_tag_t HarfBuzzFace::vrt2Tag = HB_TAG('v', 'r', 't', '2');
 
@@ skipping 83 matching lines @@
     if (m_scriptForVerticalText == HB_SCRIPT_INVALID)
         m_scriptForVerticalText = findScriptForVerticalGlyphSubstitution(m_face);
     hb_buffer_set_script(buffer, m_scriptForVerticalText);
 }
 
 struct HarfBuzzFontData {
     HarfBuzzFontData(WTF::HashMap<uint32_t, uint16_t>* glyphCacheForFaceCacheEntry)
         : m_glyphCacheForFaceCacheEntry(glyphCacheForFaceCacheEntry)
     { }
     SkPaint m_paint;
+    RefPtr<SimpleFontData> m_simpleFontData;
     WTF::HashMap<uint32_t, uint16_t>* m_glyphCacheForFaceCacheEntry;
 };
 
 static hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value)
 {
     return SkScalarToFixed(value);
 }
 
 static void SkiaGetGlyphWidthAndExtents(SkPaint* paint, hb_codepoint_t codepoint, hb_position_t* width, hb_glyph_extents_t* extents)
 {
@@ skipping 46 matching lines @@
     return advance;
 }
 
 static hb_bool_t harfBuzzGetGlyphHorizontalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData)
 {
     // Just return true, following the way that HarfBuzz-FreeType
     // implementation does.
     return true;
 }
 
+static hb_bool_t harfBuzzGetGlyphVerticalOrigin(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void* userData)
+{
+    HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData);
+    const OpenTypeVerticalData* verticalData = hbFontData->m_simpleFontData->verticalData();
+    if (!verticalData)
+        return false;
+
+    float result[] = { 0, 0 };
+    Glyph theGlyph = glyph;
+    verticalData->getVerticalTranslationsForGlyphs(hbFontData->m_simpleFontData.get(), &theGlyph, 1, result);
+    *x = SkiaScalarToHarfBuzzPosition(-result[0]);
+    *y = SkiaScalarToHarfBuzzPosition(-result[1]);
+    return true;
+}
+
+static hb_position_t harfBuzzGetGlyphVerticalAdvance(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, void* userData)
+{
+    HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData);
+    const OpenTypeVerticalData* verticalData = hbFontData->m_simpleFontData->verticalData();
+    if (!verticalData)
+        return SkiaScalarToHarfBuzzPosition(hbFontData->m_simpleFontData->fontMetrics().height());
+
+    Glyph theGlyph = glyph;
+    float advanceHeight = verticalData->advanceHeight(hbFontData->m_simpleFontData.get(), theGlyph);
+    return SkiaScalarToHarfBuzzPosition(SkFloatToScalar(advanceHeight));
+}
+
 static hb_position_t harfBuzzGetGlyphHorizontalKerning(hb_font_t*, void* fontData, hb_codepoint_t leftGlyph, hb_codepoint_t rightGlyph, void*)
 {
     HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData);
     if (hbFontData->m_paint.isVerticalText()) {
         // We don't support cross-stream kerning
         return 0;
     }
 
     SkTypeface* typeface = hbFontData->m_paint.getTypeface();
 
     const uint16_t glyphs[2] = { static_cast<uint16_t>(leftGlyph), static_cast<uint16_t>(rightGlyph) };
     int32_t kerningAdjustments[1] = { 0 };
 
     if (typeface->getKerningPairAdjustments(glyphs, 2, kerningAdjustments)) {
         SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm());
         SkScalar size = hbFontData->m_paint.getTextSize();
         return SkiaScalarToHarfBuzzPosition(SkScalarMulDiv(SkIntToScalar(kerningAdjustments[0]), size, upm));
     }
 
     return 0;
 }
 
-
 static hb_bool_t harfBuzzGetGlyphExtents(hb_font_t* hbFont, void* fontData, hb_codepoint_t glyph, hb_glyph_extents_t* extents, void* userData)
 {
     HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData);
 
     SkiaGetGlyphWidthAndExtents(&hbFontData->m_paint, glyph, 0, extents);
     return true;
 }
 
 static hb_font_funcs_t* harfBuzzSkiaGetFontFuncs()
 {
     static hb_font_funcs_t* harfBuzzSkiaFontFuncs = 0;
 
     // We don't set callback functions which we can't support.
     // HarfBuzz will use the fallback implementation if they aren't set.
     if (!harfBuzzSkiaFontFuncs) {
         harfBuzzSkiaFontFuncs = hb_font_funcs_create();
         hb_font_funcs_set_glyph_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyph, 0, 0);
         hb_font_funcs_set_glyph_h_advance_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalAdvance, 0, 0);
         hb_font_funcs_set_glyph_h_kerning_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalKerning, 0, 0);
         hb_font_funcs_set_glyph_h_origin_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphHorizontalOrigin, 0, 0);
+        hb_font_funcs_set_glyph_v_advance_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphVerticalAdvance, 0, 0);
+        hb_font_funcs_set_glyph_v_origin_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphVerticalOrigin, 0, 0);
         hb_font_funcs_set_glyph_extents_func(harfBuzzSkiaFontFuncs, harfBuzzGetGlyphExtents, 0, 0);
         hb_font_funcs_make_immutable(harfBuzzSkiaFontFuncs);
     }
     return harfBuzzSkiaFontFuncs;
 }
 
 #if !OS(MACOSX)
 static hb_blob_t* harfBuzzSkiaGetTable(hb_face_t* face, hb_tag_t tag, void* userData)
 {
     SkTypeface* typeface = reinterpret_cast<SkTypeface*>(userData);
@@ skipping 30 matching lines @@
     hb_face_t* face = hb_face_create_for_tables(harfBuzzSkiaGetTable, m_platformData->typeface(), 0);
 #endif
     ASSERT(face);
     return face;
 }
 
 hb_font_t* HarfBuzzFace::createFont()
 {
     HarfBuzzFontData* hbFontData = new HarfBuzzFontData(m_glyphCacheForFaceCacheEntry);
     m_platformData->setupPaint(&hbFontData->m_paint);
+    hbFontData->m_simpleFontData = FontCache::fontCache()->fontDataFromFontPlatformData(m_platformData);
+    ASSERT(hbFontData->m_simpleFontData);
     hb_font_t* font = hb_font_create(m_face);
     hb_font_set_funcs(font, harfBuzzSkiaGetFontFuncs(), hbFontData, destroyHarfBuzzFontData);
     float size = m_platformData->size();
     int scale = SkiaScalarToHarfBuzzPosition(size);
     hb_font_set_scale(font, scale, scale);
     hb_font_make_immutable(font);
     return font;
 }
 
 } // namespace blink