Optimize Complex Text Shaping and Caching

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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "platform/fonts/Font.h"
 
 #include "SkPaint.h"
 #include "SkTemplates.h"
+#include "hb-ot.h"
+#include "hb.h"
 #include "platform/LayoutUnit.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/Character.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontFallbackList.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/GlyphPageTreeNode.h"
 #include "platform/fonts/SimpleFontData.h"
+#include "platform/fonts/shaping/HarfBuzzFace.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/fonts/shaping/SimpleShaper.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRun.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/transforms/AffineTransform.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/unicode/CharacterNames.h"
 #include "wtf/unicode/Unicode.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
 Font::Font()
 {
 }
 
 Font::Font(const FontDescription& fd)
     : m_fontDescription(fd)
+    , m_canShapeWordByWord(0)
+    , m_shapeWordByWordComputed(0)
 {
 }
 
 Font::Font(const Font& other)
     : m_fontDescription(other.m_fontDescription)
     , m_fontFallbackList(other.m_fontFallbackList)
+    , m_canShapeWordByWord(0)
+    , m_shapeWordByWordComputed(0)
 {
 }
 
 Font& Font::operator=(const Font& other)
 {
     m_fontDescription = other.m_fontDescription;
     m_fontFallbackList = other.m_fontFallbackList;
+    m_canShapeWordByWord = other.m_canShapeWordByWord;
+    m_shapeWordByWordComputed = other.m_shapeWordByWordComputed;
     return *this;
 }
 
 bool Font::operator==(const Font& other) const
 {
     FontSelector* first = m_fontFallbackList ? m_fontFallbackList->fontSelector() : 0;
     FontSelector* second = other.m_fontFallbackList ? other.m_fontFallbackList->fontSelector() : 0;
 
     return first == second
         && m_fontDescription == other.m_fontDescription
@@ skipping 10 matching lines @@
     // 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,
     const GlyphData* emphasisData) const
 {
     if (codePath(runInfo) == ComplexPath) {
-        HarfBuzzShaper shaper(this, runInfo.run, emphasisData);
-        shaper.setDrawRange(runInfo.from, runInfo.to);
-        shaper.shape(&glyphBuffer);
-        return shaper.totalWidth();
+        float width;
+        if (emphasisData) {
+            // FIXME: Populate using CachingWordShaper.

[drott, 2015/06/23 12:45:51]

IIRC, in a couple of reviews dpranke asked me to never leave FIXME's dangling
without corresponding bugs, which I find good practice. Could you file an issue
for this issue of emphasis glyphbuffer filling and mark it as blocking 462643?

On the issue itself, I've been thinking about what it would take to solve this:
I think the problem is that we lose the original word/string, right? For
emphasis glyphBuffer filling we need the shapeResult, especially the
glyphToCharacterIndex() method, which is based on the
m_glyphData.characterIndex, but also the original string to do
countGraphemesInCluster. So, the only way to solve this would be to somehow do 
countGraphemesInCluster over the required intervals - when we need emphasis
drawing - and then keep this information with our ShapeCacheEntry / ShapeResult.

+            HarfBuzzShaper shaper(this, runInfo.run);
+            RefPtr<ShapeResult> shapeResult = shaper.shapeResult();
+            shapeResult->fillGlyphBufferForTextEmphasis(&glyphBuffer, 0,
+                runInfo.run, emphasisData, runInfo.from, runInfo.to, 0);
+            width = shapeResult->width();
+        } else {
+            CachingWordShaper& shaper = m_fontFallbackList->cachingWordShaper();
+            width = shaper.fillGlyphBuffer(this, runInfo.run, nullptr,
+                &glyphBuffer, runInfo.from, runInfo.to);
+        }
+
+        return width;
     }
 
     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());
@@ skipping 207 matching lines @@
     if (run.codePath() == TextRun::ForceSimple)
         return SimplePath;
 
     if (run.is8Bit())
         return SimplePath;
 
     // Start from 0 since drawing and highlighting also measure the characters before run->from.
     return Character::characterRangeCodePath(run.characters16(), run.length());
 }
 
+static inline bool tableHasSpace(hb_face_t* face, hb_set_t* glyphs,
+    hb_tag_t tag, hb_codepoint_t space)
+{
+    unsigned count = hb_ot_layout_table_get_lookup_count(face, tag);
+    for (unsigned i = 0; i < count; i++) {
+        hb_ot_layout_lookup_collect_glyphs(face, tag, i, glyphs, glyphs, glyphs,
+            0);
+        if (hb_set_has(glyphs, space))
+            return true;
+    }
+    return false;
+}
+
+bool Font::canShapeWordByWord() const
+{
+    if (!m_shapeWordByWordComputed) {
+        m_canShapeWordByWord = computeCanShapeWordByWord();
+        m_shapeWordByWordComputed = true;
+    }
+    return m_canShapeWordByWord;
+};
+
+bool Font::computeCanShapeWordByWord() const
+{
+    if (!fontDescription().typesettingFeatures())
+        return true;
+
+    const FontPlatformData& platformData = primaryFont()->platformData();

[drott, 2015/06/23 12:45:51]

I'd suggest to move the code from below this line to the end of the method to
FontPlatformData and then call something like hasSpaceInLigaturesOrKerning() to
combine this with typeSettingFeatures() to have your local answer for
computeCanShapeWordByWord(). My reasoning would be that the code is more low
level, actually looks at the TTF blob and that it's actually operating on
FontPlatformData.

+    const HarfBuzzFace* hbFace = platformData.harfBuzzFace();
+    if (!hbFace)
+        return true;
+
+    hb_face_t* face = hbFace->face();
+    ASSERT(face);
+    hb_font_t* font = hbFace->createFont();
+    ASSERT(font);
+
+    hb_codepoint_t space;
+    // If the space glyph isn't present in the font then each space character
+    // will be rendering using a fallback font, which grantees that it cannot
+    // affect the shape of the preceding word.
+    if (!hb_font_get_glyph(font, spaceCharacter, 0, &space))
+        return true;
+
+    if (!hb_ot_layout_has_substitution(face)
+        && !hb_ot_layout_has_positioning(face)) {
+        return true;
+    }
+
+    hb_set_t* glyphs = hb_set_create();
+    TypesettingFeatures features = fontDescription().typesettingFeatures();
+
+    bool foundSpaceInTable = false;
+    if (features & Kerning)
+        foundSpaceInTable = tableHasSpace(face, glyphs, HB_OT_TAG_GPOS, space);
+    if (!foundSpaceInTable && (features & Ligatures))
+        foundSpaceInTable = tableHasSpace(face, glyphs, HB_OT_TAG_GSUB, space);
+
+    hb_set_destroy(glyphs);
+    hb_font_destroy(font);
+
+    return !foundSpaceInTable;
+};
+
 void Font::willUseFontData(UChar32 character) const
 {
     const FontFamily& family = fontDescription().family();
     if (m_fontFallbackList && m_fontFallbackList->fontSelector() && !family.familyIsEmpty())
         m_fontFallbackList->fontSelector()->willUseFontData(fontDescription(), family.family(), character);
 }
 
 static inline GlyphData glyphDataForNonCJKCharacterWithGlyphOrientation(UChar32 character, FontOrientation orientation, GlyphData& data, unsigned pageNumber)
 {
     if (isVerticalNonCJKUpright(orientation) || Character::shouldIgnoreRotation(character)) {
@@ skipping 316 matching lines @@
     canvas->restoreToCount(canvasStackLevel);
 }
 
 void Font::drawTextBlob(SkCanvas* canvas, const SkPaint& paint, const SkTextBlob* blob, const SkPoint& origin) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     canvas->drawTextBlob(blob, origin.x(), origin.y(), paint);
 }
 
-float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* outGlyphBounds) const
+float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBounds) const
 {
-    bool hasWordSpacingOrLetterSpacing = fontDescription().wordSpacing()
-        || fontDescription().letterSpacing();
-    // Word spacing and letter spacing can change the width of a word.
-    // If a tab occurs inside a word, the width of the word varies based on its
-    // position on the line.
-    bool isCacheable = !hasWordSpacingOrLetterSpacing && !run.allowTabs();
-
-    WidthCacheEntry* cacheEntry = isCacheable
-        ? m_fontFallbackList->widthCache().add(run, WidthCacheEntry())
-        : 0;
-    if (cacheEntry && cacheEntry->isValid()) {
-        if (outGlyphBounds)
-            *outGlyphBounds = cacheEntry->glyphBounds;
-        return cacheEntry->width;
-    }
-
-    FloatRect glyphBounds;
-    HarfBuzzShaper shaper(this, run, nullptr, fallbackFonts, &glyphBounds);
-    if (!shaper.shape())
-        return 0;
-
-    float result = shaper.totalWidth();
-
-    if (cacheEntry && (!fallbackFonts || fallbackFonts->isEmpty())) {
-        cacheEntry->glyphBounds = glyphBounds;
-        cacheEntry->width = result;
-    }
-
-    if (outGlyphBounds)
-        *outGlyphBounds = glyphBounds;
-    return result;
+    CachingWordShaper& shaper = m_fontFallbackList->cachingWordShaper();
+    float width = shaper.width(this, run, fallbackFonts, glyphBounds);
+    return width;
 }
 
 // Return the code point index for the given |x| offset into the text run.
 int Font::offsetForPositionForComplexText(const TextRun& run, float xFloat,
     bool includePartialGlyphs) const
 {
     HarfBuzzShaper shaper(this, run);
-    if (!shaper.shape())
+    RefPtr<ShapeResult> shapeResult = shaper.shapeResult();
+    if (!shapeResult)
         return 0;
-    return shaper.offsetForPosition(xFloat);
+    return shapeResult->offsetForPosition(xFloat);
 }
 
 // Return the rectangle for selecting the given range of code-points in the TextRun.
 FloatRect Font::selectionRectForComplexText(const TextRun& run,
     const FloatPoint& point, int height, int from, int to) const
 {
     HarfBuzzShaper shaper(this, run);
-    if (!shaper.shape())
+    RefPtr<ShapeResult> shapeResult = shaper.shapeResult();
+    if (!shapeResult)
         return FloatRect();
-    return shaper.selectionRect(point, height, from, to);
+    return shapeResult->selectionRect(point, height, from, to);
 }
 
 void Font::drawGlyphBuffer(SkCanvas* canvas, const SkPaint& paint, const TextRunPaintInfo& runInfo, const GlyphBuffer& glyphBuffer, const FloatPoint& point, float deviceScaleFactor) const
 {
     if (glyphBuffer.isEmpty())
         return;
 
     if (RuntimeEnabledFeatures::textBlobEnabled()) {
         // Enabling text-blobs forces the blob rendering path even for uncacheable blobs.
         TextBlobPtr uncacheableTextBlob;
@@ skipping 101 matching lines @@
 {
     return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const
 {
     return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 } // namespace blink