Unify selection rect snapping logic

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 308 matching lines @@
         const float* advances = glyphBuffer.advances(start);
         for (unsigned j = 0; j < count; j++) {
             buffer.pos[j] = x;
             x += SkFloatToScalar(advances[j]);
         }
     }
 
     return adoptRef(builder.build());
 }
 
+static inline FloatRect pixelSnappedSelectionRect(FloatRect rect)
+{
+    // Using roundf() rather than ceilf() for the right edge as a compromise to
+    // ensure correct caret positioning.
+    float roundedX = roundf(rect.x());
+    return FloatRect(roundedX, rect.y(), roundf(rect.maxX() - roundedX), rect.height());
+}
 
 FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     to = (to == -1 ? run.length() : to);
 
     TextRunPaintInfo runInfo(run);
     runInfo.from = from;
     runInfo.to = to;
 
     if (codePath(runInfo) != ComplexPath)
-        return selectionRectForSimpleText(run, point, h, from, to, accountForGlyphBounds);
-
-    return selectionRectForComplexText(run, point, h, from, to);
+        return pixelSnappedSelectionRect(selectionRectForSimpleText(run, point, h, from, to, accountForGlyphBounds));
+    return pixelSnappedSelectionRect(selectionRectForComplexText(run, point, h, from, to));
 }
 
 int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     if (codePath(TextRunPaintInfo(run)) != ComplexPath && !fontDescription().typesettingFeatures())
         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
 
     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
 }
 
@@ skipping 687 matching lines @@
     if (glyphBounds) {
         glyphBounds->setTop(floorf(-bounds.minGlyphBoundingBoxY));
         glyphBounds->setBottom(ceilf(bounds.maxGlyphBoundingBoxY));
         glyphBounds->setLeft(floorf(bounds.firstGlyphOverflow));
         glyphBounds->setRight(ceilf(bounds.lastGlyphOverflow));
     }
 
     return shaper.runWidthSoFar();
 }
 
-FloatRect Font::pixelSnappedSelectionRect(float fromX, float toX, float y, float height)
-{
-    // Using roundf() rather than ceilf() for the right edge as a compromise to
-    // ensure correct caret positioning.
-    float roundedX = roundf(fromX);
-    return FloatRect(roundedX, y, roundf(toX - roundedX), height);
-}
-
 FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
 {
     SimpleShaper::GlyphBounds 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 pixelSnappedSelectionRect(point.x() + fromX, point.x() + toX,
+    return FloatRect(point.x() + fromX,
         accountForGlyphBounds ? bounds.minGlyphBoundingBoxY : point.y(),
+        toX - fromX,
         accountForGlyphBounds ? bounds.maxGlyphBoundingBoxY - bounds.minGlyphBoundingBoxY : h);
 }
 
 int Font::offsetForPositionForSimpleText(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     float delta = x;
 
     SimpleShaper shaper(this, run);
     unsigned offset;
     if (run.rtl()) {
@@ skipping 26 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink