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
@@ skipping 17 matching lines @@
 #include "SkPaint.h"
 #include "SkTemplates.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;
+        CachingWordShaper& shaper = m_fontFallbackList->cachingWordShaper();
+        if (emphasisData) {
+            width = shaper.fillGlyphBufferForTextEmphasis(this, runInfo.run,
+                emphasisData, &glyphBuffer, runInfo.from, runInfo.to);
+        } else {
+            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 210 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());
 }
 
+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();
+    return !platformData.hasSpaceInLigaturesOrKerning();
+};
+
 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())
-        return FloatRect();
-    return shaper.selectionRect(point, height, from, to);
+    CachingWordShaper& shaper = m_fontFallbackList->cachingWordShaper();
+    return shaper.selectionRect(this, run, 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