Force glyph overflow calculation

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 IntRectOutsets& glyphBounds,
+static inline void updateGlyphOverflowFromBounds(const FloatRectOutsets& 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();
-    glyphOverflow->right = glyphBounds.right();
+    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
 {
     FontCachePurgePreventer purgePreventer;
 
     CodePath codePathToUse = codePath(TextRunPaintInfo(run));
 
     float result;
-    IntRectOutsets glyphBounds;
-    if (codePathToUse == ComplexPath) {
+    FloatRectOutsets glyphBounds;
+    if (codePathToUse == ComplexPath)
         result = floatWidthForComplexText(run, fallbackFonts, &glyphBounds);
-    } else {
-        // The simple path can optimize the case where glyph overflow is not observable.
-        if (codePathToUse != SimpleWithGlyphOverflowPath && (glyphOverflow && !glyphOverflow->computeBounds))
-            glyphOverflow = 0;
+    else
         result = floatWidthForSimpleText(run, fallbackFonts, glyphOverflow ? &glyphBounds : 0);
-    }
 
     if (glyphOverflow)
         updateGlyphOverflowFromBounds(glyphBounds, fontMetrics(), glyphOverflow);
     return result;
 }
 
 PassTextBlobPtr Font::buildTextBlob(const GlyphBuffer& glyphBuffer) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
@@ skipping 434 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, IntRectOutsets* glyphBounds) const
+float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRectOutsets* 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()) {
         ASSERT(glyphBounds);
         *glyphBounds = cacheEntry->glyphBounds;
         return cacheEntry->width;
     }
 
     FloatRect bounds;
     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())));
+    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();
     if (cacheEntry && (!fallbackFonts || fallbackFonts->isEmpty())) {
         cacheEntry->glyphBounds = *glyphBounds;
         cacheEntry->width = result;
     }
 
     return result;
 }
 
@@ skipping 45 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, IntRectOutsets* glyphBounds) const
+float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRectOutsets* glyphBounds) const
 {
     FloatRect bounds;
     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)));
+        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;
 }
 
 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();
@@ skipping 61 matching lines @@
 {
     return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const
 {
     return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 } // namespace blink