Simplify text emphasis painting

Source/platform/fonts/shaping/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 329 matching lines @@
     } else {
         while (glyphIndex < m_numGlyphs && m_glyphToCharacterIndexes[glyphIndex] < offset) {
             position += m_advances[glyphIndex];
             ++glyphIndex;
         }
     }
     return position;
 }
 
 
-HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run, ForTextEmphasisOrNot forTextEmphasis, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* bounds)
-    : Shaper(font, run, forTextEmphasis, fallbackFonts, bounds)
+HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run, const GlyphData* emphasisData,
+    HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* bounds)
+    : Shaper(font, run, emphasisData, fallbackFonts, bounds)
     , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
     , m_letterSpacing(font->fontDescription().letterSpacing())
     , m_expansionOpportunityCount(0)
     , m_fromIndex(0)
     , m_toIndex(m_run.length())
 {
     setExpansion(m_run.expansion());
     setFontFeatures();
 }
 
@@ skipping 794 matching lines @@
                 advanceSoFar += advances[i];
             }
         }
     }
 
     return advanceSoFar - initialAdvance;
 }
 
 float HarfBuzzShaper::fillGlyphBufferForTextEmphasis(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun, float initialAdvance)
 {
-    // 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.
@@ skipping 28 matching lines @@
             else
                 clusterEnd = isRunEnd ? currentRun->startIndex() + currentRun->numCharacters() : currentRun->startIndex() + glyphToCharacterIndexes[i + 1];
 
             graphemesInCluster = m_run.is8Bit() ? 1 : countGraphemesInCluster(m_run.characters16(), m_run.length(), 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.
-                Glyph glyphToAdd = Character::canReceiveTextEmphasis(m_run[currentCharacterIndex]) ? 1 : 0;
-                // The emphasis code expects mid-glyph offsets.
-                glyphBuffer->add(glyphToAdd, currentRun->fontData(), advanceSoFar + glyphAdvanceX / 2);
+                if (Character::canReceiveTextEmphasis(m_run[currentCharacterIndex]))
+                    addEmphasisMark(glyphBuffer, advanceSoFar + glyphAdvanceX / 2);
+
                 advanceSoFar += glyphAdvanceX;
             }
             clusterStart = clusterEnd;
             clusterAdvance = 0;
         }
     }
 
     return advanceSoFar - initialAdvance;
 }
 
 bool HarfBuzzShaper::fillGlyphBuffer(GlyphBuffer* glyphBuffer)
 {
     ASSERT(glyphBuffer);
 
     unsigned numRuns = m_harfBuzzRuns.size();
     float advanceSoFar = 0;
     for (unsigned runIndex = 0; runIndex < numRuns; ++runIndex) {
         HarfBuzzRun* currentRun = m_harfBuzzRuns[m_run.ltr() ? runIndex : numRuns - runIndex - 1].get();
         // Skip runs that only contain control characters.
         if (!currentRun->numGlyphs())
             continue;
-        advanceSoFar += (m_forTextEmphasis == ForTextEmphasis)
+        advanceSoFar += forTextEmphasis()
             ? fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun, advanceSoFar)
             : fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, advanceSoFar);
     }
     return glyphBuffer->size();
 }
 
 int HarfBuzzShaper::offsetForPosition(float targetX)
 {
     int charactersSoFar = 0;
     float currentX = 0;
@@ skipping 70 matching lines @@
     // possibly invalid from, to arguments.
     if (!foundToX && !foundFromX)
         fromX = toX = 0;
 
     if (fromX < toX)
         return FloatRect(point.x() + fromX, point.y(), toX - fromX, height);
     return FloatRect(point.x() + toX, point.y(), fromX - toX, height);
 }
 
 } // namespace blink