Use LayoutRect during addFocusRingRects to avoid loss of precision

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1200 matching lines @@
         quad[3] = FloatPoint(x2, y1 + std::max(-adjacentWidth1, 0));
         break;
     }
 
     graphicsContext->drawConvexPolygon(4, quad, antialias);
     graphicsContext->setStrokeStyle(oldStrokeStyle);
 }
 
 void RenderObject::paintFocusRing(PaintInfo& paintInfo, const LayoutPoint& paintOffset, RenderStyle* style)
 {
-    Vector<IntRect> focusRingRects;
+    Vector<LayoutRect> focusRingRects;
     addFocusRingRects(focusRingRects, paintOffset, paintInfo.paintContainer());
     ASSERT(style->outlineStyleIsAuto());
-    paintInfo.context->drawFocusRing(focusRingRects, style->outlineWidth(), style->outlineOffset(), resolveColor(style, CSSPropertyOutlineColor));
+    Vector<IntRect> focusRingIntRects;
+    for (size_t i = 0; i < focusRingRects.size(); ++i)
+        focusRingIntRects.append(pixelSnappedIntRect(focusRingRects[i]));
+    paintInfo.context->drawFocusRing(focusRingIntRects, style->outlineWidth(), style->outlineOffset(), resolveColor(style, CSSPropertyOutlineColor));
 }
 
 void RenderObject::paintOutline(PaintInfo& paintInfo, const LayoutRect& paintRect)
 {
     RenderStyle* styleToUse = style();
     if (!styleToUse->hasOutline())
         return;
 
     LayoutUnit outlineWidth = styleToUse->outlineWidth();
 
@@ skipping 50 matching lines @@
 
     drawLineForBoxSide(graphicsContext, leftOuter, topOuter, leftInner, bottomOuter, BSLeft, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     drawLineForBoxSide(graphicsContext, leftOuter, topOuter, rightOuter, topInner, BSTop, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     drawLineForBoxSide(graphicsContext, rightInner, topOuter, rightOuter, bottomOuter, BSRight, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     drawLineForBoxSide(graphicsContext, leftOuter, bottomInner, rightOuter, bottomOuter, BSBottom, outlineColor, outlineStyle, outlineWidth, outlineWidth);
 
     if (useTransparencyLayer)
         graphicsContext->endLayer();
 }
 
-void RenderObject::addChildFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer) const
+void RenderObject::addChildFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer) const
 {
     for (RenderObject* current = slowFirstChild(); current; current = current->nextSibling()) {
         if (current->isText() || current->isListMarker())
             continue;
 
         if (current->isBox()) {
             RenderBox* box = toRenderBox(current);
             if (box->hasLayer()) {
-                Vector<IntRect> layerFocusRingRects;
+                Vector<LayoutRect> layerFocusRingRects;
                 box->addFocusRingRects(layerFocusRingRects, LayoutPoint(), box);
                 for (size_t i = 0; i < layerFocusRingRects.size(); ++i) {
-                    FloatQuad quadInBox = box->localToContainerQuad(FloatRect(layerFocusRingRects[i]), paintContainer);
-                    FloatRect rect = quadInBox.boundingBox();
-                    // Floor the location instead of using pixelSnappedIntRect to match the !hasLayer() path.
-                    // FIXME: roundedIntSize matches pixelSnappedIntRect in other places of addFocusRingRects
-                    // because we always floor the offset.
-                    // This assumption is fragile and should be replaced by better solution.
-                    rects.append(IntRect(flooredIntPoint(rect.location()), roundedIntSize(rect.size())));
+                    FloatQuad quadInBox = box->localToContainerQuad(FloatQuad(layerFocusRingRects[i]), paintContainer);
+                    LayoutRect rect = LayoutRect(quadInBox.boundingBox());
+                    if (!rect.isEmpty())
+                        rects.append(rect);
                 }
             } else {
-                FloatPoint pos(additionalOffset);
-                pos.move(box->locationOffset());
-                box->addFocusRingRects(rects, flooredIntPoint(pos), paintContainer);
+                box->addFocusRingRects(rects, additionalOffset + box->locationOffset(), paintContainer);
             }
         } else {
             current->addFocusRingRects(rects, additionalOffset, paintContainer);
         }
     }
 }
 
 LayoutPoint RenderObject::positionFromPaintInvalidationContainer(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     ASSERT(containerForPaintInvalidation() == paintInvalidationContainer);
@@ skipping 30 matching lines @@
         return IntRect();
 
     LayoutRect result = rects[0];
     for (size_t i = 1; i < n; ++i)
         result.unite(rects[i]);
     return pixelSnappedIntRect(result);
 }
 
 void RenderObject::absoluteFocusRingQuads(Vector<FloatQuad>& quads)
 {
-    Vector<IntRect> rects;
+    Vector<LayoutRect> rects;
     const RenderLayerModelObject* container = containerForPaintInvalidation();
     addFocusRingRects(rects, LayoutPoint(localToContainerPoint(FloatPoint(), container)), container);
     size_t count = rects.size();
     for (size_t i = 0; i < count; ++i)
         quads.append(container->localToAbsoluteQuad(FloatQuad(rects[i])));
 }
 
 FloatRect RenderObject::absoluteBoundingBoxRectForRange(const Range* range)
 {
     if (!range || !range->startContainer())
@@ skipping 2066 matching lines @@
 {
     if (object1) {
         const blink::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif