Implement CSS Emphasis Marks for complex text

Source/platform/fonts/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.
@@ skipping 20 matching lines @@
 
 #include "config.h"
 #include "platform/fonts/harfbuzz/HarfBuzzShaper.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "hb-icu.h"
 #include "platform/fonts/Character.h"
 #include "platform/fonts/Font.h"
 #include "platform/fonts/harfbuzz/HarfBuzzFace.h"
 #include "platform/text/SurrogatePairAwareTextIterator.h"
+#include "platform/text/TextBreakIterator.h"
 #include "wtf/MathExtras.h"
 #include "wtf/unicode/Unicode.h"
 #include <unicode/normlzr.h>
 #include <unicode/uchar.h>
 
 #include <list>
 #include <map>
 #include <string>
 
 namespace WebCore {
@@ skipping 150 matching lines @@
 {
     DEFINE_STATIC_LOCAL(HarfBuzzRunCache, globalHarfBuzzRunCache, ());
     return globalHarfBuzzRunCache;
 }
 
 static inline float harfBuzzPositionToFloat(hb_position_t value)
 {
     return static_cast<float>(value) / (1 << 16);
 }
 
+static inline unsigned countGraphemesInCluster(const TextRun& run, uint16_t startIndex, uint16_t endIndex)
+{
+    if (startIndex > endIndex) {
+        uint16_t tempIndex = startIndex;
+        startIndex = endIndex;
+        endIndex = tempIndex;
+    }
+    uint16_t length = endIndex - startIndex;
+    TextRun subRun = run.subRun(startIndex, length);
+
+    const UChar* source;
+    String stringFor8BitRun;
+    if (run.is8Bit()) {
+        stringFor8BitRun = String::make16BitFrom8BitSource(subRun.characters8(), subRun.length());

[eae, 2014/02/14 11:15:35]

I don't suppose we could have this method use m_normalizedBuffer instead?
Converting back and forth is quite expensive.

+        source = stringFor8BitRun.characters16();
+    } else {
+        source = subRun.characters16();
+    }
+    TextBreakIterator* cursorPosIterator = cursorMovementIterator(source, subRun.length());
+
+    int cursorPos = cursorPosIterator->current();
+    int numGraphemes = -1;
+    while (0 <= cursorPos) {
+        cursorPos = cursorPosIterator->next();
+        numGraphemes++;
+    }
+    return numGraphemes < 0 ? 0 : numGraphemes;
+}
+
 inline HarfBuzzShaper::HarfBuzzRun::HarfBuzzRun(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction, hb_script_t script)
     : m_fontData(fontData)
     , m_startIndex(startIndex)
     , m_numCharacters(numCharacters)
     , m_numGlyphs(0)
     , m_direction(direction)
     , m_script(script)
     , m_width(0)
 {
 }
@@ skipping 121 matching lines @@
         // Don't normalize tabs as they are not treated as spaces for word-end.
         if (Character::treatAsSpace(character) && character != '\t')
             character = ' ';
         else if (Character::treatAsZeroWidthSpaceInComplexScript(character))
             character = zeroWidthSpace;
         U16_APPEND(destination, *destinationLength, length, character, error);
         ASSERT_UNUSED(error, !error);
     }
 }
 
-HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run)
+HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run, ForTextEmphasisOrNot forTextEmphasis)
     : m_font(font)
     , m_normalizedBufferLength(0)
     , m_run(run)
     , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
     , m_padding(0)
     , m_padPerWordBreak(0)
     , m_padError(0)
     , m_letterSpacing(font->fontDescription().letterSpacing())
     , m_fromIndex(0)
     , m_toIndex(m_run.length())
+    , m_forTextEmphasis(forTextEmphasis)
 {
     m_normalizedBuffer = adoptArrayPtr(new UChar[m_run.length() + 1]);
     normalizeCharacters(m_run, m_run.length(), m_normalizedBuffer.get(), &m_normalizedBufferLength);
     setPadding(m_run.expansion());
     setFontFeatures();
 }
 
 static void normalizeSpacesAndMirrorChars(const UChar* source, unsigned length, UChar* destination, unsigned* destinationLength, HarfBuzzShaper::NormalizeMode normalizeMode)
 {
     unsigned position = 0;
@@ skipping 575 matching lines @@
     m_totalWidth += currentRun->width();
 }
 
 void HarfBuzzShaper::fillGlyphBufferFromHarfBuzzRun(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun, FloatPoint& firstOffsetOfNextRun)
 {
     FloatPoint* offsets = currentRun->offsets();
     uint16_t* glyphs = currentRun->glyphs();
     float* advances = currentRun->advances();
     unsigned numGlyphs = currentRun->numGlyphs();
     uint16_t* glyphToCharacterIndexes = currentRun->glyphToCharacterIndexes();
-
     for (unsigned i = 0; i < numGlyphs; ++i) {
         uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
         FloatPoint& currentOffset = offsets[i];
         FloatPoint& nextOffset = (i == numGlyphs - 1) ? firstOffsetOfNextRun : offsets[i + 1];
         float glyphAdvanceX = advances[i] + nextOffset.x() - currentOffset.x();
         float glyphAdvanceY = nextOffset.y() - currentOffset.y();
         if (m_run.rtl()) {
             if (currentCharacterIndex >= m_toIndex)
                 m_startOffset.move(glyphAdvanceX, glyphAdvanceY);
             else if (currentCharacterIndex >= m_fromIndex)
                 glyphBuffer->add(glyphs[i], currentRun->fontData(), createGlyphBufferAdvance(glyphAdvanceX, glyphAdvanceY));
         } else {
             if (currentCharacterIndex < m_fromIndex)
                 m_startOffset.move(glyphAdvanceX, glyphAdvanceY);
             else if (currentCharacterIndex < m_toIndex)
                 glyphBuffer->add(glyphs[i], currentRun->fontData(), createGlyphBufferAdvance(glyphAdvanceX, glyphAdvanceY));
         }
     }
 }
 
+void HarfBuzzShaper::fillGlyphBufferForTextEmphasis(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun)
+{
+    // FIXME: Instead of generating a synthetic GlyphBuffer here which is then used by the
+    // drawEmphasisMarks method of FontFastPath, we should roll our own emphasis mark drawing function.
+
+    float* advances = currentRun->advances();
+    unsigned numGlyphs = currentRun->numGlyphs();
+    uint16_t* glyphToCharacterIndexes = currentRun->glyphToCharacterIndexes();
+    unsigned graphemesInCluster = 1;
+    float clusterAdvance = 0;
+    uint16_t clusterStart;
+
+    // A "cluster" in this context means a cluster as it is used by HarfBuzz:
+    // The minimal group of characters and corresponding glyphs, that cannot be broken
+    // down further from a text shaping point of view.
+    // A cluster can contain multiple glyphs and grapheme clusters, with mutually
+    // overlapping boundaries. Below we count grapheme clusters per HarfBuzz clusters,
+    // then linearly split the sum of corresponding glyph advances by the number of
+    // grapheme clusters in order to find positions for emphasis mark drawing.
+
+    if (m_run.rtl())
+        clusterStart = currentRun->startIndex() + currentRun->numCharacters();
+    else
+        clusterStart = currentRun->startIndex() + glyphToCharacterIndexes[0];
+
+    for (unsigned i = 0; i < numGlyphs; ++i) {
+        uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
+        bool isRunEnd = (i + 1 == numGlyphs);
+        bool isClusterEnd =  isRunEnd || (currentRun->startIndex() + glyphToCharacterIndexes[i + 1] != currentCharacterIndex);
+        clusterAdvance += advances[i];
+
+        if (isClusterEnd) {
+            uint16_t clusterEnd;
+            if (m_run.rtl())
+                clusterEnd = currentCharacterIndex;
+            else
+                clusterEnd = isRunEnd ? currentRun->startIndex() + currentRun->numCharacters() : currentRun->startIndex() + glyphToCharacterIndexes[i + 1];
+
+            graphemesInCluster = countGraphemesInCluster(m_run, clusterStart, clusterEnd);
+            if (!graphemesInCluster || !clusterAdvance)
+                continue;
+
+            float glyphAdvanceX = clusterAdvance / graphemesInCluster;
+            for (unsigned j = 0; j < graphemesInCluster; ++j) {
+                // Do not put emphasis marks on space, separator, and control characters.
+                GlyphBufferGlyph glyphToAdd = Character::canReceiveTextEmphasis(m_run[currentCharacterIndex]) ? 1 : 0;
+                glyphBuffer->add(glyphToAdd, currentRun->fontData(), createGlyphBufferAdvance(glyphAdvanceX, 0));
+            }
+            clusterStart = clusterEnd;
+            clusterAdvance = 0;
+        }
+    }
+}
+
 bool HarfBuzzShaper::fillGlyphBuffer(GlyphBuffer* glyphBuffer)
 {
     unsigned numRuns = m_harfBuzzRuns.size();
     if (m_run.rtl()) {
         m_startOffset = m_harfBuzzRuns.last()->offsets()[0];
         for (int runIndex = numRuns - 1; runIndex >= 0; --runIndex) {
             HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
             FloatPoint firstOffsetOfNextRun = !runIndex ? FloatPoint() : m_harfBuzzRuns[runIndex - 1]->offsets()[0];
-            fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, firstOffsetOfNextRun);
+            if (m_forTextEmphasis == ForTextEmphasis)
+                fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun);
+            else
+                fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, firstOffsetOfNextRun);
         }
     } else {
         m_startOffset = m_harfBuzzRuns.first()->offsets()[0];
         for (unsigned runIndex = 0; runIndex < numRuns; ++runIndex) {
             HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
             FloatPoint firstOffsetOfNextRun = runIndex == numRuns - 1 ? FloatPoint() : m_harfBuzzRuns[runIndex + 1]->offsets()[0];
-            fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, firstOffsetOfNextRun);
+            if (m_forTextEmphasis == ForTextEmphasis)
+                fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun);
+            else
+                fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, firstOffsetOfNextRun);
         }
     }
     return glyphBuffer->size();
 }
 
 int HarfBuzzShaper::offsetForPosition(float targetX)
 {
     int charactersSoFar = 0;
     float currentX = 0;
 
@@ skipping 64 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