Implement TrueType kerning support for HarfBuzz text path.

Source/core/platform/graphics/harfbuzz/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
+ * Copyright (C) 2013 BlackBerry Limited. 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
@@ skipping 29 matching lines @@
 #include "wtf/Vector.h"
 #include <unicode/normlzr.h>
 #include <unicode/uchar.h>
 
 #include <list>
 #include <map>
 #include <string>
 
 namespace WebCore {
 
+const hb_tag_t cligTag = HB_TAG('c', 'l', 'i', 'g');
+const hb_tag_t dligTag = HB_TAG('d', 'l', 'i', 'g');
+const hb_tag_t hligTag = HB_TAG('h', 'l', 'i', 'g');
+const hb_tag_t kernTag = HB_TAG('k', 'e', 'r', 'n');
+const hb_tag_t ligaTag = HB_TAG('l', 'i', 'g', 'a');
+
 template<typename T>
 class HarfBuzzScopedPtr {
 public:
     typedef void (*DestroyFunction)(T*);
 
     HarfBuzzScopedPtr(T* ptr, DestroyFunction destroy)
         : m_ptr(ptr)
         , m_destroy(destroy)
     {
         ASSERT(m_destroy);
@@ skipping 439 matching lines @@
 void HarfBuzzShaper::setFontFeatures()
 {
     const FontDescription& description = m_font->fontDescription();
     if (description.orientation() == Vertical) {
         static hb_feature_t vert = { HarfBuzzFace::vertTag, 1, 0, static_cast<unsigned>(-1) };
         static hb_feature_t vrt2 = { HarfBuzzFace::vrt2Tag, 1, 0, static_cast<unsigned>(-1) };
         m_features.append(vert);
         m_features.append(vrt2);
     }
 
+    static hb_feature_t kern = { kernTag, 1, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t noKern = { kernTag, 0, 0, static_cast<unsigned>(-1) };
+    if (!(m_font->typesettingFeatures() & Kerning)) {
+        m_features.append(noKern);
+    } else {
+        switch (description.kerning()) {
+        case FontDescription::NormalKerning:
+            m_features.append(kern);
+            break;
+        case FontDescription::NoneKerning:
+            m_features.append(noKern);
+            break;
+        case FontDescription::AutoKerning:
+            break;
+        }
+    }
+
+    static hb_feature_t liga = { ligaTag, 1, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t noLiga = { ligaTag, 0, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t clig = { cligTag, 1, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t noClig = { cligTag, 0, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t dlig = { dligTag, 1, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t noDlig = { dligTag, 0, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t hlig = { hligTag, 1, 0, static_cast<unsigned>(-1) };
+    static hb_feature_t noHlig = { hligTag, 0, 0, static_cast<unsigned>(-1) };
+    if (!(m_font->typesettingFeatures() & Ligatures)) {
+        m_features.append(noLiga);
+        m_features.append(noClig);
+        m_features.append(noDlig);
+        m_features.append(noHlig);
+    } else {
+        switch (description.commonLigaturesState()) {
+        case FontDescription::DisabledLigaturesState:
+            m_features.append(noLiga);
+            m_features.append(noClig);
+            break;
+        case FontDescription::EnabledLigaturesState:
+            m_features.append(liga);

[behdad_google, 2013/11/15 16:26:35]

Don't append features that are enabled by default.  This pollutes harfbuzz's
internal caches unnecessarily.

+            m_features.append(clig);
+            break;
+        case FontDescription::NormalLigaturesState:
+            break;
+        }
+        switch (description.discretionaryLigaturesState()) {
+        case FontDescription::DisabledLigaturesState:
+            m_features.append(noDlig);
+            break;
+        case FontDescription::EnabledLigaturesState:
+            m_features.append(dlig);
+            break;
+        case FontDescription::NormalLigaturesState:
+            break;
+        }
+        switch (description.historicalLigaturesState()) {
+        case FontDescription::DisabledLigaturesState:
+            m_features.append(noHlig);
+            break;
+        case FontDescription::EnabledLigaturesState:
+            m_features.append(hlig);
+            break;
+        case FontDescription::NormalLigaturesState:
+            break;
+        }
+    }
+
     FontFeatureSettings* settings = description.featureSettings();
     if (!settings)
         return;
 
     unsigned numFeatures = settings->size();
     for (unsigned i = 0; i < numFeatures; ++i) {
         hb_feature_t feature;
         String tag = settings->at(i).tag();
         feature.tag = HB_TAG(tag[0], tag[1], tag[2], tag[3]);
         feature.value = settings->at(i).value();
@@ skipping 159 matching lines @@
             currentFontData = m_font->glyphDataForCharacter(upperText[0], false, SmallCapsVariant).fontData;
             ASSERT(!upperText.is8Bit()); // m_normalizedBuffer is 16 bit, therefore upperText is 16 bit, even after we call makeUpper().
             hb_buffer_add_utf16(harfBuzzBuffer.get(), toUint16(upperText.characters16()), currentRun->numCharacters(), 0, currentRun->numCharacters());
         } else {
             hb_buffer_add_utf16(harfBuzzBuffer.get(), toUint16(m_normalizedBuffer.get() + currentRun->startIndex()), currentRun->numCharacters(), 0, currentRun->numCharacters());
         }
 
         if (m_font->fontDescription().orientation() == Vertical)
             face->setScriptForVerticalGlyphSubstitution(harfBuzzBuffer.get());
 
-        HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(), hb_font_destroy);
+        HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(m_font->typesettingFeatures()), hb_font_destroy);
 
         hb_shape(harfBuzzFont.get(), harfBuzzBuffer.get(), m_features.isEmpty() ? 0 : m_features.data(), m_features.size());
         currentRun->applyShapeResult(harfBuzzBuffer.get());
         setGlyphPositionsForHarfBuzzRun(currentRun, harfBuzzBuffer.get());
 
         runCache.insert(key, new CachedShapingResults(harfBuzzBuffer.get(), m_font, props.direction));
 
         harfBuzzBuffer.set(hb_buffer_create());
         hb_buffer_set_unicode_funcs(harfBuzzBuffer.get(), hb_icu_get_unicode_funcs());
     }
@@ skipping 173 matching lines @@
     if (!foundToX)
         toX = m_run.rtl() ? 0 : m_totalWidth;
 
     // Using floorf() and roundf() as the same as mac port.
     if (fromX < toX)
         return FloatRect(floorf(point.x() + fromX), point.y(), roundf(toX - fromX), height);
     return FloatRect(floorf(point.x() + toX), point.y(), roundf(fromX - toX), height);
 }
 
 } // namespace WebCore