Resolve the percentage values of inset properties against proper box.
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 3 May 2019 13:19:57 +0000 (13:19 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 3 May 2019 13:19:57 +0000 (13:19 +0000)
https://bugs.webkit.org/show_bug.cgi?id=189549

Patch by Joonghun Park <jh718.park@samsung.com> on 2019-05-03
Reviewed by Antti Koivisto.

Before this CL, sticky element's layout was executed relative to
a box's overflow container,
but the value returned by getComputedStyle was resolved against
its containing block.

So, the computed value and the actual value used in layout
was different before this change.

LayoutTests/imported/w3c:

* web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt.
* web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html.
* web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt:
* web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html:
* web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt: Added.
* web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html: Added.
* web-platform-tests/css/cssom/support/getComputedStyle-insets.js:
(runTestsWithWM):

Source/WebCore:

Tests: imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html
       imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html

* css/CSSComputedStyleDeclaration.cpp:
(WebCore::positionOffsetValue):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::enclosingScrollportBox const):
* rendering/RenderBox.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@244906 268f45cc-cd09-0410-ab3c-d52691b4dbfc

12 files changed:
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js
Source/WebCore/ChangeLog
Source/WebCore/css/CSSComputedStyleDeclaration.cpp
Source/WebCore/rendering/RenderBox.cpp
Source/WebCore/rendering/RenderBox.h

index e210bae..4a22b6d 100644 (file)
@@ -1,3 +1,27 @@
+2019-05-03  Joonghun Park  <jh718.park@samsung.com>
+
+        Resolve the percentage values of inset properties against proper box.
+        https://bugs.webkit.org/show_bug.cgi?id=189549
+
+        Reviewed by Antti Koivisto.
+
+        Before this CL, sticky element's layout was executed relative to
+        a box's overflow container,
+        but the value returned by getComputedStyle was resolved against
+        its containing block.
+
+        So, the computed value and the actual value used in layout
+        was different before this change.
+
+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html: Copied from LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html.
+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt:
+        * web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html:
+        * web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt: Added.
+        * web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html: Added.
+        * web-platform-tests/css/cssom/support/getComputedStyle-insets.js:
+        (runTestsWithWM):
+
 2019-05-02  Frederic Wang  <fwang@igalia.com>
 
         [GTK][WPE] Disable "thin", "thick", "medium" values of mfrac@linethickness at runtime
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt
new file mode 100644 (file)
index 0000000..19812d3
--- /dev/null
@@ -0,0 +1,254 @@
+
+PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
+PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html
new file mode 100644 (file)
index 0000000..7f5ec30
--- /dev/null
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSSOM: resolved values of the inset properties for sticky positioning</title>
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
+<link rel="help" href="https://drafts.csswg.org/css-position/#sticky-pos">
+<link rel="author" title="Joonghun Park" href="mailto:pjh0718@gmail.com">
+<style>
+    #container-for-abspos {
+        height: 200px;
+        width: 400px;
+        overflow: hidden;
+    }
+</style>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script type="module">
+import {runTests, containerForAbspos} from "./support/getComputedStyle-insets.js";
+runTests({
+  style: "position: sticky;",
+  containingBlockElement: containerForAbspos,
+  containingBlockArea: "content",
+  preservesPercentages: false,
+  preservesAuto: true,
+  canStretchAutoSize: false,
+});
+</script>
index 436ed0c..19812d3 100644 (file)
 
 PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
 PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
 PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
 PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
 PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
 PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr ltr - calc() is absolutized into pixels 
 PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
 PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-lr rtl - calc() is absolutized into pixels 
 PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
 PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl ltr - calc() is absolutized into pixels 
 PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
 PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb ltr inside vertical-rl rtl - calc() is absolutized into pixels 
 PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
 PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
 PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
 PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
 PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
 PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr ltr - calc() is absolutized into pixels 
 PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
 PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-lr rtl - calc() is absolutized into pixels 
 PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
 PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl ltr - calc() is absolutized into pixels 
 PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
 PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
 PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
-FAIL horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS horizontal-tb rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS horizontal-tb rtl inside vertical-rl rtl - calc() is absolutized into pixels 
 PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
 PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
 PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
 PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
 PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
 PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr ltr - calc() is absolutized into pixels 
 PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
 PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-lr rtl - calc() is absolutized into pixels 
 PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
 PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl ltr - calc() is absolutized into pixels 
 PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
 PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr ltr inside vertical-rl rtl - calc() is absolutized into pixels 
 PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
 PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
 PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
 PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
 PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
 PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr ltr - calc() is absolutized into pixels 
 PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
 PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-lr rtl - calc() is absolutized into pixels 
 PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
 PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl ltr - calc() is absolutized into pixels 
 PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
 PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-lr rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-lr rtl inside vertical-rl rtl - calc() is absolutized into pixels 
 PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
 PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb ltr - calc() is absolutized into pixels 
 PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
 PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside horizontal-tb rtl - calc() is absolutized into pixels 
 PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
 PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr ltr - calc() is absolutized into pixels 
 PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
 PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-lr rtl - calc() is absolutized into pixels 
 PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
 PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl ltr - calc() is absolutized into pixels 
 PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
 PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl ltr inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl ltr inside vertical-rl rtl - calc() is absolutized into pixels 
 PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
 PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside horizontal-tb ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb ltr - calc() is absolutized into pixels 
 PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
 PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside horizontal-tb rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside horizontal-tb rtl - calc() is absolutized into pixels 
 PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
 PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-lr ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr ltr - calc() is absolutized into pixels 
 PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
 PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-lr rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-lr rtl - calc() is absolutized into pixels 
 PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
 PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
-FAIL vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-rl ltr - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl ltr - calc() is absolutized into pixels 
 PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
 PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
 PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
-FAIL vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels assert_equals: 'top' expected "10px" but got "10%"
-FAIL vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels assert_equals: 'top' expected "9px" but got "calc(10% - 1px)"
+PASS vertical-rl rtl inside vertical-rl rtl - Percentages are absolutized into pixels 
+PASS vertical-rl rtl inside vertical-rl rtl - calc() is absolutized into pixels 
 PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
 PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
index 6149acc..6b23fab 100755 (executable)
@@ -4,12 +4,15 @@
 <link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
 <link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
 <link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
+<style>
+    #container-for-inflow { overflow: hidden; }
+</style>
 <script src=/resources/testharness.js></script>
 <script src=/resources/testharnessreport.js></script>
 <script type="module">
 import {runTests, containerForInflow} from "./support/getComputedStyle-insets.js";
 runTests({
-  style: "position: sticky; position: -webkit-sticky",
+  style: "position: sticky;",
   containingBlockElement: containerForInflow,
   containingBlockArea: "content",
   preservesPercentages: false,
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt
new file mode 100644 (file)
index 0000000..8f04004
--- /dev/null
@@ -0,0 +1,3 @@
+
+PASS Sticky element's top property percentage value should be resolved against the div with overflow: hidden 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html b/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html
new file mode 100644 (file)
index 0000000..12ad5e8
--- /dev/null
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<title>CSS Test: resolve top percentage value against proper box</title>
+<link rel="help" href="https://github.com/w3c/csswg-drafts/issues/3115" />
+<link rel="help" href="https://drafts.csswg.org/css-position/#sticky-pos" />
+<link rel="help" href="https://drafts.csswg.org/cssom/#resolved-values" />
+<meta name="assert" content="Test that the sticky percentage insets are
+resolved against the right ancestor, i.e. the nearest scrollport." />
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<div style="height: 500px; background: purple; overflow: hidden;">
+  <div style="height: 400px; background: yellow;">
+    <div id="target" style="height: 100px; position: sticky; left: 0; top: 50%; background: blue;">
+    </div>
+  </div>
+</div>
+<script>
+test(() => {
+  assert_equals(getComputedStyle(target).top, '250px');
+}, "Sticky element's top property percentage value should be resolved against the div with overflow: hidden");
+</script>
index beec32e..723990c 100755 (executable)
@@ -22,7 +22,6 @@ stylesheet.textContent = `
     padding: 1px 2px;
     border-width: 2px 4px;
     margin: 4px 8px;
-    overflow: hidden;
   }
   #container-for-abspos {
     /* Padding area: 200px tall, 400px wide */
@@ -48,7 +47,7 @@ stylesheet.textContent = `
     border-style: solid;
   }
 `;
-document.head.appendChild(stylesheet);
+document.head.prepend(stylesheet);
 
 function runTestsWithWM(data, testWM, cbWM) {
   const {
@@ -149,10 +148,10 @@ function runTestsWithWM(data, testWM, cbWM) {
       bottom: "50%",
       right: "75%",
     }, {
-      top: .1 * cbHeight + "px",
-      left: .25 * cbWidth + "px",
-      bottom: .5 * cbHeight + "px",
-      right: .75 * cbWidth + "px",
+      top: cbHeight * 10 / 100 + "px",
+      left: cbWidth * 25 / 100 + "px",
+      bottom: cbHeight * 50 / 100 + "px",
+      right: cbWidth * 75 / 100 + "px",
     }, "Percentages are absolutized into pixels");
 
     checkStyle({
@@ -161,10 +160,10 @@ function runTestsWithWM(data, testWM, cbWM) {
       bottom: "calc(50% - 3px)",
       right: "calc(75% - 4px)",
     }, {
-      top: .1 * cbHeight - 1 + "px",
-      left: .25 * cbWidth - 2 + "px",
-      bottom: .5 * cbHeight - 3 + "px",
-      right: .75 * cbWidth - 4 + "px",
+      top: cbHeight * 10 / 100 - 1 + "px",
+      left: cbWidth * 25 / 100 - 2 + "px",
+      bottom: cbHeight * 50 / 100 - 3 + "px",
+      right: cbWidth * 75 / 100 - 4 + "px",
     }, "calc() is absolutized into pixels");
   }
 
index 45a3063..bc3c831 100644 (file)
@@ -1,3 +1,27 @@
+2019-05-03  Joonghun Park  <jh718.park@samsung.com>
+
+        Resolve the percentage values of inset properties against proper box.
+        https://bugs.webkit.org/show_bug.cgi?id=189549
+
+        Reviewed by Antti Koivisto.
+
+        Before this CL, sticky element's layout was executed relative to
+        a box's overflow container,
+        but the value returned by getComputedStyle was resolved against
+        its containing block.
+
+        So, the computed value and the actual value used in layout
+        was different before this change.
+
+        Tests: imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html
+               imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::positionOffsetValue):
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::enclosingScrollportBox const):
+        * rendering/RenderBox.h:
+
 2019-05-02  Antti Koivisto  <antti@apple.com>
 
         Add a quirk to make gmail navigation bar scrollable without mouse hover on iOS
index 2932ba3..f2dc6b7 100644 (file)
@@ -780,8 +780,7 @@ static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropert
     auto* containingBlock = box.containingBlock();
 
     // Resolve a "computed value" percentage if the element is positioned.
-    // TODO: percentages for sticky positioning should be handled here (bug 189549).
-    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned() && !box.isStickilyPositioned()) {
+    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned()) {
         bool isVerticalProperty;
         if (propertyID == CSSPropertyTop || propertyID == CSSPropertyBottom)
             isVerticalProperty = true;
@@ -790,14 +789,23 @@ static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropert
             isVerticalProperty = false;
         }
         LayoutUnit containingBlockSize;
-        if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {
-            containingBlockSize = box.isOutOfFlowPositioned()
-                ? box.containingBlockLogicalHeightForPositioned(*containingBlock, false)
-                : box.containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
+        if (box.isStickilyPositioned()) {
+            const RenderBox& enclosingScrollportBox =
+                box.enclosingScrollportBox();
+            if (isVerticalProperty == enclosingScrollportBox.isHorizontalWritingMode())
+                containingBlockSize = enclosingScrollportBox.contentLogicalHeight();
+            else
+                containingBlockSize = enclosingScrollportBox.contentLogicalWidth();
         } else {
-            containingBlockSize = box.isOutOfFlowPositioned()
-                ? box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false)
-                : box.containingBlockLogicalWidthForContent();
+            if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {
+                containingBlockSize = box.isOutOfFlowPositioned()
+                    ? box.containingBlockLogicalHeightForPositioned(*containingBlock, false)
+                    : box.containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
+            } else {
+                containingBlockSize = box.isOutOfFlowPositioned()
+                    ? box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false)
+                    : box.containingBlockLogicalWidthForContent();
+            }
         }
         return zoomAdjustedPixelValue(floatValueForLength(offset, containingBlockSize), style);
     }
index fbfb3ca..b6bb7e1 100644 (file)
@@ -4722,6 +4722,17 @@ RenderLayer* RenderBox::enclosingFloatPaintingLayer() const
     return nullptr;
 }
 
+const RenderBlock& RenderBox::enclosingScrollportBox() const
+{
+    const RenderBlock* ancestor = containingBlock();
+    for (; ancestor; ancestor = ancestor->containingBlock()) {
+        if (ancestor->hasOverflowClip())
+            return *ancestor;
+    }
+    ASSERT_NOT_REACHED();
+    return *ancestor;
+}
+
 LayoutRect RenderBox::logicalVisualOverflowRectForPropagation(const RenderStyle* parentStyle) const
 {
     LayoutRect rect = visualOverflowRectForPropagation(parentStyle);
index 8bcc848..51c7ef1 100644 (file)
@@ -526,6 +526,8 @@ override;
     void removeFloatingOrPositionedChildFromBlockLists();
     
     RenderLayer* enclosingFloatPaintingLayer() const;
+
+    const RenderBlock& enclosingScrollportBox() const;
     
     virtual Optional<int> firstLineBaseline() const { return Optional<int>(); }
     virtual Optional<int> inlineBlockBaseline(LineDirectionMode) const { return Optional<int>(); } // Returns empty if we should skip this box when computing the baseline of an inline-block.