<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[244906] trunk</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/244906">244906</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2019-05-03 06:19:57 -0700 (Fri, 03 May 2019)</dd>
</dl>

<h3>Log Message</h3>
<pre>Resolve the percentage values of inset properties against proper box.
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:</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsimportedw3cChangeLog">trunk/LayoutTests/imported/w3c/ChangeLog</a></li>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickyexpectedtxt">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt</a></li>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickyhtml">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html</a></li>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomsupportgetComputedStyleinsetsjs">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssCSSComputedStyleDeclarationcpp">trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxcpp">trunk/Source/WebCore/rendering/RenderBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxh">trunk/Source/WebCore/rendering/RenderBox.h</a></li>
</ul>

<h3>Added Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickycontainerforabsposexpectedtxt">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt</a></li>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickycontainerforabsposhtml">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html</a></li>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStylestickypospercentexpectedtxt">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt</a></li>
<li><a href="#trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStylestickypospercenthtml">trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsimportedw3cChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/imported/w3c/ChangeLog (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/ChangeLog 2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/LayoutTests/imported/w3c/ChangeLog    2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -1,3 +1,27 @@
</span><ins>+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):
+
</ins><span class="cx"> 2019-05-02  Frederic Wang  <fwang@igalia.com>
</span><span class="cx"> 
</span><span class="cx">         [GTK][WPE] Disable "thin", "thick", "medium" values of mfrac@linethickness at runtime
</span></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickycontainerforabsposexpectedtxtfromrev244905trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickyexpectedtxt"></a>
<div class="copfile"><h4>Copied: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt (from rev 244905, trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt) (0 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt                             (rev 0)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos-expected.txt        2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -0,0 +1,254 @@
</span><ins>+
+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 
+
</ins></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickycontainerforabsposhtmlfromrev244905trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickyhtml"></a>
<div class="copfile"><h4>Copied: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html (from rev 244905, trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html) (0 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html                             (rev 0)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-container-for-abspos.html        2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -0,0 +1,26 @@
</span><ins>+<!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>
</ins></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickyexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt  2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky-expected.txt     2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -1,253 +1,253 @@
</span><span class="cx"> 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb ltr - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb rtl - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr ltr - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr rtl - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl ltr - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl rtl - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb ltr - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb rtl - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr ltr - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr rtl - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl ltr - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl rtl - Pixels resolve as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS horizontal-tb rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS horizontal-tb rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-lr rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-lr rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl ltr inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl ltr inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl ltr inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl ltr inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl ltr inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl ltr inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl ltr inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl rtl inside horizontal-tb ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl rtl inside horizontal-tb rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside horizontal-tb rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl rtl inside vertical-lr ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl rtl inside vertical-lr rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-lr rtl - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl ltr - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl ltr - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl rtl inside vertical-rl ltr - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl ltr - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl ltr - If opposite sides are 'auto', they resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl rtl - Pixels resolve as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl rtl - Relative lengths are absolutized into pixels 
</span><del>-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)"
</del><ins>+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 
</ins><span class="cx"> PASS vertical-rl rtl inside vertical-rl rtl - If start side is 'auto' and end side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl rtl - If end side is 'auto' and start side is not, 'auto' resolves as-is 
</span><span class="cx"> PASS vertical-rl rtl inside vertical-rl rtl - If opposite sides are 'auto', they resolve as-is 
</span></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStyleinsetsstickyhtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html  2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-insets-sticky.html     2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -4,12 +4,15 @@
</span><span class="cx"> <link rel="help" href="https://drafts.csswg.org/cssom/#resolved-value">
</span><span class="cx"> <link rel="help" href="https://drafts.csswg.org/css-position/#pos-sch">
</span><span class="cx"> <link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com">
</span><ins>+<style>
+    #container-for-inflow { overflow: hidden; }
+</style>
</ins><span class="cx"> <script src=/resources/testharness.js></script>
</span><span class="cx"> <script src=/resources/testharnessreport.js></script>
</span><span class="cx"> <script type="module">
</span><span class="cx"> import {runTests, containerForInflow} from "./support/getComputedStyle-insets.js";
</span><span class="cx"> runTests({
</span><del>-  style: "position: sticky; position: -webkit-sticky",
</del><ins>+  style: "position: sticky;",
</ins><span class="cx">   containingBlockElement: containerForInflow,
</span><span class="cx">   containingBlockArea: "content",
</span><span class="cx">   preservesPercentages: false,
</span></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStylestickypospercentexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt (0 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt                             (rev 0)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent-expected.txt        2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -0,0 +1,3 @@
</span><ins>+
+PASS Sticky element's top property percentage value should be resolved against the div with overflow: hidden 
+
</ins></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomgetComputedStylestickypospercenthtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html (0 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html                             (rev 0)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/getComputedStyle-sticky-pos-percent.html        2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -0,0 +1,22 @@
</span><ins>+<!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>
</ins></span></pre></div>
<a id="trunkLayoutTestsimportedw3cwebplatformtestscsscssomsupportgetComputedStyleinsetsjs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js   2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/css/cssom/support/getComputedStyle-insets.js      2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -22,7 +22,6 @@
</span><span class="cx">     padding: 1px 2px;
</span><span class="cx">     border-width: 2px 4px;
</span><span class="cx">     margin: 4px 8px;
</span><del>-    overflow: hidden;
</del><span class="cx">   }
</span><span class="cx">   #container-for-abspos {
</span><span class="cx">     /* Padding area: 200px tall, 400px wide */
</span><span class="lines">@@ -48,7 +47,7 @@
</span><span class="cx">     border-style: solid;
</span><span class="cx">   }
</span><span class="cx"> `;
</span><del>-document.head.appendChild(stylesheet);
</del><ins>+document.head.prepend(stylesheet);
</ins><span class="cx"> 
</span><span class="cx"> function runTestsWithWM(data, testWM, cbWM) {
</span><span class="cx">   const {
</span><span class="lines">@@ -149,10 +148,10 @@
</span><span class="cx">       bottom: "50%",
</span><span class="cx">       right: "75%",
</span><span class="cx">     }, {
</span><del>-      top: .1 * cbHeight + "px",
-      left: .25 * cbWidth + "px",
-      bottom: .5 * cbHeight + "px",
-      right: .75 * cbWidth + "px",
</del><ins>+      top: cbHeight * 10 / 100 + "px",
+      left: cbWidth * 25 / 100 + "px",
+      bottom: cbHeight * 50 / 100 + "px",
+      right: cbWidth * 75 / 100 + "px",
</ins><span class="cx">     }, "Percentages are absolutized into pixels");
</span><span class="cx"> 
</span><span class="cx">     checkStyle({
</span><span class="lines">@@ -161,10 +160,10 @@
</span><span class="cx">       bottom: "calc(50% - 3px)",
</span><span class="cx">       right: "calc(75% - 4px)",
</span><span class="cx">     }, {
</span><del>-      top: .1 * cbHeight - 1 + "px",
-      left: .25 * cbWidth - 2 + "px",
-      bottom: .5 * cbHeight - 3 + "px",
-      right: .75 * cbWidth - 4 + "px",
</del><ins>+      top: cbHeight * 10 / 100 - 1 + "px",
+      left: cbWidth * 25 / 100 - 2 + "px",
+      bottom: cbHeight * 50 / 100 - 3 + "px",
+      right: cbWidth * 75 / 100 - 4 + "px",
</ins><span class="cx">     }, "calc() is absolutized into pixels");
</span><span class="cx">   }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog   2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/Source/WebCore/ChangeLog      2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -1,3 +1,27 @@
</span><ins>+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:
+
</ins><span class="cx"> 2019-05-02  Antti Koivisto  <antti@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Add a quirk to make gmail navigation bar scrollable without mouse hover on iOS
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSComputedStyleDeclarationcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp 2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp    2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -780,8 +780,7 @@
</span><span class="cx">     auto* containingBlock = box.containingBlock();
</span><span class="cx"> 
</span><span class="cx">     // Resolve a "computed value" percentage if the element is positioned.
</span><del>-    // TODO: percentages for sticky positioning should be handled here (bug 189549).
-    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned() && !box.isStickilyPositioned()) {
</del><ins>+    if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned()) {
</ins><span class="cx">         bool isVerticalProperty;
</span><span class="cx">         if (propertyID == CSSPropertyTop || propertyID == CSSPropertyBottom)
</span><span class="cx">             isVerticalProperty = true;
</span><span class="lines">@@ -790,14 +789,23 @@
</span><span class="cx">             isVerticalProperty = false;
</span><span class="cx">         }
</span><span class="cx">         LayoutUnit containingBlockSize;
</span><del>-        if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {
-            containingBlockSize = box.isOutOfFlowPositioned()
-                ? box.containingBlockLogicalHeightForPositioned(*containingBlock, false)
-                : box.containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
</del><ins>+        if (box.isStickilyPositioned()) {
+            const RenderBox& enclosingScrollportBox =
+                box.enclosingScrollportBox();
+            if (isVerticalProperty == enclosingScrollportBox.isHorizontalWritingMode())
+                containingBlockSize = enclosingScrollportBox.contentLogicalHeight();
+            else
+                containingBlockSize = enclosingScrollportBox.contentLogicalWidth();
</ins><span class="cx">         } else {
</span><del>-            containingBlockSize = box.isOutOfFlowPositioned()
-                ? box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false)
-                : box.containingBlockLogicalWidthForContent();
</del><ins>+            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();
+            }
</ins><span class="cx">         }
</span><span class="cx">         return zoomAdjustedPixelValue(floatValueForLength(offset, containingBlockSize), style);
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.cpp     2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp        2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -4722,6 +4722,17 @@
</span><span class="cx">     return nullptr;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+const RenderBlock& RenderBox::enclosingScrollportBox() const
+{
+    const RenderBlock* ancestor = containingBlock();
+    for (; ancestor; ancestor = ancestor->containingBlock()) {
+        if (ancestor->hasOverflowClip())
+            return *ancestor;
+    }
+    ASSERT_NOT_REACHED();
+    return *ancestor;
+}
+
</ins><span class="cx"> LayoutRect RenderBox::logicalVisualOverflowRectForPropagation(const RenderStyle* parentStyle) const
</span><span class="cx"> {
</span><span class="cx">     LayoutRect rect = visualOverflowRectForPropagation(parentStyle);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.h (244905 => 244906)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.h       2019-05-03 08:42:18 UTC (rev 244905)
+++ trunk/Source/WebCore/rendering/RenderBox.h  2019-05-03 13:19:57 UTC (rev 244906)
</span><span class="lines">@@ -526,6 +526,8 @@
</span><span class="cx">     void removeFloatingOrPositionedChildFromBlockLists();
</span><span class="cx">     
</span><span class="cx">     RenderLayer* enclosingFloatPaintingLayer() const;
</span><ins>+
+    const RenderBlock& enclosingScrollportBox() const;
</ins><span class="cx">     
</span><span class="cx">     virtual Optional<int> firstLineBaseline() const { return Optional<int>(); }
</span><span class="cx">     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.
</span></span></pre>
</div>
</div>

</body>
</html>