Using FloatRect in SimpleShaper and remove GlyphBounds

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 90 matching lines @@
 {
     if (codePath(runInfo) == ComplexPath) {
         HarfBuzzShaper shaper(this, runInfo.run, (forTextEmphasis == ForTextEmphasis)
             ? HarfBuzzShaper::ForTextEmphasis : HarfBuzzShaper::NotForTextEmphasis);
         shaper.setDrawRange(runInfo.from, runInfo.to);
         shaper.shape(&glyphBuffer);
         return shaper.totalWidth();
     }
 
     SimpleShaper shaper(this, runInfo.run, nullptr /* fallbackFonts */,
-        nullptr /* GlyphBounds */, forTextEmphasis);
+        nullptr, forTextEmphasis);
     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());
         glyphBuffer.reverseForSimpleRTL(width, shaper.runWidthSoFar());
     }
 
@@ skipping 657 matching lines @@
     if ((textMode & TextModeStroke) && gc->hasStroke()) {
         SkPaint paint = gc->strokePaint();
         if (textMode & TextModeFill)
             paint.setLooper(0);
         gc->drawTextBlob(blob, origin, paint);
     }
 }
 
 float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, IntRectOutsets* glyphBounds) const
 {
-    HarfBuzzShaper shaper(this, run, HarfBuzzShaper::NotForTextEmphasis, fallbackFonts);
+    FloatRect bounds;
+    HarfBuzzShaper shaper(this, run, HarfBuzzShaper::NotForTextEmphasis, fallbackFonts, glyphBounds ? &bounds : 0);
     if (!shaper.shape())
         return 0;
 
-    glyphBounds->setTop(ceilf(-shaper.glyphBoundingBox().y()));
-    glyphBounds->setBottom(ceilf(shaper.glyphBoundingBox().maxY()));
-    glyphBounds->setLeft(std::max<int>(0, ceilf(-shaper.glyphBoundingBox().x())));
-    glyphBounds->setRight(std::max<int>(0, ceilf(shaper.glyphBoundingBox().maxX() - shaper.totalWidth())));
+    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())));
 
     return shaper.totalWidth();
 }
 
 // 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())
@@ skipping 78 matching lines @@
             markBuffer.add(markGlyphData.glyph, markFontData, FloatPoint(- offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph),
                 glyphBuffer.xOffsetAt(i) - offsetToMiddleOfGlyph(markFontData, markGlyphData.glyph, Vertical)));
         }
     }
 
     drawGlyphBuffer(context, runInfo, markBuffer, point);
 }
 
 float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, IntRectOutsets* glyphBounds) const
 {
-    SimpleShaper::GlyphBounds bounds;
+    FloatRect bounds;
     SimpleShaper shaper(this, run, fallbackFonts, glyphBounds ? &bounds : 0);
     shaper.advance(run.length());
+    float runWidth = shaper.runWidthSoFar();
 
     if (glyphBounds) {
-        glyphBounds->setTop(ceilf(-bounds.minGlyphBoundingBoxY));
-        glyphBounds->setBottom(ceilf(bounds.maxGlyphBoundingBoxY));
-        glyphBounds->setLeft(ceilf(bounds.firstGlyphOverflow));
-        glyphBounds->setRight(ceilf(bounds.lastGlyphOverflow));
+        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)));
     }
-
-    return shaper.runWidthSoFar();
+    return runWidth;
 }
 
 FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
-    SimpleShaper::GlyphBounds bounds;
+    FloatRect bounds;
     SimpleShaper shaper(this, run, 0, accountForGlyphBounds ? &bounds : 0);
     shaper.advance(from);
     float fromX = shaper.runWidthSoFar();
     shaper.advance(to);
     float toX = shaper.runWidthSoFar();
 
     if (run.rtl()) {
         shaper.advance(run.length());
         float totalWidth = shaper.runWidthSoFar();
         float beforeWidth = fromX;
         float afterWidth = toX;
         fromX = totalWidth - afterWidth;
         toX = totalWidth - beforeWidth;
     }
 
     return FloatRect(point.x() + fromX,
-        accountForGlyphBounds ? bounds.minGlyphBoundingBoxY : point.y(),
+        accountForGlyphBounds ? bounds.y(): point.y(),
         toX - fromX,
-        accountForGlyphBounds ? bounds.maxGlyphBoundingBoxY - bounds.minGlyphBoundingBoxY : h);
+        accountForGlyphBounds ? bounds.maxY()- bounds.y(): h);
 }
 
 int Font::offsetForPositionForSimpleText(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     float delta = x;
 
     SimpleShaper shaper(this, run);
     unsigned offset;
     if (run.rtl()) {
         delta -= floatWidthForSimpleText(run);
@@ skipping 25 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink