Changeset 169309 in webkit

Timestamp:

May 24, 2014 7:50:42 AM (10 years ago)

Author:

Alan Bujtas

Message:

Subpixel rendering: Non-compositing transforms with subpixel coordinates paint to wrong position.
​https://bugs.webkit.org/show_bug.cgi?id=133184
<rdar://problem/16745606>

Reviewed by Simon Fraser.

Snapping relative negative coordinate values should produce the same position as if they were
positive absolute coordinates.
When a child box gets positioned off of its containers towards top/left, its relative coordinates
become negative. Pixel snapping those negative values should produce the same
final painting position as if the child box was fixed positioned with positive coordinates.
Since halfway values always round away from zero, negative and positive halfway values
produce opposite rounding direction.
This patch ensures that negative halfway values round to the direction as if they were positive.

Source/WebCore:
Test: fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction.html

• platform/LayoutUnit.h:

(WebCore::roundToDevicePixel):

• rendering/RenderLayer.cpp:

(WebCore::RenderLayer::paintLayerByApplyingTransform):

LayoutTests:

• fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction-expected.html: Added.
• fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction-expected.html (added)
• LayoutTests/fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/platform/LayoutUnit.h (modified) (1 diff)
• Source/WebCore/rendering/RenderLayer.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2014-05-24  Zalan Bujtas  <zalan@apple.com>
+
+        Subpixel rendering: Non-compositing transforms with subpixel coordinates paint to wrong position.
+        https://bugs.webkit.org/show_bug.cgi?id=133184
+        <rdar://problem/16745606>
+
+        Reviewed by Simon Fraser.
+
+        Snapping relative negative coordinate values should produce the same position as if they were
+        positive absolute coordinates.
+        When a child box gets positioned off of its containers towards top/left, its relative coordinates
+        become negative. Pixel snapping those negative values should produce the same
+        final painting position as if the child box was fixed positioned with positive coordinates.
+        Since halfway values always round away from zero, negative and positive halfway values
+        produce opposite rounding direction.
+        This patch ensures that negative halfway values round to the direction as if they were positive.  
+
+        * fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction-expected.html: Added.
+        * fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction.html: Added.
+
 2014-05-24  Frédéric Wang  <fred.wang@free.fr>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-05-24  Zalan Bujtas  <zalan@apple.com>
+
+        Subpixel rendering: Non-compositing transforms with subpixel coordinates paint to wrong position.
+        https://bugs.webkit.org/show_bug.cgi?id=133184
+        <rdar://problem/16745606>
+
+        Reviewed by Simon Fraser.
+
+        Snapping relative negative coordinate values should produce the same position as if they were
+        positive absolute coordinates.
+        When a child box gets positioned off of its containers towards top/left, its relative coordinates
+        become negative. Pixel snapping those negative values should produce the same
+        final painting position as if the child box was fixed positioned with positive coordinates.
+        Since halfway values always round away from zero, negative and positive halfway values
+        produce opposite rounding direction.
+        This patch ensures that negative halfway values round to the direction as if they were positive.  
+
+        Test: fast/layers/hidpi-floor-negative-coordinate-values-to-maintain-rounding-direction.html
+
+        * platform/LayoutUnit.h:
+        (WebCore::roundToDevicePixel):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::paintLayerByApplyingTransform):
+
 2014-05-24  Frédéric Wang  <fred.wang@free.fr>
 

trunk/Source/WebCore/platform/LayoutUnit.h

@@ -936 +936 @@
 }
 
-inline float roundToDevicePixel(LayoutUnit value, float pixelSnappingFactor, bool needsDirectionalRounding = false)
-{
-    return roundf(((value.rawValue() - (needsDirectionalRounding ? LayoutUnit::epsilon() / 2.0f : 0)) * pixelSnappingFactor) / kEffectiveFixedPointDenominator) / pixelSnappingFactor;
+inline float roundToDevicePixel(LayoutUnit value, const float pixelSnappingFactor, bool needsDirectionalRounding = false)
+{
+    auto roundInternal = [&] (float valueToRound) { return roundf((valueToRound * pixelSnappingFactor) / kEffectiveFixedPointDenominator) / pixelSnappingFactor; };
+
+    float adjustedValue = value.rawValue() - (needsDirectionalRounding ? LayoutUnit::epsilon() / 2.0f : 0);
+    if (adjustedValue >= 0)
+        return roundInternal(adjustedValue);
+
+    // This adjusts directional rounding on negative halfway values. It produces the same direction for both negative and positive values.
+    // It helps snapping relative negative coordinates to the same position as if they were positive absolute coordinates.
+    float translateOrigin = fabsf(adjustedValue - LayoutUnit::fromPixel(1));
+    return roundInternal(adjustedValue + (translateOrigin * kEffectiveFixedPointDenominator)) - translateOrigin;
 }
 

trunk/Source/WebCore/rendering/RenderLayer.cpp

@@ -4136 +4136 @@
     offsetFromParent.moveBy(translationOffset);
     TransformationMatrix transform(renderableTransform(paintingInfo.paintBehavior));
-    FloatPoint devicePixelFlooredOffsetFromParent = flooredForPainting(offsetFromParent, deviceScaleFactor);
+    FloatPoint devicePixelSnappedOffsetFromParent = roundedForPainting(offsetFromParent, deviceScaleFactor);
     // Translate the graphics context to the snapping position to avoid off-device-pixel positing.
-    transform.translateRight(devicePixelFlooredOffsetFromParent.x(), devicePixelFlooredOffsetFromParent.y());
+    transform.translateRight(devicePixelSnappedOffsetFromParent.x(), devicePixelSnappedOffsetFromParent.y());
     // We handle accumulated subpixels through nested layers here. Since the context gets translated to device pixels,
     // all we need to do is add the delta to the accumulated pixels coming from ancestor layers. With deep nesting of subpixel positioned
     // boxes, this could grow to a relatively large number, but the translateRight() balances it.
-    FloatSize delta = offsetFromParent - devicePixelFlooredOffsetFromParent;
+    FloatSize delta = offsetFromParent - devicePixelSnappedOffsetFromParent;
     LayoutSize adjustedSubPixelAccumulation = paintingInfo.subPixelAccumulation + LayoutSize(delta);
     // Apply the transform.