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 uint16_t 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);
+
+    // FIXME: Perhaps turn this into a classic character break iterator?

[behdad, 2014/02/08 02:45:10]

What does this mean?

+    TextBreakIterator* cursorPosIterator = cursorMovementIterator(subRun.characters16(), length);
+
+    int cursorPos = cursorPosIterator->current();
+    uint16_t numGraphemes = -1; // Assumption
+    while (0 <= cursorPos) {
+        cursorPos = cursorPosIterator->next();
+        numGraphemes++;
+    }
+    return 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, bool forTextEmphasis)
     : m_font(font)
     , m_normalizedBufferLength(0)
     , m_run(run)
     , m_wordSpacingAdjustment(font->wordSpacing())
     , m_padding(0)
     , m_padPerWordBreak(0)
     , m_padError(0)
     , m_letterSpacing(font->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 536 matching lines @@
 }
 
 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));
+    // 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.
+    if (m_forTextEmphasis) {
+        uint16_t graphemesInCluster = 1;
+        uint16_t clusterStart;
+        float clusterAdvance = 0;
+        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 runEnd = (i + 1 == numGlyphs);
+            bool isClusterEnd =  runEnd || (currentRun->startIndex() + glyphToCharacterIndexes[i + 1] != currentCharacterIndex);
+            clusterAdvance += advances[i];
+
+            if (isClusterEnd) {
+                uint16_t clusterEnd;
+                if (m_run.rtl())
+                    clusterEnd = currentRun->startIndex() + glyphToCharacterIndexes[i];
+                else
+                    clusterEnd = runEnd ? currentRun->startIndex() + currentRun->numCharacters() : currentRun->startIndex() + glyphToCharacterIndexes[i + 1];

[behdad, 2014/02/08 02:45:10]

Looks to me like you can easily merge lines 962..965 with lines 955..957.

+                graphemesInCluster = countGraphemesInCluster(m_run, clusterStart, clusterEnd);
+                float glyphAdvanceX = clusterAdvance / graphemesInCluster;
+                for (unsigned j = 0; j < graphemesInCluster; ++j) {
+                    GlyphBufferGlyph glyphToAdd = Character::canReceiveTextEmphasis(m_run[currentCharacterIndex]) ? 1 : 0;
+                    glyphBuffer->add(glyphToAdd, currentRun->fontData(), createGlyphBufferAdvance(glyphAdvanceX, 0));

[behdad, 2014/02/08 02:45:10]

I think we should try to horizontally center the emphasis mark over the
glyphAdvanceX.

+                }
+                clusterStart = clusterEnd;
+                clusterAdvance = 0;
+            }
+        }
+    } else {
+        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));
+            }
         }
     }
 }
 
 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) {
@@ skipping 84 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