Simplify text emphasis painting

Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 81 matching lines @@
     // being reasonably safe (because inherited fonts in the render tree pick up the new
     // style anyway. Other copies are transient, e.g., the state in the GraphicsContext, and
     // won't stick around long enough to get you in trouble). Still, this is pretty disgusting,
     // and could eventually be rectified by using RefPtrs for Fonts themselves.
     if (!m_fontFallbackList)
         m_fontFallbackList = FontFallbackList::create();
     m_fontFallbackList->invalidate(fontSelector);
 }
 
 float Font::buildGlyphBuffer(const TextRunPaintInfo& runInfo, GlyphBuffer& glyphBuffer,
-    ForTextEmphasisOrNot forTextEmphasis) const
+    const GlyphData* emphasisData) const
 {
     if (codePath(runInfo) == ComplexPath) {
-        HarfBuzzShaper shaper(this, runInfo.run, (forTextEmphasis == ForTextEmphasis)
-            ? HarfBuzzShaper::ForTextEmphasis : HarfBuzzShaper::NotForTextEmphasis);
+        HarfBuzzShaper shaper(this, runInfo.run, emphasisData);
         shaper.setDrawRange(runInfo.from, runInfo.to);
         shaper.shape(&glyphBuffer);
         return shaper.totalWidth();
     }
 
-    SimpleShaper shaper(this, runInfo.run, nullptr /* fallbackFonts */,
-        nullptr, forTextEmphasis);
+    SimpleShaper shaper(this, runInfo.run, emphasisData, nullptr /* fallbackFonts */, nullptr);
     shaper.advance(runInfo.from);
     shaper.advance(runInfo.to, &glyphBuffer);
     float width = shaper.runWidthSoFar();
 
     if (runInfo.run.rtl()) {
         // Glyphs are shaped & stored in RTL advance order - reverse them for LTR drawing.
         shaper.advance(runInfo.run.length());
         glyphBuffer.reverseForSimpleRTL(width, shaper.runWidthSoFar());
     }
 
@@ skipping 73 matching lines @@
     }
 
     bidiRuns.deleteRuns();
 }
 
 void Font::drawEmphasisMarks(GraphicsContext* context, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point) const
 {
     if (shouldSkipDrawing())
         return;
 
+    FontCachePurgePreventer purgePreventer;
+
+    GlyphData emphasisGlyphData;
+    if (!getEmphasisMarkGlyphData(mark, emphasisGlyphData))
+        return;
+
+    ASSERT(emphasisGlyphData.fontData);
+    if (!emphasisGlyphData.fontData)
+        return;
+
     GlyphBuffer glyphBuffer;
-    buildGlyphBuffer(runInfo, glyphBuffer, ForTextEmphasis);
+    buildGlyphBuffer(runInfo, glyphBuffer, &emphasisGlyphData);
 
     if (glyphBuffer.isEmpty())
         return;
 
-    drawEmphasisMarks(context, runInfo, glyphBuffer, mark, point);
+    drawGlyphBuffer(context, runInfo, glyphBuffer, point);
 }
 
 static inline void updateGlyphOverflowFromBounds(const IntRectOutsets& glyphBounds,
     const FontMetrics& fontMetrics, GlyphOverflow* glyphOverflow)
 {
     glyphOverflow->top = std::max<int>(glyphOverflow->top,
         glyphBounds.top() - (glyphOverflow->computeBounds ? 0 : fontMetrics.ascent()));
     glyphOverflow->bottom = std::max<int>(glyphOverflow->bottom,
         glyphBounds.bottom() - (glyphOverflow->computeBounds ? 0 : fontMetrics.descent()));
     glyphOverflow->left = glyphBounds.left();
@@ skipping 550 matching lines @@
         SkPaint paint = gc->strokePaint();
         if (textMode & TextModeFill)
             paint.setLooper(0);
         gc->drawTextBlob(blob, origin, paint);
     }
 }
 
 float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, IntRectOutsets* glyphBounds) const
 {
     FloatRect bounds;
-    HarfBuzzShaper shaper(this, run, HarfBuzzShaper::NotForTextEmphasis, fallbackFonts, glyphBounds ? &bounds : 0);
+    HarfBuzzShaper shaper(this, run, nullptr, fallbackFonts, glyphBounds ? &bounds : 0);
     if (!shaper.shape())
         return 0;
 
     glyphBounds->setTop(ceilf(-bounds.y()));
     glyphBounds->setBottom(ceilf(bounds.maxY()));
     glyphBounds->setLeft(std::max<int>(0, ceilf(-bounds.x())));
     glyphBounds->setRight(std::max<int>(0, ceilf(bounds.maxX() - shaper.totalWidth())));
 
     return shaper.totalWidth();
 }
@@ skipping 51 matching lines @@
 
             lastFrom = nextGlyph;
             fontData = nextFontData;
         }
     }
 
     drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, point,
         runInfo.bounds);
 }
 
-inline static float offsetToMiddleOfGlyph(const SimpleFontData* fontData, Glyph glyph, FontOrientation orientation = Horizontal)
-{
-    FloatRect bounds = fontData->boundsForGlyph(glyph);
-    if (orientation == Horizontal)
-        return bounds.x() + bounds.width() / 2;
-    return bounds.y() + bounds.height() / 2;
-}
-
-void Font::drawEmphasisMarks(GraphicsContext* context, const TextRunPaintInfo& runInfo, const GlyphBuffer& glyphBuffer, const AtomicString& mark, const FloatPoint& point) const
-{
-    FontCachePurgePreventer purgePreventer;
-
-    GlyphData markGlyphData;
-    if (!getEmphasisMarkGlyphData(mark, markGlyphData))
-        return;
-
-    const SimpleFontData* markFontData = markGlyphData.fontData;
-    ASSERT(markFontData);
-    if (!markFontData)
-        return;
-
-    GlyphBuffer markBuffer;
-    bool drawVertically = markFontData->platformData().orientation() == Vertical && markFontData->verticalData();
-    for (unsigned i = 0; i < glyphBuffer.size(); ++i) {
-        // Skip marks for suppressed glyphs.
-        if (!glyphBuffer.glyphAt(i))
-            continue;
-
-        // We want the middle of the emphasis mark aligned with the middle of the glyph.
-        // The input offsets are already adjusted to point to the middle of the glyph, so all
-        // is left to do is adjust for 1/2 mark width.
-        // FIXME: we could avoid this by passing some additional info to the shaper,
-        //        and perform all adjustments at buffer build time.
-        if (!drawVertically) {
-            markBuffer.add(markGlyphData.glyph, markFontData, glyphBuffer.xOffsetAt(i) - offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph));
-        } else {
-            markBuffer.add(markGlyphData.glyph, markFontData, FloatPoint(- offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph),
-                glyphBuffer.xOffsetAt(i) - offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph, Vertical)));
-        }
-    }
-
-    drawGlyphBuffer(context, runInfo, markBuffer, point);
-}
-
 float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, IntRectOutsets* glyphBounds) const
 {
     FloatRect bounds;
-    SimpleShaper shaper(this, run, fallbackFonts, glyphBounds ? &bounds : 0);
+    SimpleShaper shaper(this, run, nullptr, fallbackFonts, glyphBounds ? &bounds : 0);
     shaper.advance(run.length());
     float runWidth = shaper.runWidthSoFar();
 
     if (glyphBounds) {
         glyphBounds->setTop(ceilf(-bounds.y()));
         glyphBounds->setBottom(ceilf(bounds.maxY()));
         glyphBounds->setLeft(std::max<int>(0, ceilf(-bounds.x())));
         glyphBounds->setRight(std::max<int>(0, ceilf(bounds.maxX() - runWidth)));
     }
     return runWidth;
 }
 
 FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     FloatRect bounds;
-    SimpleShaper shaper(this, run, 0, accountForGlyphBounds ? &bounds : 0);
+    SimpleShaper shaper(this, run, nullptr, nullptr, accountForGlyphBounds ? &bounds : nullptr);
     shaper.advance(from);
     float fromX = shaper.runWidthSoFar();
     shaper.advance(to);
     float toX = shaper.runWidthSoFar();
 
     if (run.rtl()) {
         shaper.advance(run.length());
         float totalWidth = shaper.runWidthSoFar();
         float beforeWidth = fromX;
         float afterWidth = toX;
@@ skipping 43 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink