Changeset 109835 in webkit

Timestamp:

Mar 5, 2012 6:42:55 PM (12 years ago)

Author:

leviw@chromium.org

Message:

Update usage of LayoutUnits in RenderBox
​https://bugs.webkit.org/show_bug.cgi?id=80039

Reviewed by Julien Chaffraix.

Updating the usage of integers versus LayoutUnits in RenderBox to mirror the
subpixellayout branch. This reverts absoluteRects, intrinsicSize, and focusRingRects
methods to use integers, and flipForWritingMode functions to LayoutUnits.

No new tests. No change in behavior.

• platform/graphics/FractionalLayoutRect.h:

(WebCore::FractionalLayoutRect::pixelSnappedX): Convenience methods that only calculate
the needed values. This requires less computation than pixelSnappedIntRect(r).x().
(WebCore::FractionalLayoutRect::pixelSnappedY): Ditto.
(WebCore::FractionalLayoutRect::pixelSnappedWidth): Ditto.
(WebCore::FractionalLayoutRect::pixelSnappedHeight): Ditto.
(WebCore::FractionalLayoutRect::pixelSnappedMaxX): Ditto.
(WebCore::FractionalLayoutRect::pixelSnappedMaxY): Ditto.
(FractionalLayoutRect):

• platform/graphics/IntRect.h:

(IntRect):
(WebCore::IntRect::pixelSnappedX): Stub methods to allow us to use IntRects like we do
FractionalLayoutRects.
(WebCore::IntRect::pixelSnappedY): Ditto.
(WebCore::IntRect::pixelSnappedMaxX): Ditto.
(WebCore::IntRect::pixelSnappedMaxY): Ditto.
(WebCore::IntRect::pixelSnappedWidth): Ditto.
(WebCore::IntRect::pixelSnappedHeight): Ditto.

• rendering/LayoutTypes.h:

(WebCore::pixelSnappedIntRect): Convenience method for building a pixelSnappedIntRect from
a LayoutPoint and LayoutSize without constructing an intermediate LayoutRect.
(WebCore):
(WebCore::snapSizeToPixel): Stub method for snapping a LayoutUnit representing a size to
its pixel value using its location.

• rendering/RenderBox.cpp:

(WebCore::RenderBox::pixelSnappedClientWidth): Changing to actually call snapSizeToPixel.
(WebCore::RenderBox::pixelSnappedClientHeight): Ditto.
(WebCore::RenderBox::absoluteRects): Switching to return IntRects that represent the actual
rendered location on screen.
(WebCore::RenderBox::addFocusRingRects): Ditto.
(WebCore::RenderBox::paintFillLayer): One-liner switching an IntSize() to LayoutSize() to
avoid unnecessary conversion.
(WebCore::RenderBox::shrinkLogicalWidthToAvoidFloats): Preparing for the conversion by
replacing 0 with zeroLayoutUnit.
(WebCore::RenderBox::positionLineBox): Preparing for conversion by replacing lroundf
with roundedLayoutUnit.
(WebCore::RenderBox::flipForWritingMode): Switching to use LayoutUnits.

• rendering/RenderBox.h:

(RenderBox):
(WebCore::RenderBox::pixelSnappedBorderBoxRect): Convenience method.
(WebCore::RenderBox::borderBoundingBox): Converting to a pixelSnappedIntRect.
(WebCore::RenderBox::intrinsicSize): Intrinsic sizes should always be integers.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/FractionalLayoutRect.h (modified) (1 diff)
• platform/graphics/IntRect.h (modified) (1 diff)
• rendering/LayoutTypes.h (modified) (2 diffs)
• rendering/RenderBox.cpp (modified) (10 diffs)
• rendering/RenderBox.h (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-03-05  Levi Weintraub  <leviw@chromium.org>
+
+        Update usage of LayoutUnits in RenderBox
+        https://bugs.webkit.org/show_bug.cgi?id=80039
+
+        Reviewed by Julien Chaffraix.
+
+        Updating the usage of integers versus LayoutUnits in RenderBox to mirror the
+        subpixellayout branch. This reverts absoluteRects, intrinsicSize, and focusRingRects
+        methods to use integers, and flipForWritingMode functions to LayoutUnits.
+
+        No new tests. No change in behavior.
+
+        * platform/graphics/FractionalLayoutRect.h:
+        (WebCore::FractionalLayoutRect::pixelSnappedX): Convenience methods that only calculate
+        the needed values. This requires less computation than pixelSnappedIntRect(r).x().
+        (WebCore::FractionalLayoutRect::pixelSnappedY): Ditto.
+        (WebCore::FractionalLayoutRect::pixelSnappedWidth): Ditto.
+        (WebCore::FractionalLayoutRect::pixelSnappedHeight): Ditto.
+        (WebCore::FractionalLayoutRect::pixelSnappedMaxX): Ditto.
+        (WebCore::FractionalLayoutRect::pixelSnappedMaxY): Ditto.
+        (FractionalLayoutRect):
+        * platform/graphics/IntRect.h:
+        (IntRect):
+        (WebCore::IntRect::pixelSnappedX): Stub methods to allow us to use IntRects like we do
+        FractionalLayoutRects.
+        (WebCore::IntRect::pixelSnappedY): Ditto.
+        (WebCore::IntRect::pixelSnappedMaxX): Ditto.
+        (WebCore::IntRect::pixelSnappedMaxY): Ditto.
+        (WebCore::IntRect::pixelSnappedWidth): Ditto.
+        (WebCore::IntRect::pixelSnappedHeight): Ditto.
+        * rendering/LayoutTypes.h:
+        (WebCore::pixelSnappedIntRect): Convenience method for building a pixelSnappedIntRect from
+        a LayoutPoint and LayoutSize without constructing an intermediate LayoutRect.
+        (WebCore):
+        (WebCore::snapSizeToPixel): Stub method for snapping a LayoutUnit representing a size to
+        its pixel value using its location.
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::pixelSnappedClientWidth): Changing to actually call snapSizeToPixel.
+        (WebCore::RenderBox::pixelSnappedClientHeight): Ditto.
+        (WebCore::RenderBox::absoluteRects): Switching to return IntRects that represent the actual
+        rendered location on screen.
+        (WebCore::RenderBox::addFocusRingRects): Ditto.
+        (WebCore::RenderBox::paintFillLayer): One-liner switching an IntSize() to LayoutSize() to
+        avoid unnecessary conversion.
+        (WebCore::RenderBox::shrinkLogicalWidthToAvoidFloats): Preparing for the conversion by
+        replacing 0 with zeroLayoutUnit.
+        (WebCore::RenderBox::positionLineBox): Preparing for conversion by replacing lroundf
+        with roundedLayoutUnit.
+        (WebCore::RenderBox::flipForWritingMode): Switching to use LayoutUnits.
+        * rendering/RenderBox.h:
+        (RenderBox):
+        (WebCore::RenderBox::pixelSnappedBorderBoxRect): Convenience method.
+        (WebCore::RenderBox::borderBoundingBox): Converting to a pixelSnappedIntRect.
+        (WebCore::RenderBox::intrinsicSize): Intrinsic sizes should always be integers.
+
 2012-03-05  Adam Barth  <abarth@webkit.org>
 

trunk/Source/WebCore/platform/graphics/FractionalLayoutRect.h

@@ -65 +65 @@
     FractionalLayoutUnit width() const { return m_size.width(); }
     FractionalLayoutUnit height() const { return m_size.height(); }
+
+    int pixelSnappedX() const { return x().round(); }
+    int pixelSnappedY() const { return y().round(); }
+    int pixelSnappedWidth() const { return snapSizeToPixel(width(), x()); }
+    int pixelSnappedHeight() const { return snapSizeToPixel(height(), y()); }
+    int pixelSnappedMaxX() const { return pixelSnappedX() + pixelSnappedWidth(); }
+    int pixelSnappedMaxY() const { return pixelSnappedY() + pixelSnappedHeight(); }
 
     void setX(FractionalLayoutUnit x) { m_location.setX(x); }

trunk/Source/WebCore/platform/graphics/IntRect.h

@@ -104 +104 @@
     int height() const { return m_size.height(); }
 
+    // FIXME: These methods are here only to ease the transition to sub-pixel layout. They should
+    // be removed when we close http://webkit.org/b/60318
+    int pixelSnappedX() const { return m_location.x(); }
+    int pixelSnappedY() const { return m_location.y(); }
+    int pixelSnappedMaxX() const { return x() + width(); }
+    int pixelSnappedMaxY() const { return y() + height(); }
+    int pixelSnappedWidth() const { return m_size.width(); }
+    int pixelSnappedHeight() const { return m_size.height(); }
+
     void setX(int x) { m_location.setX(x); }
     void setY(int y) { m_location.setY(y); }

trunk/Source/WebCore/rendering/LayoutTypes.h

@@ -39 +39 @@
 #include "FloatRect.h"
 #include "IntRect.h"
+#include <wtf/UnusedParam.h>
 
 namespace WebCore {
@@ -64 +65 @@
 }
 
+inline IntRect pixelSnappedIntRect(const LayoutPoint& location, const LayoutSize& size)
+{
+    return IntRect(location, size);
+}
+
 inline IntRect pixelSnappedIntRectFromEdges(LayoutUnit left, LayoutUnit top, LayoutUnit right, LayoutUnit bottom)
 {
     return IntRect(left, top, right - left, bottom - top);
+}
+
+inline int snapSizeToPixel(LayoutUnit size, LayoutUnit location) 
+{
+    UNUSED_PARAM(location);
+    return size;
 }
 

trunk/Source/WebCore/rendering/RenderBox.cpp

@@ -481 +481 @@
 int RenderBox::pixelSnappedClientWidth() const
 {
-    return clientWidth();
+    return snapSizeToPixel(clientWidth(), clientLeft());
 }
 
 int RenderBox::pixelSnappedClientHeight() const
 {
-    return clientHeight();
+    return snapSizeToPixel(clientHeight(), clientTop());
 }
 
@@ -533 +533 @@
 void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
-    rects.append(LayoutRect(accumulatedOffset, size()));
+    rects.append(pixelSnappedIntRect(accumulatedOffset, size()));
 }
 
@@ -582 +582 @@
 }
 
-void RenderBox::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset)
+void RenderBox::addFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset)
 {
     if (!size().isEmpty())
-        rects.append(LayoutRect(additionalOffset, size()));
+        rects.append(pixelSnappedIntRect(additionalOffset, size()));
 }
 
@@ -1079 +1079 @@
     BackgroundBleedAvoidance bleedAvoidance, CompositeOperator op, RenderObject* backgroundObject)
 {
-    paintFillLayerExtended(paintInfo, c, fillLayer, rect, bleedAvoidance, 0, IntSize(), op, backgroundObject);
+    paintFillLayerExtended(paintInfo, c, fillLayer, rect, bleedAvoidance, 0, LayoutSize(), op, backgroundObject);
 }
 
@@ -1277 +1277 @@
     LayoutUnit adjustedPageOffsetForContainingBlock = offsetFromLogicalTopOfFirstPage - logicalTop();
     if (region) {
-        LayoutUnit offsetFromLogicalTopOfRegion = region ? region->offsetFromLogicalTopOfFirstPage() - offsetFromLogicalTopOfFirstPage : 0;
+        LayoutUnit offsetFromLogicalTopOfRegion = region ? region->offsetFromLogicalTopOfFirstPage() - offsetFromLogicalTopOfFirstPage : zeroLayoutUnit;
         logicalTopPosition = max(logicalTopPosition, logicalTopPosition + offsetFromLogicalTopOfRegion);
         containingBlockRegion = cb->clampToStartAndEndRegions(region);
@@ -1485 +1485 @@
             // the inlines.
             RootInlineBox* root = box->root();
-            root->block()->setStaticInlinePositionForChild(this, root->lineTopWithLeading(), lroundf(box->logicalLeft()));
+            root->block()->setStaticInlinePositionForChild(this, root->lineTopWithLeading(), roundedLayoutUnit(box->logicalLeft()));
             if (style()->hasStaticInlinePosition(box->isHorizontal()))
                 setChildNeedsLayout(true, false); // Just go ahead and mark the positioned object as needing layout, so it will update its position properly.
@@ -3896 +3896 @@
 }
 
-void RenderBox::flipForWritingMode(IntRect& rect) const
+void RenderBox::flipForWritingMode(LayoutRect& rect) const
 {
     if (!style()->isFlippedBlocksWritingMode())
@@ -3907 +3907 @@
 }
 
-int RenderBox::flipForWritingMode(int position) const
+LayoutUnit RenderBox::flipForWritingMode(LayoutUnit position) const
 {
     if (!style()->isFlippedBlocksWritingMode())
@@ -3914 +3914 @@
 }
 
-IntPoint RenderBox::flipForWritingMode(const IntPoint& position) const
+LayoutPoint RenderBox::flipForWritingMode(const LayoutPoint& position) const
 {
     if (!style()->isFlippedBlocksWritingMode())
         return position;
-    return isHorizontalWritingMode() ? IntPoint(position.x(), height() - position.y()) : IntPoint(width() - position.x(), position.y());
+    return isHorizontalWritingMode() ? LayoutPoint(position.x(), height() - position.y()) : LayoutPoint(width() - position.x(), position.y());
 }
 
@@ -3928 +3928 @@
 }
 
-IntSize RenderBox::flipForWritingMode(const IntSize& offset) const
+LayoutSize RenderBox::flipForWritingMode(const LayoutSize& offset) const
 {
     if (!style()->isFlippedBlocksWritingMode())
         return offset;
-    return isHorizontalWritingMode() ? IntSize(offset.width(), height() - offset.height()) : IntSize(width() - offset.width(), offset.height());
+    return isHorizontalWritingMode() ? LayoutSize(offset.width(), height() - offset.height()) : LayoutSize(width() - offset.width(), offset.height());
 }
 

trunk/Source/WebCore/rendering/RenderBox.h

@@ -128 +128 @@
     void setFrameRect(const LayoutRect& rect) { m_frameRect = rect; }
 
+    // FIXME: We shouldn't be returning this as a LayoutRect, since it loses its position and won't properly pixel snap.
     LayoutRect borderBoxRect() const { return LayoutRect(LayoutPoint(), size()); }
-    virtual LayoutRect borderBoundingBox() const { return borderBoxRect(); } 
+    IntRect pixelSnappedBorderBoxRect() const { return IntRect(IntPoint(), IntSize(m_frameRect.pixelSnappedWidth(), m_frameRect.pixelSnappedHeight())); }
+    virtual IntRect borderBoundingBox() const { return pixelSnappedBorderBoxRect(); }
 
     // The content area of the box (excludes padding and border).
@@ -140 +142 @@
     // Bounds of the outline box in absolute coords. Respects transforms
     virtual LayoutRect outlineBoundsForRepaint(RenderBoxModelObject* /*repaintContainer*/, LayoutPoint* cachedOffsetToRepaintContainer) const;
-    virtual void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint&);
+    virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint&);
 
     // Use this with caution! No type checking is done!
@@ -247 +249 @@
     virtual LayoutUnit collapsedMarginAfter() const { return marginAfter(); }
 
-    virtual void absoluteRects(Vector<LayoutRect>&, const LayoutPoint& accumulatedOffset) const;
+    virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
     
@@ -322 +324 @@
     }
 
-    virtual LayoutSize intrinsicSize() const { return LayoutSize(); }
+    virtual IntSize intrinsicSize() const { return IntSize(); }
     LayoutUnit intrinsicLogicalWidth() const { return style()->isHorizontalWritingMode() ? intrinsicSize().width() : intrinsicSize().height(); }
     LayoutUnit intrinsicLogicalHeight() const { return style()->isHorizontalWritingMode() ? intrinsicSize().height() : intrinsicSize().width(); }
@@ -425 +427 @@
 
     LayoutPoint flipForWritingModeForChild(const RenderBox* child, const LayoutPoint&) const;
-    int flipForWritingMode(int position) const; // The offset is in the block direction (y for horizontal writing modes, x for vertical writing modes).
-    IntPoint flipForWritingMode(const IntPoint&) const;
+    LayoutUnit flipForWritingMode(LayoutUnit position) const; // The offset is in the block direction (y for horizontal writing modes, x for vertical writing modes).
+    LayoutPoint flipForWritingMode(const LayoutPoint&) const;
     LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
-    IntSize flipForWritingMode(const IntSize&) const;
-    void flipForWritingMode(IntRect&) const;
+    LayoutSize flipForWritingMode(const LayoutSize&) const;
+    void flipForWritingMode(LayoutRect&) const;
     FloatPoint flipForWritingMode(const FloatPoint&) const;
     void flipForWritingMode(FloatRect&) const;