Store glyph bounds in WordMeasurement to avoid slow path width calc

Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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 20 matching lines @@
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutTextCombine.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/TextRunConstructor.h"
 #include "core/layout/line/AbstractInlineTextBox.h"
 #include "core/layout/line/EllipsisBox.h"
+#include "core/layout/line/GlyphOverflow.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "platform/fonts/Character.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextBreakIterator.h"
 #include "platform/text/TextRunIterator.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringBuilder.h"
@@ skipping 649 matching lines @@
         left = std::max(left, leftEdge);
         left = std::min(left, rootRight - caretWidth());
     } else {
         left = std::min(left, rightEdge - caretWidthRightOfOffset);
         left = std::max(left, rootLeft);
     }
 
     return LayoutRect(style()->isHorizontalWritingMode() ? IntRect(left, top, caretWidth(), height) : IntRect(top, left, height, caretWidth()));
 }
 
-ALWAYS_INLINE float LayoutText::widthFromCache(const Font& f, int start, int len, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+ALWAYS_INLINE float LayoutText::widthFromFont(const Font& f, int start, int len, float leadWidth, float textWidthSoFar, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBoundsAccumulation) const
 {
     if (style()->hasTextCombine() && isCombineText()) {
         const LayoutTextCombine* combineText = toLayoutTextCombine(this);
         if (combineText->isCombined())
             return combineText->combinedTextWidth(f);
     }
 
     TextRun run = constructTextRun(const_cast<LayoutText*>(this), f, this, start, len, styleRef(), textDirection);
     run.setCharactersLength(textLength() - start);
     ASSERT(run.charactersLength() >= run.length());
     run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
     run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
-    run.setXPos(xPos);
-    return f.width(run, fallbackFonts, glyphOverflow);
+    run.setXPos(leadWidth + textWidthSoFar);
+
+    FloatRect newGlyphBounds;
+    float result = f.width(run, fallbackFonts, glyphBoundsAccumulation ? &newGlyphBounds : nullptr);
+    if (glyphBoundsAccumulation) {
+        newGlyphBounds.move(textWidthSoFar, 0);
+        glyphBoundsAccumulation->unite(newGlyphBounds);
+    }
+    return result;
 }
 
 void LayoutText::trimmedPrefWidths(LayoutUnit leadWidthLayoutUnit,
     LayoutUnit& firstLineMinWidth, bool& hasBreakableStart,
     LayoutUnit& lastLineMinWidth, bool& hasBreakableEnd,
     bool& hasBreakableChar, bool& hasBreak,
     LayoutUnit& firstLineMaxWidth, LayoutUnit& lastLineMaxWidth,
     LayoutUnit& minWidth, LayoutUnit& maxWidth, bool& stripFrontSpaces,
     TextDirection direction)
 {
@@ skipping 59 matching lines @@
         const Font& f = style()->font(); // FIXME: This ignores first-line.
         bool firstLine = true;
         firstLineMaxWidth = floatMaxWidth;
         lastLineMaxWidth = floatMaxWidth;
         for (int i = 0; i < len; i++) {
             int linelen = 0;
             while (i + linelen < len && text[i + linelen] != newlineCharacter)
                 linelen++;
 
             if (linelen) {
-                lastLineMaxWidth = widthFromCache(f, i, linelen, leadWidth + lastLineMaxWidth, direction, 0, 0);
+                lastLineMaxWidth = widthFromFont(f, i, linelen, leadWidth, lastLineMaxWidth.toFloat(), direction, nullptr, nullptr);
                 if (firstLine) {
                     firstLine = false;
                     leadWidth = 0.f;
                     firstLineMaxWidth = lastLineMaxWidth;
                 }
                 i += linelen;
             } else if (firstLine) {
                 firstLineMaxWidth = LayoutUnit();
                 firstLine = false;
                 leadWidth = 0.f;
@@ skipping 23 matching lines @@
 {
     if (preferredLogicalWidthsDirty())
         const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0);
 
     return m_maxWidth;
 }
 
 void LayoutText::computePreferredLogicalWidths(float leadWidth)
 {
     HashSet<const SimpleFontData*> fallbackFonts;
-    GlyphOverflow glyphOverflow;
-    computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphOverflow);
-
-    // We shouldn't change our mind once we "know".
-    ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts || (fallbackFonts.isEmpty() && glyphOverflow.isZero()));
-    m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts.isEmpty() && glyphOverflow.isZero();

[Xianzhu, 2015/06/11 18:22:48]

This is moved into the long form computePreferredLogicalWidth() to avoid
duplicated code.

+    FloatRect glyphBounds;
+    computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphBounds);
 }
 
 static inline float hyphenWidth(LayoutText* layoutObject, const Font& font, TextDirection direction)
 {
     const ComputedStyle& style = layoutObject->styleRef();
     return font.width(constructTextRun(layoutObject, font, style.hyphenString().string(), style, direction));
 }
 
-void LayoutText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
+void LayoutText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, FloatRect& glyphBounds)
 {
     ASSERT(m_hasTab || preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts);
 
     m_minWidth = 0;
     m_maxWidth = 0;
     m_firstLineMinWidth = 0;
     m_lastLineLineMinWidth = 0;
 
     if (isBR())
         return;
@@ skipping 14 matching lines @@
     LazyLineBreakIterator breakIterator(m_text, styleToUse.locale());
     bool needsWordSpacing = false;
     bool ignoringSpaces = false;
     bool isSpace = false;
     bool firstWord = true;
     bool firstLine = true;
     int nextBreakable = -1;
     int lastWordBoundary = 0;
     float cachedWordTrailingSpaceWidth[2] = { 0, 0 }; // LTR, RTL
 
-    int firstGlyphLeftOverflow = -1;
-
     bool breakAll = (styleToUse.wordBreak() == BreakAllWordBreak || styleToUse.wordBreak() == BreakWordBreak) && styleToUse.autoWrap();
     bool keepAll = styleToUse.wordBreak() == KeepAllWordBreak && styleToUse.autoWrap();
 
     BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
     BidiCharacterRun* run;
     TextDirection textDirection = styleToUse.direction();
     if (is8Bit() || isOverride(styleToUse.unicodeBidi())) {
         run = 0;
     } else {
         TextRun textRun(text());
@@ skipping 57 matching lines @@
         if (ignoringSpaces && !isSpace)
             ignoringSpaces = false;
 
         // Ignore spaces and soft hyphens
         if (ignoringSpaces) {
             ASSERT(lastWordBoundary == i);
             lastWordBoundary++;
             continue;
         }
         if (c == softHyphenCharacter) {
-            currMaxWidth += widthFromCache(f, lastWordBoundary, i - lastWordBoundary, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
-            if (firstGlyphLeftOverflow < 0)
-                firstGlyphLeftOverflow = glyphOverflow.left;
+            currMaxWidth += widthFromFont(f, lastWordBoundary, i - lastWordBoundary, leadWidth, currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
             lastWordBoundary = i + 1;
             continue;
         }
 
         bool hasBreak = breakIterator.isBreakable(i, nextBreakable, breakAll ? LineBreakType::BreakAll : keepAll ? LineBreakType::KeepAll : LineBreakType::Normal);
         bool betweenWords = true;
         int j = i;
         while (c != newlineCharacter && c != spaceCharacter && c != tabulationCharacter && (c != softHyphenCharacter)) {
             j++;
             if (j == len)
@@ skipping 19 matching lines @@
             float wordTrailingSpaceWidth = 0;
             if (isSpace && (f.fontDescription().typesettingFeatures() & Kerning)) {
                 ASSERT(textDirection >=0 && textDirection <= 1);
                 if (!cachedWordTrailingSpaceWidth[textDirection])
                     cachedWordTrailingSpaceWidth[textDirection] = f.width(constructTextRun(this, f, &spaceCharacter, 1, styleToUse, textDirection)) + wordSpacing;
                 wordTrailingSpaceWidth = cachedWordTrailingSpaceWidth[textDirection];
             }
 
             float w;
             if (wordTrailingSpaceWidth && isSpace) {
-                w = widthFromCache(f, i, wordLen + 1, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow) - wordTrailingSpaceWidth;
+                w = widthFromFont(f, i, wordLen + 1, leadWidth, currMaxWidth, textDirection, &fallbackFonts, &glyphBounds) - wordTrailingSpaceWidth;
             } else {
-                w = widthFromCache(f, i, wordLen, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
+                w = widthFromFont(f, i, wordLen, leadWidth, currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
                 if (c == softHyphenCharacter)
                     currMinWidth += hyphenWidth(this, f, textDirection);
             }
 
-            if (firstGlyphLeftOverflow < 0)
-                firstGlyphLeftOverflow = glyphOverflow.left;
             currMinWidth += w;
             if (betweenWords) {
                 if (lastWordBoundary == i)
                     currMaxWidth += w;
                 else
-                    currMaxWidth += widthFromCache(f, lastWordBoundary, j - lastWordBoundary, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
+                    currMaxWidth += widthFromFont(f, lastWordBoundary, j - lastWordBoundary, leadWidth, currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
                 lastWordBoundary = j;
             }
 
             bool isCollapsibleWhiteSpace = (j < len) && styleToUse.isCollapsibleWhiteSpace(c);
             if (j < len && styleToUse.autoWrap())
                 m_hasBreakableChar = true;
 
             // Add in wordSpacing to our currMaxWidth, but not if this is the last word on a line or the
             // last word in the run.
             if (wordSpacing && (isSpace || isCollapsibleWhiteSpace) && !containsOnlyWhitespace(j, len-j))
@@ skipping 38 matching lines @@
                 currMaxWidth = 0;
             } else {
                 TextRun run = constructTextRun(this, f, this, i, 1, styleToUse, textDirection);
                 run.setCharactersLength(len - i);
                 run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
                 ASSERT(run.charactersLength() >= run.length());
                 run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
                 run.setXPos(leadWidth + currMaxWidth);
 
                 currMaxWidth += f.width(run);
-                glyphOverflow.right = 0;
                 needsWordSpacing = isSpace && !previousCharacterIsSpace && i == len - 1;
             }
             ASSERT(lastWordBoundary == i);
             lastWordBoundary++;
         }
     }
     if (run)
         bidiResolver.runs().deleteRuns();
 
-    if (firstGlyphLeftOverflow > 0)
-        glyphOverflow.left = firstGlyphLeftOverflow;
-
     if ((needsWordSpacing && len > 1) || (ignoringSpaces && !firstWord))
         currMaxWidth += wordSpacing;
 
     m_minWidth = std::max(currMinWidth, m_minWidth);
     m_maxWidth = std::max(currMaxWidth, m_maxWidth);
 
     if (!styleToUse.autoWrap())
         m_minWidth = m_maxWidth;
 
     if (styleToUse.whiteSpace() == PRE) {
         if (firstLine)
             m_firstLineMinWidth = m_maxWidth;
         m_lastLineLineMinWidth = currMaxWidth;
     }
 
+    if (styleToUse.lineBoxContain() & LineBoxContainGlyphs) {
+        // We shouldn't change our mind once we "know".
+        ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts);
+    } else {
+        GlyphOverflow glyphOverflow;
+        glyphOverflow.setFromBounds(glyphBounds, f.fontMetrics().floatAscent(), f.fontMetrics().floatDescent(), m_maxWidth);
+        // We shouldn't change our mind once we "know".
+        ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts || (fallbackFonts.isEmpty() && glyphOverflow.isZero()));
+        m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts.isEmpty() && glyphOverflow.isZero();
+    }
+
     clearPreferredLogicalWidthsDirty();
 }
 
 bool LayoutText::isAllCollapsibleWhitespace() const
 {
     unsigned length = textLength();
     if (is8Bit()) {
         for (unsigned i = 0; i < length; ++i) {
             if (!style()->isCollapsibleWhiteSpace(characters8()[i]))
                 return false;
@@ skipping 324 matching lines @@
             m_lastTextBox = s->prevTextBox();
         else
             s->nextTextBox()->setPreviousTextBox(s->prevTextBox());
         s->destroy();
         return;
     }
 
     m_containsReversedText |= !s->isLeftToRightDirection();
 }
 
-float LayoutText::width(unsigned from, unsigned len, LayoutUnit xPos, TextDirection textDirection, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float LayoutText::width(unsigned from, unsigned len, LayoutUnit xPos, TextDirection textDirection, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBounds) const
 {
     if (from >= textLength())
         return 0;
 
     if (from + len > textLength())
         len = textLength() - from;
 
-    return width(from, len, style(firstLine)->font(), xPos, textDirection, fallbackFonts, glyphOverflow);
+    return width(from, len, style(firstLine)->font(), xPos, textDirection, fallbackFonts, glyphBounds);
 }
 
-float LayoutText::width(unsigned from, unsigned len, const Font& f, LayoutUnit xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float LayoutText::width(unsigned from, unsigned len, const Font& f, LayoutUnit xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBounds) const
 {
     ASSERT(from + len <= textLength());
     if (!textLength())
         return 0;
 
     float w;
     if (&f == &style()->font()) {
-        if (!style()->preserveNewline() && !from && len == textLength() && (!glyphOverflow || !glyphOverflow->computeBounds)) {
+        if (!style()->preserveNewline() && !from && len == textLength()) {
             if (fallbackFonts) {
-                ASSERT(glyphOverflow);
-                if (preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts) {
-                    const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphOverflow);
-                    // We shouldn't change our mind once we "know".
-                    ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts
-                        || (fallbackFonts->isEmpty() && glyphOverflow->isZero()));
-                    m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts->isEmpty() && glyphOverflow->isZero();
-                }
+                ASSERT(glyphBounds);
+                if (preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts)
+                    const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphBounds);
+                else
+                    *glyphBounds = FloatRect(0, -f.fontMetrics().floatAscent(), m_maxWidth, f.fontMetrics().floatHeight());
                 w = m_maxWidth;
             } else {
                 w = maxLogicalWidth();
             }
         } else {
-            w = widthFromCache(f, from, len, xPos.toFloat(), textDirection, fallbackFonts, glyphOverflow);
+            w = widthFromFont(f, from, len, xPos.toFloat(), 0, textDirection, fallbackFonts, glyphBounds);
         }
     } else {
         TextRun run = constructTextRun(const_cast<LayoutText*>(this), f, this, from, len, styleRef(), textDirection);
         run.setCharactersLength(textLength() - from);
         ASSERT(run.charactersLength() >= run.length());
 
         run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
         run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
         run.setXPos(xPos.toFloat());
-        w = f.width(run, fallbackFonts, glyphOverflow);
+        w = f.width(run, fallbackFonts, glyphBounds);
     }
 
     return w;
 }
 
 IntRect LayoutText::linesBoundingBox() const
 {
     IntRect result;
 
     ASSERT(!firstTextBox() == !lastTextBox()); // Either both are null or both exist.
@@ skipping 340 matching lines @@
 }
 
 void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink