Store glyph bounds in WordMeasurement to avoid slow path width calc

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 195 matching lines @@
 
     GlyphBuffer glyphBuffer;
     buildGlyphBuffer(runInfo, glyphBuffer, &emphasisGlyphData);
 
     if (glyphBuffer.isEmpty())
         return;
 
     drawGlyphBuffer(canvas, paint, runInfo, glyphBuffer, point, deviceScaleFactor);
 }
 
-static inline void updateGlyphOverflowFromBounds(const FloatRectOutsets& glyphBounds,
-    const FontMetrics& fontMetrics, GlyphOverflow* glyphOverflow)
-{
-    glyphOverflow->top = ceilf(glyphOverflow->computeBounds ? glyphBounds.top() : std::max(0.0f, glyphBounds.top() - fontMetrics.floatAscent()));
-    glyphOverflow->bottom = ceilf(glyphOverflow->computeBounds ? glyphBounds.bottom() : std::max(0.0f, glyphBounds.bottom() - fontMetrics.floatDescent()));
-    glyphOverflow->left = ceilf(glyphBounds.left());
-    glyphOverflow->right = ceilf(glyphBounds.right());
-}
-
-float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBounds) const
 {
     FontCachePurgePreventer purgePreventer;
 
-    CodePath codePathToUse = codePath(TextRunPaintInfo(run));
-
-    float result;
-    FloatRectOutsets glyphBounds;
-    if (codePathToUse == ComplexPath)
-        result = floatWidthForComplexText(run, fallbackFonts, &glyphBounds);
-    else
-        result = floatWidthForSimpleText(run, fallbackFonts, glyphOverflow ? &glyphBounds : 0);
-
-    if (glyphOverflow)
-        updateGlyphOverflowFromBounds(glyphBounds, fontMetrics(), glyphOverflow);
-    return result;
+    if (codePath(TextRunPaintInfo(run)) == ComplexPath)
+        return floatWidthForComplexText(run, fallbackFonts, glyphBounds);
+    return floatWidthForSimpleText(run, fallbackFonts, glyphBounds);
 }
 
 PassTextBlobPtr Font::buildTextBlob(const GlyphBuffer& glyphBuffer) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     SkTextBlobBuilder builder;
     bool hasVerticalOffsets = glyphBuffer.hasVerticalOffsets();
 
     unsigned i = 0;
@@ skipping 430 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, FloatRectOutsets* glyphBounds) const
+float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* outGlyphBounds) 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()) {
-        ASSERT(glyphBounds);
-        *glyphBounds = cacheEntry->glyphBounds;
+        if (outGlyphBounds)
+            *outGlyphBounds = cacheEntry->glyphBounds;
         return cacheEntry->width;
     }
 
-    FloatRect bounds;
-    HarfBuzzShaper shaper(this, run, nullptr, fallbackFonts, glyphBounds ? &bounds : 0);
+    FloatRect glyphBounds;
+    HarfBuzzShaper shaper(this, run, nullptr, fallbackFonts, &glyphBounds);
     if (!shaper.shape())
         return 0;
 
-    glyphBounds->setTop(-bounds.y());
-    glyphBounds->setBottom(bounds.maxY());
-    glyphBounds->setLeft(std::max(0.0f, -bounds.x()));
-    glyphBounds->setRight(std::max(0.0f, bounds.maxX() - shaper.totalWidth()));
+    float result = shaper.totalWidth();
 
-    float result = shaper.totalWidth();
     if (cacheEntry && (!fallbackFonts || fallbackFonts->isEmpty())) {
-        cacheEntry->glyphBounds = *glyphBounds;
+        cacheEntry->glyphBounds = glyphBounds;
         cacheEntry->width = result;
     }
 
+    if (outGlyphBounds)
+        *outGlyphBounds = glyphBounds;
     return result;
 }
 
 // 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())
         return 0;
@@ skipping 38 matching lines @@
         if (nextFontData != fontData) {
             drawGlyphs(canvas, paint, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, point, runInfo.bounds, deviceScaleFactor);
             lastFrom = nextGlyph;
             fontData = nextFontData;
         }
     }
 
     drawGlyphs(canvas, paint, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, point, runInfo.bounds, deviceScaleFactor);
 }
 
-float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRectOutsets* glyphBounds) const
+float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBounds) const
 {
-    FloatRect bounds;
-    SimpleShaper shaper(this, run, nullptr, fallbackFonts, glyphBounds ? &bounds : 0);
+    SimpleShaper shaper(this, run, nullptr, fallbackFonts, glyphBounds);
     shaper.advance(run.length());
-    float runWidth = shaper.runWidthSoFar();
-
-    if (glyphBounds) {
-        glyphBounds->setTop(-bounds.y());
-        glyphBounds->setBottom(bounds.maxY());
-        glyphBounds->setLeft(std::max(0.0f, -bounds.x()));
-        glyphBounds->setRight(std::max(0.0f, bounds.maxX() - runWidth));
-    }
-    return runWidth;
+    return shaper.runWidthSoFar();
 }
 
 FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     FloatRect bounds;
     SimpleShaper shaper(this, run, nullptr, nullptr, accountForGlyphBounds ? &bounds : nullptr);
     shaper.advance(from);
     float fromX = shaper.runWidthSoFar();
     shaper.advance(to);
     float toX = shaper.runWidthSoFar();
@@ skipping 59 matching lines @@
 {
     return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const
 {
     return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 } // namespace blink