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 330 matching lines @@
         // Don't normalize tabs as they are not treated as spaces for word-end.
         if (Font::treatAsSpace(character) && character != '\t')
             character = ' ';
         else if (Font::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 295 matching lines @@
 
         hb_buffer_set_script(harfBuzzBuffer.get(), currentRun->script());
         hb_buffer_set_direction(harfBuzzBuffer.get(), currentRun->rtl() ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
 
         hb_segment_properties_t props;
         hb_buffer_get_segment_properties(harfBuzzBuffer.get(), &props);
 
         const UChar* src = m_normalizedBuffer.get() + currentRun->startIndex();
         std::wstring key(src, src + currentRun->numCharacters());
 
-        CachedShapingResults* cachedResults = runCache.find(key);
+        CachedShapingResults* cachedResults = m_forTextEmphasis ? 0 : runCache.find(key);
         if (cachedResults) {
             if (cachedResults->dir == props.direction && cachedResults->font == *m_font) {
                 currentRun->applyShapeResult(cachedResults->buffer);
                 setGlyphPositionsForHarfBuzzRun(currentRun, cachedResults->buffer);
 
                 hb_buffer_reset(harfBuzzBuffer.get());
 
                 runCache.moveToBack(cachedResults);
 
                 continue;
@@ skipping 18 matching lines @@
 
         if (m_font->fontDescription().orientation() == Vertical)
             face->setScriptForVerticalGlyphSubstitution(harfBuzzBuffer.get());
 
         HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(), 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));
+        if (!m_forTextEmphasis)
+            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());
     }
 
     return true;
 }
 
 void HarfBuzzShaper::setGlyphPositionsForHarfBuzzRun(HarfBuzzRun* currentRun, hb_buffer_t* harfBuzzBuffer)
 {
@@ skipping 53 matching lines @@
     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();
+
+        Glyph glyphToAdd = glyphs[i];
+        UChar ch = m_run[currentCharacterIndex];
+        if (m_forTextEmphasis)
+            printf("Glyph: 0x%x, Character: 0x%x\n", glyphToAdd, ch);

[Dominik Röttsches, 2014/01/16 16:37:32]

When running this against:
http://roettsch.es/emphasis_simple.html
(just a simple กำ with CSS emphasis) I get currently get three emphasis marks,
but there should be only one for this cluster.

I get 
Glyph: 0xe3, Character: 0xe01
Glyph: 0x12c, Character: 0xe01
Glyph: 0x114, Character: 0xe01

The way this works on mac, for each run, it goes through the list of glyphs,
get's the character for each glyph and checks whether this matches the
U_GC_M_MASK - returns an empty glyph if it does. Which leads to no emphasis mark
being drawn for that glyph index.

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

The output on Mac is:
Glyph: 0x4ab, Character: 0xe01

In my patch, I get three emphasis marks, on the mac I get one.

The CSS Text Decoration Module says that there should be one emphasis mark per
character, which in this spec is a synonym for a grapheme cluster.

Behdad - would you have an idea how I can filter here? Would I need to scan
backwards and forwards through glyphToCharacterIndexes here to see whether the
glyph belongs to the same grapheme cluster, or are there better ways to figure
this out?

+
+        // FIXME: Combining marks should receive a text emphasis mark if they are combine with a space.
+        if (m_forTextEmphasis && (!Font::canReceiveTextEmphasis(ch) || (U_GET_GC_MASK(ch) & U_GC_M_MASK)))
+            glyphToAdd = 0;
+
         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));
+                glyphBuffer->add(glyphToAdd, 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));
+                glyphBuffer->add(glyphToAdd, 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