<!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>[245543] trunk/Source</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/245543">245543</a></dd>
<dt>Author</dt> <dd>ross.kirsling@sony.com</dd>
<dt>Date</dt> <dd>2019-05-20 18:36:11 -0700 (Mon, 20 May 2019)</dd>
</dl>

<h3>Log Message</h3>
<pre>Make lossy LayoutUnit constructors explicit
https://bugs.webkit.org/show_bug.cgi?id=191811

Reviewed by Antti Koivisto.

Source/WebCore:

* platform/LayoutUnit.h:
Make lossy unary constructors explicit.
For ergonomics, give float overloads to copy constructor and round/floor/ceil functions.

* css/LengthFunctions.h:
* platform/graphics/LayoutPoint.h:
* platform/graphics/LayoutRect.h:
* platform/graphics/LayoutSize.h:
* rendering/RenderBox.h:
* rendering/RenderElement.h:
Templatize common functions to allow LayoutUnit itself to dictate which types it allows.

* html/shadow/SliderThumbElement.cpp:
* page/FrameView.cpp:
* page/Page.cpp:
* page/SpatialNavigation.cpp:
* page/scrolling/AxisScrollSnapOffsets.cpp:
* page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
* layout/FormattingContextGeometry.cpp:
* layout/FormattingContextQuirks.cpp:
* layout/LayoutState.cpp:
* layout/displaytree/DisplayBox.h:
* layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
* layout/layouttree/LayoutReplaced.cpp:
* platform/animation/AnimationUtilities.h:
* platform/cocoa/ScrollSnapAnimatorState.mm:
* rendering/BorderEdge.cpp:
* rendering/EllipsisBox.cpp:
* rendering/FixedTableLayout.cpp:
* rendering/InlineBox.cpp:
* rendering/InlineFlowBox.cpp:
* rendering/InlineFlowBox.h:
* rendering/InlineTextBox.cpp:
* rendering/RenderBlock.cpp:
* rendering/RenderBlockFlow.cpp:
* rendering/RenderBlockLineLayout.cpp:
* rendering/RenderBox.cpp:
* rendering/RenderBoxModelObject.cpp:
* rendering/RenderBoxModelObject.h:
* rendering/RenderDeprecatedFlexibleBox.cpp:
* rendering/RenderElement.cpp:
* rendering/RenderImage.cpp:
* rendering/RenderInline.cpp:
* rendering/RenderLineBreak.cpp:
* rendering/RenderListMarker.cpp:
* rendering/RenderMultiColumnSet.cpp:
* rendering/RenderMultiColumnSet.h:
* rendering/RenderObject.cpp:
* rendering/RenderReplaced.cpp:
* rendering/RenderTable.cpp:
* rendering/RenderTableCell.cpp:
* rendering/RenderTableSection.cpp:
* rendering/RenderText.cpp:
* rendering/RenderTextControlMultiLine.cpp:
* rendering/RenderThemeMac.mm:
* rendering/RenderVTTCue.cpp:
* rendering/RenderView.cpp:
* rendering/RootInlineBox.cpp:
* rendering/SimpleLineLayoutFunctions.cpp:
* rendering/SimpleLineLayoutPagination.cpp:
* rendering/SimpleLineLayoutResolver.cpp:
* rendering/line/LineWidth.cpp:
* rendering/mathml/MathOperator.cpp:
* rendering/mathml/RenderMathMLBlock.cpp:
* rendering/mathml/RenderMathMLBlock.h:
* rendering/mathml/RenderMathMLFencedOperator.h:
* rendering/mathml/RenderMathMLFraction.cpp:
* rendering/mathml/RenderMathMLMenclose.cpp:
* rendering/mathml/RenderMathMLOperator.cpp:
* rendering/mathml/RenderMathMLRoot.cpp:
* rendering/mathml/RenderMathMLScripts.cpp:
* rendering/mathml/RenderMathMLToken.cpp:
* rendering/shapes/BoxShape.cpp:
* rendering/shapes/ShapeOutsideInfo.cpp:
* rendering/style/CollapsedBorderValue.h:
* rendering/style/NinePieceImage.cpp:
* rendering/style/NinePieceImage.h:
* rendering/style/RenderStyle.cpp:
* rendering/style/RenderStyle.h:
* rendering/svg/RenderSVGText.cpp:
* rendering/svg/SVGInlineTextBox.cpp:
Make usage of LayoutUnit(float) and LayoutUnit(double) explicit where needed.

Source/WebKit:

* WebProcess/WebPage/WebPage.cpp:
* WebProcess/WebPage/ios/WebPageIOS.mm:
Make usage of LayoutUnit(float) explicit.</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssLengthFunctionsh">trunk/Source/WebCore/css/LengthFunctions.h</a></li>
<li><a href="#trunkSourceWebCorehtmlshadowSliderThumbElementcpp">trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutFormattingContextGeometrycpp">trunk/Source/WebCore/layout/FormattingContextGeometry.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutFormattingContextQuirkscpp">trunk/Source/WebCore/layout/FormattingContextQuirks.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutLayoutStatecpp">trunk/Source/WebCore/layout/LayoutState.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutdisplaytreeDisplayBoxh">trunk/Source/WebCore/layout/displaytree/DisplayBox.h</a></li>
<li><a href="#trunkSourceWebCorelayoutinlineformattingInlineFormattingContextLineLayoutcpp">trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorelayoutlayouttreeLayoutReplacedcpp">trunk/Source/WebCore/layout/layouttree/LayoutReplaced.cpp</a></li>
<li><a href="#trunkSourceWebCorepageFrameViewcpp">trunk/Source/WebCore/page/FrameView.cpp</a></li>
<li><a href="#trunkSourceWebCorepagePagecpp">trunk/Source/WebCore/page/Page.cpp</a></li>
<li><a href="#trunkSourceWebCorepageSpatialNavigationcpp">trunk/Source/WebCore/page/SpatialNavigation.cpp</a></li>
<li><a href="#trunkSourceWebCorepagescrollingAxisScrollSnapOffsetscpp">trunk/Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp</a></li>
<li><a href="#trunkSourceWebCorepagescrollingmacScrollingTreeFrameScrollingNodeMacmm">trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm</a></li>
<li><a href="#trunkSourceWebCoreplatformLayoutUnith">trunk/Source/WebCore/platform/LayoutUnit.h</a></li>
<li><a href="#trunkSourceWebCoreplatformanimationAnimationUtilitiesh">trunk/Source/WebCore/platform/animation/AnimationUtilities.h</a></li>
<li><a href="#trunkSourceWebCoreplatformcocoaScrollSnapAnimatorStatemm">trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm</a></li>
<li><a href="#trunkSourceWebCoreplatformgraphicsLayoutPointh">trunk/Source/WebCore/platform/graphics/LayoutPoint.h</a></li>
<li><a href="#trunkSourceWebCoreplatformgraphicsLayoutRecth">trunk/Source/WebCore/platform/graphics/LayoutRect.h</a></li>
<li><a href="#trunkSourceWebCoreplatformgraphicsLayoutSizeh">trunk/Source/WebCore/platform/graphics/LayoutSize.h</a></li>
<li><a href="#trunkSourceWebCorerenderingBorderEdgecpp">trunk/Source/WebCore/rendering/BorderEdge.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingEllipsisBoxcpp">trunk/Source/WebCore/rendering/EllipsisBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingFixedTableLayoutcpp">trunk/Source/WebCore/rendering/FixedTableLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingInlineBoxcpp">trunk/Source/WebCore/rendering/InlineBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingInlineFlowBoxcpp">trunk/Source/WebCore/rendering/InlineFlowBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingInlineFlowBoxh">trunk/Source/WebCore/rendering/InlineFlowBox.h</a></li>
<li><a href="#trunkSourceWebCorerenderingInlineTextBoxcpp">trunk/Source/WebCore/rendering/InlineTextBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockcpp">trunk/Source/WebCore/rendering/RenderBlock.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockFlowcpp">trunk/Source/WebCore/rendering/RenderBlockFlow.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockLineLayoutcpp">trunk/Source/WebCore/rendering/RenderBlockLineLayout.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>
<li><a href="#trunkSourceWebCorerenderingRenderBoxModelObjectcpp">trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxModelObjecth">trunk/Source/WebCore/rendering/RenderBoxModelObject.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderDeprecatedFlexibleBoxcpp">trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderElementcpp">trunk/Source/WebCore/rendering/RenderElement.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderElementh">trunk/Source/WebCore/rendering/RenderElement.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderImagecpp">trunk/Source/WebCore/rendering/RenderImage.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderInlinecpp">trunk/Source/WebCore/rendering/RenderInline.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLineBreakcpp">trunk/Source/WebCore/rendering/RenderLineBreak.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderListMarkercpp">trunk/Source/WebCore/rendering/RenderListMarker.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnSetcpp">trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnSeth">trunk/Source/WebCore/rendering/RenderMultiColumnSet.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjectcpp">trunk/Source/WebCore/rendering/RenderObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderReplacedcpp">trunk/Source/WebCore/rendering/RenderReplaced.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTablecpp">trunk/Source/WebCore/rendering/RenderTable.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTableCellcpp">trunk/Source/WebCore/rendering/RenderTableCell.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTableSectioncpp">trunk/Source/WebCore/rendering/RenderTableSection.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTextcpp">trunk/Source/WebCore/rendering/RenderText.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTextControlMultiLinecpp">trunk/Source/WebCore/rendering/RenderTextControlMultiLine.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderThemeMacmm">trunk/Source/WebCore/rendering/RenderThemeMac.mm</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderVTTCuecpp">trunk/Source/WebCore/rendering/RenderVTTCue.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderViewcpp">trunk/Source/WebCore/rendering/RenderView.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRootInlineBoxcpp">trunk/Source/WebCore/rendering/RootInlineBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingSimpleLineLayoutFunctionscpp">trunk/Source/WebCore/rendering/SimpleLineLayoutFunctions.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingSimpleLineLayoutPaginationcpp">trunk/Source/WebCore/rendering/SimpleLineLayoutPagination.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingSimpleLineLayoutResolvercpp">trunk/Source/WebCore/rendering/SimpleLineLayoutResolver.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderinglineLineWidthcpp">trunk/Source/WebCore/rendering/line/LineWidth.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlMathOperatorcpp">trunk/Source/WebCore/rendering/mathml/MathOperator.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLBlockcpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLBlockh">trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.h</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLFencedOperatorh">trunk/Source/WebCore/rendering/mathml/RenderMathMLFencedOperator.h</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLFractioncpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLMenclosecpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLMenclose.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLOperatorcpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLRootcpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLScriptscpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingmathmlRenderMathMLTokencpp">trunk/Source/WebCore/rendering/mathml/RenderMathMLToken.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingshapesBoxShapecpp">trunk/Source/WebCore/rendering/shapes/BoxShape.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingshapesShapeOutsideInfocpp">trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleCollapsedBorderValueh">trunk/Source/WebCore/rendering/style/CollapsedBorderValue.h</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleNinePieceImagecpp">trunk/Source/WebCore/rendering/style/NinePieceImage.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleNinePieceImageh">trunk/Source/WebCore/rendering/style/NinePieceImage.h</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleRenderStylecpp">trunk/Source/WebCore/rendering/style/RenderStyle.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleRenderStyleh">trunk/Source/WebCore/rendering/style/RenderStyle.h</a></li>
<li><a href="#trunkSourceWebCorerenderingsvgRenderSVGTextcpp">trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingsvgSVGInlineTextBoxcpp">trunk/Source/WebCore/rendering/svg/SVGInlineTextBox.cpp</a></li>
<li><a href="#trunkSourceWebKitChangeLog">trunk/Source/WebKit/ChangeLog</a></li>
<li><a href="#trunkSourceWebKitWebProcessWebPageWebPagecpp">trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp</a></li>
<li><a href="#trunkSourceWebKitWebProcessWebPageiosWebPageIOSmm">trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/ChangeLog      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -1,3 +1,93 @@
</span><ins>+2019-05-20  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Make lossy LayoutUnit constructors explicit
+        https://bugs.webkit.org/show_bug.cgi?id=191811
+
+        Reviewed by Antti Koivisto.
+
+        * platform/LayoutUnit.h:
+        Make lossy unary constructors explicit.
+        For ergonomics, give float overloads to copy constructor and round/floor/ceil functions.
+
+        * css/LengthFunctions.h:
+        * platform/graphics/LayoutPoint.h:
+        * platform/graphics/LayoutRect.h:
+        * platform/graphics/LayoutSize.h:
+        * rendering/RenderBox.h:
+        * rendering/RenderElement.h:
+        Templatize common functions to allow LayoutUnit itself to dictate which types it allows.
+
+        * html/shadow/SliderThumbElement.cpp:
+        * page/FrameView.cpp:
+        * page/Page.cpp:
+        * page/SpatialNavigation.cpp:
+        * page/scrolling/AxisScrollSnapOffsets.cpp:
+        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
+        * layout/FormattingContextGeometry.cpp:
+        * layout/FormattingContextQuirks.cpp:
+        * layout/LayoutState.cpp:
+        * layout/displaytree/DisplayBox.h:
+        * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
+        * layout/layouttree/LayoutReplaced.cpp:
+        * platform/animation/AnimationUtilities.h:
+        * platform/cocoa/ScrollSnapAnimatorState.mm:
+        * rendering/BorderEdge.cpp:
+        * rendering/EllipsisBox.cpp:
+        * rendering/FixedTableLayout.cpp:
+        * rendering/InlineBox.cpp:
+        * rendering/InlineFlowBox.cpp:
+        * rendering/InlineFlowBox.h:
+        * rendering/InlineTextBox.cpp:
+        * rendering/RenderBlock.cpp:
+        * rendering/RenderBlockFlow.cpp:
+        * rendering/RenderBlockLineLayout.cpp:
+        * rendering/RenderBox.cpp:
+        * rendering/RenderBoxModelObject.cpp:
+        * rendering/RenderBoxModelObject.h:
+        * rendering/RenderDeprecatedFlexibleBox.cpp:
+        * rendering/RenderElement.cpp:
+        * rendering/RenderImage.cpp:
+        * rendering/RenderInline.cpp:
+        * rendering/RenderLineBreak.cpp:
+        * rendering/RenderListMarker.cpp:
+        * rendering/RenderMultiColumnSet.cpp:
+        * rendering/RenderMultiColumnSet.h:
+        * rendering/RenderObject.cpp:
+        * rendering/RenderReplaced.cpp:
+        * rendering/RenderTable.cpp:
+        * rendering/RenderTableCell.cpp:
+        * rendering/RenderTableSection.cpp:
+        * rendering/RenderText.cpp:
+        * rendering/RenderTextControlMultiLine.cpp:
+        * rendering/RenderThemeMac.mm:
+        * rendering/RenderVTTCue.cpp:
+        * rendering/RenderView.cpp:
+        * rendering/RootInlineBox.cpp:
+        * rendering/SimpleLineLayoutFunctions.cpp:
+        * rendering/SimpleLineLayoutPagination.cpp:
+        * rendering/SimpleLineLayoutResolver.cpp:
+        * rendering/line/LineWidth.cpp:
+        * rendering/mathml/MathOperator.cpp:
+        * rendering/mathml/RenderMathMLBlock.cpp:
+        * rendering/mathml/RenderMathMLBlock.h:
+        * rendering/mathml/RenderMathMLFencedOperator.h:
+        * rendering/mathml/RenderMathMLFraction.cpp:
+        * rendering/mathml/RenderMathMLMenclose.cpp:
+        * rendering/mathml/RenderMathMLOperator.cpp:
+        * rendering/mathml/RenderMathMLRoot.cpp:
+        * rendering/mathml/RenderMathMLScripts.cpp:
+        * rendering/mathml/RenderMathMLToken.cpp:
+        * rendering/shapes/BoxShape.cpp:
+        * rendering/shapes/ShapeOutsideInfo.cpp:
+        * rendering/style/CollapsedBorderValue.h:
+        * rendering/style/NinePieceImage.cpp:
+        * rendering/style/NinePieceImage.h:
+        * rendering/style/RenderStyle.cpp:
+        * rendering/style/RenderStyle.h:
+        * rendering/svg/RenderSVGText.cpp:
+        * rendering/svg/SVGInlineTextBox.cpp:
+        Make usage of LayoutUnit(float) and LayoutUnit(double) explicit where needed.
+
</ins><span class="cx"> 2019-05-20  Jer Noble  <jer.noble@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Provide an explicit UIModalPresentation style when creating an AVPlayerViewController for fullscreen.
</span></span></pre></div>
<a id="trunkSourceWebCorecssLengthFunctionsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/LengthFunctions.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/LengthFunctions.h       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/css/LengthFunctions.h  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -35,9 +35,7 @@
</span><span class="cx"> struct Length;
</span><span class="cx"> struct LengthSize;
</span><span class="cx"> 
</span><del>-int minimumIntValueForLength(const Length&, LayoutUnit maximumValue);
</del><span class="cx"> int intValueForLength(const Length&, LayoutUnit maximumValue);
</span><del>-LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue);
</del><span class="cx"> WEBCORE_EXPORT LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue);
</span><span class="cx"> LayoutSize sizeForLengthSize(const LengthSize&, const LayoutSize& maximumValue);
</span><span class="cx"> float floatValueForLength(const Length&, LayoutUnit maximumValue);
</span><span class="lines">@@ -48,12 +46,12 @@
</span><span class="cx"> {
</span><span class="cx">     switch (length.type()) {
</span><span class="cx">     case Fixed:
</span><del>-        return length.value();
</del><ins>+        return LayoutUnit(length.value());
</ins><span class="cx">     case Percent:
</span><span class="cx">         // Don't remove the extra cast to float. It is needed for rounding on 32-bit Intel machines that use the FPU stack.
</span><span class="cx">         return LayoutUnit(static_cast<float>(maximumValue * length.percent() / 100.0f));
</span><span class="cx">     case Calculated:
</span><del>-        return length.nonNanCalculatedValue(maximumValue);
</del><ins>+        return LayoutUnit(length.nonNanCalculatedValue(maximumValue));
</ins><span class="cx">     case FillAvailable:
</span><span class="cx">     case Auto:
</span><span class="cx">         return 0;
</span><span class="lines">@@ -75,4 +73,7 @@
</span><span class="cx">     return static_cast<int>(minimumValueForLength(length, maximumValue));
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+template<typename T> inline LayoutUnit valueForLength(const Length& length, T maximumValue) { return valueForLength(length, LayoutUnit(maximumValue)); }
+template<typename T> inline LayoutUnit minimumValueForLength(const Length& length, T maximumValue) { return minimumValueForLength(length, LayoutUnit(maximumValue)); }
+
</ins><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlshadowSliderThumbElementcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -191,7 +191,7 @@
</span><span class="cx">     double percentageOffset = sliderPosition(input).toDouble();
</span><span class="cx">     LayoutUnit availableExtent = isVertical ? track->contentHeight() : track->contentWidth();
</span><span class="cx">     availableExtent -= isVertical ? thumb->height() : thumb->width();
</span><del>-    LayoutUnit offset = percentageOffset * availableExtent;
</del><ins>+    LayoutUnit offset { percentageOffset * availableExtent };
</ins><span class="cx">     LayoutPoint thumbLocation = thumb->location();
</span><span class="cx">     if (isVertical)
</span><span class="cx">         thumbLocation.setY(thumbLocation.y() + track->contentHeight() - thumb->height() - offset);
</span><span class="lines">@@ -301,7 +301,7 @@
</span><span class="cx">         if (Optional<Decimal> closest = input->findClosestTickMarkValue(value)) {
</span><span class="cx">             double closestFraction = stepRange.proportionFromValue(*closest).toDouble();
</span><span class="cx">             double closestRatio = isVertical || !isLeftToRightDirection ? 1.0 - closestFraction : closestFraction;
</span><del>-            LayoutUnit closestPosition = trackLength * closestRatio;
</del><ins>+            LayoutUnit closestPosition { trackLength * closestRatio };
</ins><span class="cx">             if ((closestPosition - position).abs() <= snappingThreshold)
</span><span class="cx">                 value = *closest;
</span><span class="cx">         }
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutFormattingContextGeometrycpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/FormattingContextGeometry.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/FormattingContextGeometry.cpp        2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/layout/FormattingContextGeometry.cpp   2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -65,7 +65,7 @@
</span><span class="cx">         return { };
</span><span class="cx"> 
</span><span class="cx">     if (height.isFixed())
</span><del>-        return { height.value() };
</del><ins>+        return LayoutUnit(height.value());
</ins><span class="cx"> 
</span><span class="cx">     Optional<LayoutUnit> containingBlockHeightValue;
</span><span class="cx">     if (layoutBox.isOutOfFlowPositioned()) {
</span><span class="lines">@@ -77,7 +77,7 @@
</span><span class="cx">         else {
</span><span class="cx">             auto containingBlockHeight = layoutBox.containingBlock()->style().logicalHeight();
</span><span class="cx">             if (containingBlockHeight.isFixed())
</span><del>-                containingBlockHeightValue = { containingBlockHeight.value() };
</del><ins>+                containingBlockHeightValue = LayoutUnit(containingBlockHeight.value());
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -160,7 +160,7 @@
</span><span class="cx"> {
</span><span class="cx">     if (!geometryProperty.isFixed())
</span><span class="cx">         return WTF::nullopt;
</span><del>-    return { geometryProperty.value() };
</del><ins>+    return LayoutUnit(geometryProperty.value());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // https://www.w3.org/TR/CSS22/visudet.html#min-max-heights
</span><span class="lines">@@ -1039,8 +1039,8 @@
</span><span class="cx">     auto& style = layoutBox.style();
</span><span class="cx">     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Border] -> layoutBox: " << &layoutBox);
</span><span class="cx">     return {
</span><del>-        { style.borderLeft().boxModelWidth(), style.borderRight().boxModelWidth() },
-        { style.borderTop().boxModelWidth(), style.borderBottom().boxModelWidth() }
</del><ins>+        { LayoutUnit(style.borderLeft().boxModelWidth()), LayoutUnit(style.borderRight().boxModelWidth()) },
+        { LayoutUnit(style.borderTop().boxModelWidth()), LayoutUnit(style.borderBottom().boxModelWidth()) }
</ins><span class="cx">     };
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutFormattingContextQuirkscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/FormattingContextQuirks.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/FormattingContextQuirks.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/layout/FormattingContextQuirks.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -44,7 +44,7 @@
</span><span class="cx">     while (containingBlock) {
</span><span class="cx">         auto containingBlockHeight = containingBlock->style().logicalHeight();
</span><span class="cx">         if (containingBlockHeight.isFixed())
</span><del>-            return containingBlockHeight.value() - bodyAndDocumentVerticalMarginPaddingAndBorder;
</del><ins>+            return LayoutUnit(containingBlockHeight.value() - bodyAndDocumentVerticalMarginPaddingAndBorder);
</ins><span class="cx"> 
</span><span class="cx">         // If the only fixed value box we find is the ICB, then ignore the body and the document (vertical) margin, padding and border. So much quirkiness.
</span><span class="cx">         // -and it's totally insane because now we freely travel across formatting context boundaries and computed margins are nonexistent.
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutLayoutStatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/LayoutState.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/LayoutState.cpp      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/layout/LayoutState.cpp 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -59,8 +59,8 @@
</span><span class="cx">     displayBox.setBorder({ });
</span><span class="cx">     displayBox.setPadding({ });
</span><span class="cx">     displayBox.setTopLeft({ });
</span><del>-    displayBox.setContentBoxHeight(initialContainingBlock.style().logicalHeight().value());
-    displayBox.setContentBoxWidth(initialContainingBlock.style().logicalWidth().value());
</del><ins>+    displayBox.setContentBoxHeight(LayoutUnit(initialContainingBlock.style().logicalHeight().value()));
+    displayBox.setContentBoxWidth(LayoutUnit(initialContainingBlock.style().logicalWidth().value()));
</ins><span class="cx"> 
</span><span class="cx">     m_formattingContextRootListForLayout.add(&initialContainingBlock);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutdisplaytreeDisplayBoxh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/displaytree/DisplayBox.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/displaytree/DisplayBox.h     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/layout/displaytree/DisplayBox.h        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -200,8 +200,8 @@
</span><span class="cx">     void setTopLeft(const LayoutPoint&);
</span><span class="cx">     void setTop(LayoutUnit);
</span><span class="cx">     void setLeft(LayoutUnit);
</span><del>-    void moveHorizontally(LayoutUnit offset) { m_topLeft.move(offset, { }); }
-    void moveVertically(LayoutUnit offset) { m_topLeft.move({ }, offset); }
</del><ins>+    void moveHorizontally(LayoutUnit offset) { m_topLeft.move(offset, 0_lu); }
+    void moveVertically(LayoutUnit offset) { m_topLeft.move(0_lu, offset); }
</ins><span class="cx"> 
</span><span class="cx">     void setContentBoxHeight(LayoutUnit);
</span><span class="cx">     void setContentBoxWidth(LayoutUnit);
</span><span class="lines">@@ -418,13 +418,13 @@
</span><span class="cx"> inline void Box::Rect::moveHorizontally(LayoutUnit offset)
</span><span class="cx"> {
</span><span class="cx">     ASSERT(m_hasValidLeft);
</span><del>-    m_rect.move(offset, { });
</del><ins>+    m_rect.move(offset, 0_lu);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> inline void Box::Rect::moveVertically(LayoutUnit offset)
</span><span class="cx"> {
</span><span class="cx">     ASSERT(m_hasValidTop);
</span><del>-    m_rect.move({ }, offset);
</del><ins>+    m_rect.move(0_lu, offset);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> inline void Box::Rect::expand(LayoutUnit width, LayoutUnit height)
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutinlineformattingInlineFormattingContextLineLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -528,7 +528,7 @@
</span><span class="cx">     float expansion = widthToDistribute.toFloat() / expansionOpportunities;
</span><span class="cx">     LayoutUnit accumulatedExpansion;
</span><span class="cx">     for (auto& inlineRun : inlineRuns) {
</span><del>-        auto expansionForRun = inlineRun.expansionOpportunity().count * expansion;
</del><ins>+        LayoutUnit expansionForRun { inlineRun.expansionOpportunity().count * expansion };
</ins><span class="cx"> 
</span><span class="cx">         inlineRun.expansionOpportunity().expansion = expansionForRun;
</span><span class="cx">         inlineRun.setLogicalLeft(inlineRun.logicalLeft() + accumulatedExpansion);
</span></span></pre></div>
<a id="trunkSourceWebCorelayoutlayouttreeLayoutReplacedcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/layout/layouttree/LayoutReplaced.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/layout/layouttree/LayoutReplaced.cpp        2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/layout/layouttree/LayoutReplaced.cpp   2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -64,7 +64,7 @@
</span><span class="cx">     ASSERT(hasIntrinsicWidth());
</span><span class="cx">     if (m_intrinsicSize)
</span><span class="cx">         return m_intrinsicSize->width();
</span><del>-    return m_layoutBox->style().logicalWidth().value();
</del><ins>+    return LayoutUnit(m_layoutBox->style().logicalWidth().value());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit Replaced::intrinsicHeight() const
</span><span class="lines">@@ -72,7 +72,7 @@
</span><span class="cx">     ASSERT(hasIntrinsicHeight());
</span><span class="cx">     if (m_intrinsicSize)
</span><span class="cx">         return m_intrinsicSize->height();
</span><del>-    return m_layoutBox->style().logicalHeight().value();
</del><ins>+    return LayoutUnit(m_layoutBox->style().logicalHeight().value());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit Replaced::intrinsicRatio() const
</span></span></pre></div>
<a id="trunkSourceWebCorepageFrameViewcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/FrameView.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/FrameView.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/page/FrameView.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -1525,7 +1525,7 @@
</span><span class="cx">     if (layoutViewportHeight > documentHeight)
</span><span class="cx">         return baseLayoutViewportSize;
</span><span class="cx"> 
</span><del>-    return { baseLayoutViewportSize.width(), std::min<LayoutUnit>(documentHeight, (1 + heightExpansionFactor) * layoutViewportHeight) };
</del><ins>+    return { baseLayoutViewportSize.width(), std::min(documentHeight, LayoutUnit((1 + heightExpansionFactor) * layoutViewportHeight)) };
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> LayoutRect FrameView::computeUpdatedLayoutViewportRect(const LayoutRect& layoutViewport, const LayoutRect& documentRect, const LayoutSize& unobscuredContentSize, const LayoutRect& unobscuredContentRect, const LayoutSize& baseLayoutViewportSize, const LayoutPoint& stableLayoutViewportOriginMin, const LayoutPoint& stableLayoutViewportOriginMax, LayoutViewportConstraint constraint)
</span><span class="lines">@@ -4549,7 +4549,7 @@
</span><span class="cx">         LayoutUnit clippedLogicalLeft;
</span><span class="cx">         if (!renderView.style().isLeftToRightDirection())
</span><span class="cx">             clippedLogicalLeft = docLogicalRight - pageLogicalWidth;
</span><del>-        LayoutRect overflow(clippedLogicalLeft, docLogicalTop, pageLogicalWidth, docLogicalHeight);
</del><ins>+        LayoutRect overflow { clippedLogicalLeft, docLogicalTop, LayoutUnit(pageLogicalWidth), docLogicalHeight };
</ins><span class="cx"> 
</span><span class="cx">         if (!horizontalWritingMode)
</span><span class="cx">             overflow = overflow.transposedRect();
</span><span class="lines">@@ -5194,7 +5194,7 @@
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit FrameView::mapFromCSSToLayoutUnits(int value) const
</span><span class="cx"> {
</span><del>-    return value * frame().pageZoomFactor() * frame().frameScaleFactor();
</del><ins>+    return LayoutUnit(value * frame().pageZoomFactor() * frame().frameScaleFactor());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void FrameView::didAddWidgetToRenderTree(Widget& widget)
</span></span></pre></div>
<a id="trunkSourceWebCorepagePagecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/Page.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/Page.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/page/Page.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2192,7 +2192,7 @@
</span><span class="cx">     // has been determined to be relevant in the context of this goal. We may choose to tweak
</span><span class="cx">     // the rect over time, much like we may choose to tweak gMinimumPaintedAreaRatio and
</span><span class="cx">     // gMaximumUnpaintedAreaRatio. But this seems to work well right now.
</span><del>-    LayoutRect relevantViewRect { 0, 0, relevantViewRectWidth, 1300 };
</del><ins>+    LayoutRect relevantViewRect { 0, 0, LayoutUnit(relevantViewRectWidth), 1300 };
</ins><span class="cx">     // If the viewRect is wider than the relevantViewRect, center the relevantViewRect.
</span><span class="cx">     if (viewRect.width() > relevantViewRect.width())
</span><span class="cx">         relevantViewRect.setX((viewRect.width() - relevantViewRect.width()) / 2);
</span></span></pre></div>
<a id="trunkSourceWebCorepageSpatialNavigationcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/SpatialNavigation.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/SpatialNavigation.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/page/SpatialNavigation.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -505,7 +505,7 @@
</span><span class="cx">     for (Frame* frame = initialFrame; frame; frame = frame->tree().parent()) {
</span><span class="cx">         if (Element* element = frame->ownerElement()) {
</span><span class="cx">             do {
</span><del>-                rect.move(element->offsetLeft(), element->offsetTop());
</del><ins>+                rect.move(LayoutUnit(element->offsetLeft()), LayoutUnit(element->offsetTop()));
</ins><span class="cx">             } while ((element = element->offsetParent()));
</span><span class="cx">             rect.moveBy((-frame->view()->scrollPosition()));
</span><span class="cx">         }
</span></span></pre></div>
<a id="trunkSourceWebCorepagescrollingAxisScrollSnapOffsetscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/page/scrolling/AxisScrollSnapOffsets.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -197,7 +197,7 @@
</span><span class="cx">     // instead, it is more intuitive to either return to the original snap position (which we arbitrarily choose here)
</span><span class="cx">     // or scroll just outside of the snap offset range. This is another minor behavior tweak that we should play around
</span><span class="cx">     // with to see what feels best.
</span><del>-    LayoutUnit proximityDistance = ratioOfScrollPortAxisLengthToBeConsideredForProximity * scrollPortAxisLength;
</del><ins>+    LayoutUnit proximityDistance { ratioOfScrollPortAxisLengthToBeConsideredForProximity * scrollPortAxisLength };
</ins><span class="cx">     for (size_t index = 1; index < snapOffsets.size(); ++index) {
</span><span class="cx">         auto startOffset = snapOffsets[index - 1] + proximityDistance;
</span><span class="cx">         auto endOffset = snapOffsets[index] - proximityDistance;
</span></span></pre></div>
<a id="trunkSourceWebCorepagescrollingmacScrollingTreeFrameScrollingNodeMacmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -74,7 +74,7 @@
</span><span class="cx">     Vector<ScrollOffsetRange<LayoutUnit>> snapOffsetRanges;
</span><span class="cx">     snapOffsetRanges.reserveInitialCapacity(snapOffsetRangesAsFloat.size());
</span><span class="cx">     for (auto range : snapOffsetRangesAsFloat)
</span><del>-        snapOffsetRanges.uncheckedAppend({ range.start, range.end });
</del><ins>+        snapOffsetRanges.uncheckedAppend({ LayoutUnit(range.start), LayoutUnit(range.end) });
</ins><span class="cx"> 
</span><span class="cx">     return snapOffsetRanges;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformLayoutUnith"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/LayoutUnit.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/LayoutUnit.h       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/platform/LayoutUnit.h  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -68,23 +68,26 @@
</span><span class="cx">     LayoutUnit(int value) { setValue(value); }
</span><span class="cx">     LayoutUnit(unsigned short value) { setValue(value); }
</span><span class="cx">     LayoutUnit(unsigned value) { setValue(value); }
</span><del>-    LayoutUnit(unsigned long value)
</del><ins>+    explicit LayoutUnit(unsigned long value)
</ins><span class="cx">     {
</span><span class="cx">         m_value = clampTo<int>(value * kFixedPointDenominator);
</span><span class="cx">     }
</span><del>-    LayoutUnit(unsigned long long value)
</del><ins>+    explicit LayoutUnit(unsigned long long value)
</ins><span class="cx">     {
</span><span class="cx">         m_value = clampTo<int>(value * kFixedPointDenominator);
</span><span class="cx">     }
</span><del>-    LayoutUnit(float value)
</del><ins>+    explicit LayoutUnit(float value)
</ins><span class="cx">     {
</span><span class="cx">         m_value = clampToInteger(value * kFixedPointDenominator);
</span><span class="cx">     }
</span><del>-    LayoutUnit(double value)
</del><ins>+    explicit LayoutUnit(double value)
</ins><span class="cx">     {
</span><span class="cx">         m_value = clampToInteger(value * kFixedPointDenominator);
</span><span class="cx">     }
</span><span class="cx"> 
</span><ins>+    LayoutUnit& operator=(const LayoutUnit& other) = default;
+    LayoutUnit& operator=(const float& other) { return *this = LayoutUnit(other); }
+
</ins><span class="cx">     static LayoutUnit fromFloatCeil(float value)
</span><span class="cx">     {
</span><span class="cx">         LayoutUnit v;
</span><span class="lines">@@ -811,6 +814,11 @@
</span><span class="cx">     return ceilf((value.rawValue() * pixelSnappingFactor) / kFixedPointDenominator) / pixelSnappingFactor;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+inline int roundToInt(float value) { return roundToInt(LayoutUnit(value)); }
+inline float roundToDevicePixel(float value, float pixelSnappingFactor, bool needsDirectionalRounding = false) { return roundToDevicePixel(LayoutUnit(value), pixelSnappingFactor, needsDirectionalRounding); }
+inline float floorToDevicePixel(float value, float pixelSnappingFactor) { return floorToDevicePixel(LayoutUnit(value), pixelSnappingFactor); }
+inline float ceilToDevicePixel(float value, float pixelSnappingFactor) { return ceilToDevicePixel(LayoutUnit(value), pixelSnappingFactor); }
+
</ins><span class="cx"> inline LayoutUnit absoluteValue(const LayoutUnit& value)
</span><span class="cx"> {
</span><span class="cx">     return value.abs();
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformanimationAnimationUtilitiesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/animation/AnimationUtilities.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/animation/AnimationUtilities.h     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/platform/animation/AnimationUtilities.h        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -53,7 +53,7 @@
</span><span class="cx"> 
</span><span class="cx"> inline LayoutUnit blend(LayoutUnit from, LayoutUnit to, double progress)
</span><span class="cx"> {  
</span><del>-    return from + (to - from) * progress;
</del><ins>+    return LayoutUnit(from + (to - from) * progress);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> inline IntPoint blend(const IntPoint& from, const IntPoint& to, double progress)
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformcocoaScrollSnapAnimatorStatemm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/platform/cocoa/ScrollSnapAnimatorState.mm      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -96,7 +96,7 @@
</span><span class="cx">         return clampTo<float>(startOffset, 0, maxScrollOffset);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    float targetOffset = closestSnapOffset(snapOffsets, snapOffsetRanges, predictedOffset / pageScale, initialDelta, outActiveSnapIndex);
</del><ins>+    float targetOffset = closestSnapOffset(snapOffsets, snapOffsetRanges, LayoutUnit(predictedOffset / pageScale), initialDelta, outActiveSnapIndex);
</ins><span class="cx">     float minimumTargetOffset = std::max<float>(0, snapOffsets.first());
</span><span class="cx">     float maximumTargetOffset = std::min<float>(maxScrollOffset, snapOffsets.last());
</span><span class="cx">     targetOffset = clampTo<float>(targetOffset, minimumTargetOffset, maximumTargetOffset);
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsLayoutPointh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/graphics/LayoutPoint.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/LayoutPoint.h     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/platform/graphics/LayoutPoint.h        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -38,7 +38,7 @@
</span><span class="cx"> class LayoutPoint {
</span><span class="cx"> public:
</span><span class="cx">     LayoutPoint() : m_x(0), m_y(0) { }
</span><del>-    LayoutPoint(LayoutUnit x, LayoutUnit y) : m_x(x), m_y(y) { }
</del><ins>+    template<typename T, typename U> LayoutPoint(T x, U y) : m_x(x), m_y(y) { }
</ins><span class="cx">     LayoutPoint(const IntPoint& point) : m_x(point.x()), m_y(point.y()) { }
</span><span class="cx">     explicit LayoutPoint(const FloatPoint& size) : m_x(size.x()), m_y(size.y()) { }
</span><span class="cx">     explicit LayoutPoint(const LayoutSize& size) : m_x(size.width()), m_y(size.height()) { }
</span><span class="lines">@@ -48,12 +48,12 @@
</span><span class="cx">     LayoutUnit x() const { return m_x; }
</span><span class="cx">     LayoutUnit y() const { return m_y; }
</span><span class="cx"> 
</span><del>-    void setX(LayoutUnit x) { m_x = x; }
-    void setY(LayoutUnit y) { m_y = y; }
</del><ins>+    template<typename T> void setX(T x) { m_x = x; }
+    template<typename T> void setY(T y) { m_y = y; }
</ins><span class="cx"> 
</span><span class="cx">     void move(const LayoutSize& s) { move(s.width(), s.height()); } 
</span><span class="cx">     void moveBy(const LayoutPoint& offset) { move(offset.x(), offset.y()); }
</span><del>-    void move(LayoutUnit dx, LayoutUnit dy) { m_x += dx; m_y += dy; }
</del><ins>+    template<typename T, typename U> void move(T dx, U dy) { m_x += dx; m_y += dy; }
</ins><span class="cx">     
</span><span class="cx">     void scale(float s)
</span><span class="cx">     {
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsLayoutRecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/graphics/LayoutRect.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/LayoutRect.h      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/platform/graphics/LayoutRect.h 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -47,7 +47,8 @@
</span><span class="cx">     LayoutRect() { }
</span><span class="cx">     LayoutRect(const LayoutPoint& location, const LayoutSize& size)
</span><span class="cx">         : m_location(location), m_size(size) { }
</span><del>-    LayoutRect(LayoutUnit x, LayoutUnit y, LayoutUnit width, LayoutUnit height)
</del><ins>+    template<typename T1, typename T2, typename U1, typename U2>
+    LayoutRect(T1 x, T2 y, U1 width, U2 height)
</ins><span class="cx">         : m_location(LayoutPoint(x, y)), m_size(LayoutSize(width, height)) { }
</span><span class="cx">     LayoutRect(const LayoutPoint& topLeft, const LayoutPoint& bottomRight)
</span><span class="cx">         : m_location(topLeft), m_size(LayoutSize(bottomRight.x() - topLeft.x(), bottomRight.y() - topLeft.y())) { }
</span><span class="lines">@@ -70,10 +71,10 @@
</span><span class="cx">     LayoutUnit width() const { return m_size.width(); }
</span><span class="cx">     LayoutUnit height() const { return m_size.height(); }
</span><span class="cx"> 
</span><del>-    void setX(LayoutUnit x) { m_location.setX(x); }
-    void setY(LayoutUnit y) { m_location.setY(y); }
-    void setWidth(LayoutUnit width) { m_size.setWidth(width); }
-    void setHeight(LayoutUnit height) { m_size.setHeight(height); }
</del><ins>+    template<typename T> void setX(T x) { m_location.setX(x); }
+    template<typename T> void setY(T y) { m_location.setY(y); }
+    template<typename T> void setWidth(T width) { m_size.setWidth(width); }
+    template<typename T> void setHeight(T height) { m_size.setHeight(height); }
</ins><span class="cx"> 
</span><span class="cx">     bool isEmpty() const { return m_size.isEmpty(); }
</span><span class="cx"> 
</span><span class="lines">@@ -83,7 +84,7 @@
</span><span class="cx"> 
</span><span class="cx">     void move(const LayoutSize& size) { m_location += size; } 
</span><span class="cx">     void moveBy(const LayoutPoint& offset) { m_location.move(offset.x(), offset.y()); }
</span><del>-    void move(LayoutUnit dx, LayoutUnit dy) { m_location.move(dx, dy); } 
</del><ins>+    template<typename T, typename U> void move(T dx, U dy) { m_location.move(dx, dy); }
</ins><span class="cx"> 
</span><span class="cx">     void expand(const LayoutSize& size) { m_size += size; }
</span><span class="cx">     void expand(const LayoutBoxExtent& box)
</span><span class="lines">@@ -91,7 +92,7 @@
</span><span class="cx">         m_location.move(-box.left(), -box.top());
</span><span class="cx">         m_size.expand(box.left() + box.right(), box.top() + box.bottom());
</span><span class="cx">     }
</span><del>-    void expand(LayoutUnit dw, LayoutUnit dh) { m_size.expand(dw, dh); }
</del><ins>+    template<typename T, typename U> void expand(T dw, U dh) { m_size.expand(dw, dh); }
</ins><span class="cx">     void contract(const LayoutSize& size) { m_size -= size; }
</span><span class="cx">     void contract(const LayoutBoxExtent& box)
</span><span class="cx">     {
</span><span class="lines">@@ -98,7 +99,7 @@
</span><span class="cx">         m_location.move(box.left(), box.top());
</span><span class="cx">         m_size.shrink(box.left() + box.right(), box.top() + box.bottom());
</span><span class="cx">     }
</span><del>-    void contract(LayoutUnit dw, LayoutUnit dh) { m_size.expand(-dw, -dh); }
</del><ins>+    template<typename T, typename U> void contract(T dw, U dh) { m_size.expand(-dw, -dh); }
</ins><span class="cx"> 
</span><span class="cx">     void shiftXEdgeTo(LayoutUnit edge)
</span><span class="cx">     {
</span><span class="lines">@@ -123,6 +124,11 @@
</span><span class="cx">         setHeight(std::max<LayoutUnit>(0, height() + delta));
</span><span class="cx">     }
</span><span class="cx"> 
</span><ins>+    template<typename T> void shiftXEdgeTo(T edge) { shiftXEdgeTo(LayoutUnit(edge)); }
+    template<typename T> void shiftMaxXEdgeTo(T edge) { shiftMaxXEdgeTo(LayoutUnit(edge)); }
+    template<typename T> void shiftYEdgeTo(T edge) { shiftYEdgeTo(LayoutUnit(edge)); }
+    template<typename T> void shiftMaxYEdgeTo(T edge) { shiftMaxYEdgeTo(LayoutUnit(edge)); }
+
</ins><span class="cx">     LayoutPoint minXMinYCorner() const { return m_location; } // typically topLeft
</span><span class="cx">     LayoutPoint maxXMinYCorner() const { return LayoutPoint(m_location.x() + m_size.width(), m_location.y()); } // typically topRight
</span><span class="cx">     LayoutPoint minXMaxYCorner() const { return LayoutPoint(m_location.x(), m_location.y() + m_size.height()); } // typically bottomLeft
</span><span class="lines">@@ -160,8 +166,11 @@
</span><span class="cx">         m_location.setY(m_location.y() - dy);
</span><span class="cx">         m_size.setHeight(m_size.height() + dy + dy);
</span><span class="cx">     }
</span><del>-    void inflate(LayoutUnit d) { inflateX(d); inflateY(d); }
</del><span class="cx">     void inflate(LayoutSize size) { inflateX(size.width()); inflateY(size.height()); }
</span><ins>+    template<typename T> void inflateX(T dx) { inflateX(LayoutUnit(dx)); }
+    template<typename T> void inflateY(T dy) { inflateY(LayoutUnit(dy)); }
+    template<typename T> void inflate(T d) { inflateX(d); inflateY(d); }
+
</ins><span class="cx">     WEBCORE_EXPORT void scale(float);
</span><span class="cx">     void scale(float xScale, float yScale);
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsLayoutSizeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/graphics/LayoutSize.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/LayoutSize.h      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/platform/graphics/LayoutSize.h 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -51,7 +51,7 @@
</span><span class="cx"> public:
</span><span class="cx">     LayoutSize() : m_width(0), m_height(0) { }
</span><span class="cx">     LayoutSize(const IntSize& size) : m_width(size.width()), m_height(size.height()) { }
</span><del>-    LayoutSize(LayoutUnit width, LayoutUnit height) : m_width(width), m_height(height) { }
</del><ins>+    template<typename T, typename U> LayoutSize(T width, U height) : m_width(width), m_height(height) { }
</ins><span class="cx"> 
</span><span class="cx">     explicit LayoutSize(const FloatSize& size) : m_width(size.width()), m_height(size.height()) { }
</span><span class="cx">     
</span><span class="lines">@@ -58,8 +58,8 @@
</span><span class="cx">     LayoutUnit width() const { return m_width; }
</span><span class="cx">     LayoutUnit height() const { return m_height; }
</span><span class="cx"> 
</span><del>-    void setWidth(LayoutUnit width) { m_width = width; }
-    void setHeight(LayoutUnit height) { m_height = height; }
</del><ins>+    template<typename T> void setWidth(T width) { m_width = width; }
+    template<typename T> void setHeight(T height) { m_height = height; }
</ins><span class="cx"> 
</span><span class="cx">     bool isEmpty() const { return m_width <= 0 || m_height <= 0; }
</span><span class="cx">     bool isZero() const { return !m_width && !m_height; }
</span><span class="lines">@@ -66,7 +66,8 @@
</span><span class="cx"> 
</span><span class="cx">     float aspectRatio() const { return static_cast<float>(m_width) / static_cast<float>(m_height); }
</span><span class="cx">     
</span><del>-    void expand(LayoutUnit width, LayoutUnit height)
</del><ins>+    template<typename T, typename U>
+    void expand(T width, U height)
</ins><span class="cx">     {
</span><span class="cx">         m_width += width;
</span><span class="cx">         m_height += height;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingBorderEdgecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/BorderEdge.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/BorderEdge.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/BorderEdge.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -87,7 +87,7 @@
</span><span class="cx"> 
</span><span class="cx"> void BorderEdge::getDoubleBorderStripeWidths(LayoutUnit& outerWidth, LayoutUnit& innerWidth) const
</span><span class="cx"> {
</span><del>-    LayoutUnit fullWidth = widthForPainting();
</del><ins>+    LayoutUnit fullWidth { widthForPainting() };
</ins><span class="cx">     innerWidth = ceilToDevicePixel(fullWidth * 2 / 3, m_devicePixelRatio);
</span><span class="cx">     outerWidth = floorToDevicePixel(fullWidth / 3, m_devicePixelRatio);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingEllipsisBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/EllipsisBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/EllipsisBox.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/EllipsisBox.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -118,7 +118,7 @@
</span><span class="cx">     const FontCascade& font = lineStyle.fontCascade();
</span><span class="cx">     const RootInlineBox& rootBox = root();
</span><span class="cx">     // FIXME: Why is this always LTR? Fix by passing correct text run flags below.
</span><del>-    LayoutRect selectionRect = LayoutRect(x(), y() + rootBox.selectionTopAdjustedForPrecedingBlock(), 0_lu, rootBox.selectionHeightAdjustedForPrecedingBlock());
</del><ins>+    LayoutRect selectionRect { LayoutUnit(x()), LayoutUnit(y() + rootBox.selectionTopAdjustedForPrecedingBlock()), 0_lu, rootBox.selectionHeightAdjustedForPrecedingBlock() };
</ins><span class="cx">     font.adjustSelectionRectForText(RenderBlock::constructTextRun(m_str, lineStyle, AllowTrailingExpansion), selectionRect);
</span><span class="cx">     // FIXME: use directional pixel snapping instead.
</span><span class="cx">     return enclosingIntRect(selectionRect);
</span><span class="lines">@@ -139,7 +139,7 @@
</span><span class="cx">     const RootInlineBox& rootBox = root();
</span><span class="cx">     GraphicsContextStateSaver stateSaver(context);
</span><span class="cx">     // FIXME: Why is this always LTR? Fix by passing correct text run flags below.
</span><del>-    LayoutRect selectionRect = LayoutRect(x() + paintOffset.x(), y() + paintOffset.y() + rootBox.selectionTop(), 0_lu, rootBox.selectionHeight());
</del><ins>+    LayoutRect selectionRect { LayoutUnit(x() + paintOffset.x()), LayoutUnit(y() + paintOffset.y() + rootBox.selectionTop()), 0_lu, rootBox.selectionHeight() };
</ins><span class="cx">     TextRun run = RenderBlock::constructTextRun(m_str, style, AllowTrailingExpansion);
</span><span class="cx">     font.adjustSelectionRectForText(run, selectionRect);
</span><span class="cx">     context.fillRect(snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), run.ltr()), c);
</span><span class="lines">@@ -152,8 +152,8 @@
</span><span class="cx">     // Hit test the markup box.
</span><span class="cx">     if (InlineBox* markupBox = this->markupBox()) {
</span><span class="cx">         const RenderStyle& lineStyle = this->lineStyle();
</span><del>-        LayoutUnit mtx = adjustedLocation.x() + logicalWidth() - markupBox->x();
-        LayoutUnit mty = adjustedLocation.y() + lineStyle.fontMetrics().ascent() - (markupBox->y() + markupBox->lineStyle().fontMetrics().ascent());
</del><ins>+        LayoutUnit mtx { adjustedLocation.x() + logicalWidth() - markupBox->x() };
+        LayoutUnit mty { adjustedLocation.y() + lineStyle.fontMetrics().ascent() - (markupBox->y() + markupBox->lineStyle().fontMetrics().ascent()) };
</ins><span class="cx">         if (markupBox->nodeAtPoint(request, result, locationInContainer, LayoutPoint(mtx, mty), lineTop, lineBottom, hitTestAction)) {
</span><span class="cx">             blockFlow().updateHitTestResult(result, locationInContainer.point() - LayoutSize(mtx, mty));
</span><span class="cx">             return true;
</span><span class="lines">@@ -160,7 +160,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    LayoutRect boundsRect(adjustedLocation, LayoutSize(logicalWidth(), m_height));
</del><ins>+    LayoutRect boundsRect { adjustedLocation, LayoutSize(LayoutUnit(logicalWidth()), m_height) };
</ins><span class="cx">     if (visibleToHitTesting() && boundsRect.intersects(HitTestLocation::rectForPoint(locationInContainer.point(), 0, 0, 0, 0))) {
</span><span class="cx">         blockFlow().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));
</span><span class="cx">         if (result.addNodeToListBasedTestResult(blockFlow().element(), request, locationInContainer, boundsRect) == HitTestProgress::Stop)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingFixedTableLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/FixedTableLayout.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/FixedTableLayout.cpp      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/FixedTableLayout.cpp 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -302,12 +302,12 @@
</span><span class="cx">     
</span><span class="cx">     float pos = 0;
</span><span class="cx">     for (unsigned i = 0; i < nEffCols; i++) {
</span><del>-        m_table->setColumnPosition(i, pos);
</del><ins>+        m_table->setColumnPosition(i, LayoutUnit(pos));
</ins><span class="cx">         pos += calcWidth[i] + hspacing;
</span><span class="cx">     }
</span><span class="cx">     float colPositionsSize = m_table->columnPositions().size();
</span><span class="cx">     if (colPositionsSize > 0)
</span><del>-        m_table->setColumnPosition(colPositionsSize - 1, pos);
</del><ins>+        m_table->setColumnPosition(colPositionsSize - 1, LayoutUnit(pos));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingInlineBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/InlineBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/InlineBox.cpp     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/InlineBox.cpp        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -184,7 +184,7 @@
</span><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     if (m_renderer.isReplaced())
</span><del>-        downcast<RenderBox>(renderer()).move(dx, dy);
</del><ins>+        downcast<RenderBox>(renderer()).move(LayoutUnit(dx), LayoutUnit(dy));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> const RootInlineBox& InlineBox::root() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingInlineFlowBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/InlineFlowBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/InlineFlowBox.cpp 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/InlineFlowBox.cpp    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -265,7 +265,7 @@
</span><span class="cx">     for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
</span><span class="cx">         child->adjustPosition(dx, dy);
</span><span class="cx">     if (m_overflow)
</span><del>-        m_overflow->move(dx, dy); // FIXME: Rounding error here since overflow was pixel snapped, but nobody other than list markers passes non-integral values here.
</del><ins>+        m_overflow->move(LayoutUnit(dx), LayoutUnit(dy)); // FIXME: Rounding error here since overflow was pixel snapped, but nobody other than list markers passes non-integral values here.
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> static inline bool isLastChildForRenderer(const RenderElement& ancestor, const RenderObject* child)
</span><span class="lines">@@ -658,9 +658,9 @@
</span><span class="cx">             child->setLogicalTop(child->logicalTop() + top + posAdjust);
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        LayoutUnit newLogicalTop = child->logicalTop();
</del><ins>+        LayoutUnit newLogicalTop { child->logicalTop() };
</ins><span class="cx">         LayoutUnit newLogicalTopIncludingMargins = newLogicalTop;
</span><del>-        LayoutUnit boxHeight = child->logicalHeight();
</del><ins>+        LayoutUnit boxHeight { child->logicalHeight() };
</ins><span class="cx">         LayoutUnit boxHeightIncludingMargins = boxHeight;
</span><span class="cx"> 
</span><span class="cx">         const RenderStyle& childLineStyle = child->lineStyle();
</span><span class="lines">@@ -698,7 +698,7 @@
</span><span class="cx"> 
</span><span class="cx">                 auto& rubyRun = downcast<RenderRubyRun>(child->renderer());
</span><span class="cx">                 if (RenderRubyBase* rubyBase = rubyRun.rubyBase()) {
</span><del>-                    LayoutUnit bottomRubyBaseLeading = (child->logicalHeight() - rubyBase->logicalBottom()) + rubyBase->logicalHeight() - (rubyBase->lastRootBox() ? rubyBase->lastRootBox()->lineBottom() : 0_lu);
</del><ins>+                    LayoutUnit bottomRubyBaseLeading { (child->logicalHeight() - rubyBase->logicalBottom()) + rubyBase->logicalHeight() - (rubyBase->lastRootBox() ? rubyBase->lastRootBox()->lineBottom() : 0_lu) };
</ins><span class="cx">                     LayoutUnit topRubyBaseLeading = rubyBase->logicalTop() + (rubyBase->firstRootBox() ? rubyBase->firstRootBox()->lineTop() : 0_lu);
</span><span class="cx">                     newLogicalTop += !renderer().style().isFlippedLinesWritingMode() ? topRubyBaseLeading : bottomRubyBaseLeading;
</span><span class="cx">                     boxHeight -= (topRubyBaseLeading + bottomRubyBaseLeading);
</span><span class="lines">@@ -739,10 +739,10 @@
</span><span class="cx">                 lineTop = logicalTop();
</span><span class="cx">                 lineTopIncludingMargins = lineTop;
</span><span class="cx">             } else {
</span><del>-                lineTop = std::min<LayoutUnit>(lineTop, logicalTop());
</del><ins>+                lineTop = std::min(lineTop, LayoutUnit(logicalTop()));
</ins><span class="cx">                 lineTopIncludingMargins = std::min(lineTop, lineTopIncludingMargins);
</span><span class="cx">             }
</span><del>-            lineBottom = std::max<LayoutUnit>(lineBottom, logicalBottom());
</del><ins>+            lineBottom = std::max(lineBottom, LayoutUnit(logicalBottom()));
</ins><span class="cx">             lineBottomIncludingMargins = std::max(lineBottom, lineBottomIncludingMargins);
</span><span class="cx">         }
</span><span class="cx">         
</span><span class="lines">@@ -828,15 +828,15 @@
</span><span class="cx">     LayoutUnit shadowLogicalTop = lineStyle.isFlippedLinesWritingMode() ? -boxShadowLogicalBottom : boxShadowLogicalTop;
</span><span class="cx">     LayoutUnit shadowLogicalBottom = lineStyle.isFlippedLinesWritingMode() ? -boxShadowLogicalTop : boxShadowLogicalBottom;
</span><span class="cx">     
</span><del>-    LayoutUnit logicalTopVisualOverflow = std::min<LayoutUnit>(logicalTop() + shadowLogicalTop, logicalVisualOverflow.y());
-    LayoutUnit logicalBottomVisualOverflow = std::max<LayoutUnit>(logicalBottom() + shadowLogicalBottom, logicalVisualOverflow.maxY());
</del><ins>+    LayoutUnit logicalTopVisualOverflow = std::min(LayoutUnit(logicalTop() + shadowLogicalTop), logicalVisualOverflow.y());
+    LayoutUnit logicalBottomVisualOverflow = std::max(LayoutUnit(logicalBottom() + shadowLogicalBottom), logicalVisualOverflow.maxY());
</ins><span class="cx">     
</span><span class="cx">     LayoutUnit boxShadowLogicalLeft;
</span><span class="cx">     LayoutUnit boxShadowLogicalRight;
</span><span class="cx">     lineStyle.getBoxShadowInlineDirectionExtent(boxShadowLogicalLeft, boxShadowLogicalRight);
</span><span class="cx"> 
</span><del>-    LayoutUnit logicalLeftVisualOverflow = std::min<LayoutUnit>(logicalLeft() + boxShadowLogicalLeft, logicalVisualOverflow.x());
-    LayoutUnit logicalRightVisualOverflow = std::max<LayoutUnit>(logicalRight() + boxShadowLogicalRight, logicalVisualOverflow.maxX());
</del><ins>+    LayoutUnit logicalLeftVisualOverflow = std::min(LayoutUnit(logicalLeft() + boxShadowLogicalLeft), logicalVisualOverflow.x());
+    LayoutUnit logicalRightVisualOverflow = std::max(LayoutUnit(logicalRight() + boxShadowLogicalRight), logicalVisualOverflow.maxX());
</ins><span class="cx">     
</span><span class="cx">     logicalVisualOverflow = LayoutRect(logicalLeftVisualOverflow, logicalTopVisualOverflow,
</span><span class="cx">                                        logicalRightVisualOverflow - logicalLeftVisualOverflow, logicalBottomVisualOverflow - logicalTopVisualOverflow);
</span><span class="lines">@@ -864,14 +864,14 @@
</span><span class="cx">     LayoutUnit outsetLogicalTop = lineStyle.isFlippedLinesWritingMode() ? borderOutsetLogicalBottom : borderOutsetLogicalTop;
</span><span class="cx">     LayoutUnit outsetLogicalBottom = lineStyle.isFlippedLinesWritingMode() ? borderOutsetLogicalTop : borderOutsetLogicalBottom;
</span><span class="cx"> 
</span><del>-    LayoutUnit logicalTopVisualOverflow = std::min<LayoutUnit>(logicalTop() - outsetLogicalTop, logicalVisualOverflow.y());
-    LayoutUnit logicalBottomVisualOverflow = std::max<LayoutUnit>(logicalBottom() + outsetLogicalBottom, logicalVisualOverflow.maxY());
</del><ins>+    LayoutUnit logicalTopVisualOverflow = std::min(LayoutUnit(logicalTop() - outsetLogicalTop), logicalVisualOverflow.y());
+    LayoutUnit logicalBottomVisualOverflow = std::max(LayoutUnit(logicalBottom() + outsetLogicalBottom), logicalVisualOverflow.maxY());
</ins><span class="cx"> 
</span><span class="cx">     LayoutUnit outsetLogicalLeft = includeLogicalLeftEdge() ? borderOutsetLogicalLeft : 0_lu;
</span><span class="cx">     LayoutUnit outsetLogicalRight = includeLogicalRightEdge() ? borderOutsetLogicalRight : 0_lu;
</span><span class="cx"> 
</span><del>-    LayoutUnit logicalLeftVisualOverflow = std::min<LayoutUnit>(logicalLeft() - outsetLogicalLeft, logicalVisualOverflow.x());
-    LayoutUnit logicalRightVisualOverflow = std::max<LayoutUnit>(logicalRight() + outsetLogicalRight, logicalVisualOverflow.maxX());
</del><ins>+    LayoutUnit logicalLeftVisualOverflow = std::min(LayoutUnit(logicalLeft() - outsetLogicalLeft), logicalVisualOverflow.x());
+    LayoutUnit logicalRightVisualOverflow = std::max(LayoutUnit(logicalRight() + outsetLogicalRight), logicalVisualOverflow.maxX());
</ins><span class="cx">     
</span><span class="cx">     logicalVisualOverflow = LayoutRect(logicalLeftVisualOverflow, logicalTopVisualOverflow,
</span><span class="cx">                                        logicalRightVisualOverflow - logicalLeftVisualOverflow, logicalBottomVisualOverflow - logicalTopVisualOverflow);
</span><span class="lines">@@ -926,10 +926,10 @@
</span><span class="cx">     LayoutUnit childOverflowLogicalLeft = std::min<LayoutUnit>(textShadowLogicalLeft + leftGlyphOverflow, leftGlyphOverflow);
</span><span class="cx">     LayoutUnit childOverflowLogicalRight = std::max<LayoutUnit>(textShadowLogicalRight + rightGlyphOverflow, rightGlyphOverflow);
</span><span class="cx"> 
</span><del>-    LayoutUnit logicalTopVisualOverflow = std::min<LayoutUnit>(textBox.logicalTop() + childOverflowLogicalTop, logicalVisualOverflow.y());
-    LayoutUnit logicalBottomVisualOverflow = std::max<LayoutUnit>(textBox.logicalBottom() + childOverflowLogicalBottom, logicalVisualOverflow.maxY());
-    LayoutUnit logicalLeftVisualOverflow = std::min<LayoutUnit>(textBox.logicalLeft() + childOverflowLogicalLeft, logicalVisualOverflow.x());
-    LayoutUnit logicalRightVisualOverflow = std::max<LayoutUnit>(textBox.logicalRight() + childOverflowLogicalRight, logicalVisualOverflow.maxX());
</del><ins>+    LayoutUnit logicalTopVisualOverflow = std::min(LayoutUnit(textBox.logicalTop() + childOverflowLogicalTop), logicalVisualOverflow.y());
+    LayoutUnit logicalBottomVisualOverflow = std::max(LayoutUnit(textBox.logicalBottom() + childOverflowLogicalBottom), logicalVisualOverflow.maxY());
+    LayoutUnit logicalLeftVisualOverflow = std::min(LayoutUnit(textBox.logicalLeft() + childOverflowLogicalLeft), logicalVisualOverflow.x());
+    LayoutUnit logicalRightVisualOverflow = std::max(LayoutUnit(textBox.logicalRight() + childOverflowLogicalRight), logicalVisualOverflow.maxX());
</ins><span class="cx">     
</span><span class="cx">     logicalVisualOverflow = LayoutRect(logicalLeftVisualOverflow, logicalTopVisualOverflow,
</span><span class="cx">                                        logicalRightVisualOverflow - logicalLeftVisualOverflow, logicalBottomVisualOverflow - logicalTopVisualOverflow);
</span><span class="lines">@@ -946,7 +946,7 @@
</span><span class="cx">     const auto& lineStyle = this->lineStyle();
</span><span class="cx">     if (!lineStyle.hasOutlineInVisualOverflow())
</span><span class="cx">         return;
</span><del>-    LayoutUnit outlineSize = lineStyle.outlineSize();
</del><ins>+    LayoutUnit outlineSize { lineStyle.outlineSize() };
</ins><span class="cx">     LayoutUnit logicalTopVisualOverflow = std::min(LayoutUnit(logicalTop() - outlineSize), logicalVisualOverflow.y());
</span><span class="cx">     LayoutUnit logicalBottomVisualOverflow = std::max(LayoutUnit(logicalBottom() + outlineSize), logicalVisualOverflow.maxY());
</span><span class="cx">     LayoutUnit logicalLeftVisualOverflow = std::min(LayoutUnit(logicalLeft() - outlineSize), logicalVisualOverflow.x());
</span><span class="lines">@@ -1127,8 +1127,8 @@
</span><span class="cx">     bool noQuirksMode = renderer().document().inNoQuirksMode();
</span><span class="cx">     if (!noQuirksMode && !hasTextChildren() && !(descendantsHaveSameLineHeightAndBaseline() && hasTextDescendants())) {
</span><span class="cx">         RootInlineBox& rootBox = root();
</span><del>-        LayoutUnit top = isHorizontal() ? y() : x();
-        LayoutUnit logicalHeight = isHorizontal() ? height() : width();
</del><ins>+        LayoutUnit top { isHorizontal() ? y() : x()};
+        LayoutUnit logicalHeight { isHorizontal() ? height() : width() };
</ins><span class="cx">         LayoutUnit bottom = std::min(rootBox.lineBottom(), top + logicalHeight);
</span><span class="cx">         top = std::max(rootBox.lineTop(), top);
</span><span class="cx">         logicalHeight = bottom - top;
</span><span class="lines">@@ -1247,7 +1247,7 @@
</span><span class="cx"> #if ENABLE(CSS_BOX_DECORATION_BREAK)
</span><span class="cx">     else if (renderer().style().boxDecorationBreak() == BoxDecorationBreak::Clone) {
</span><span class="cx">         GraphicsContextStateSaver stateSaver(paintInfo.context());
</span><del>-        paintInfo.context().clip(LayoutRect(rect.x(), rect.y(), width(), height()));
</del><ins>+        paintInfo.context().clip({ rect.x(), rect.y(), LayoutUnit(width()), LayoutUnit(height()) });
</ins><span class="cx">         renderer().paintFillLayerExtended(paintInfo, color, fillLayer, rect, BackgroundBleedNone, this, rect.size(), op);
</span><span class="cx">     }
</span><span class="cx"> #endif
</span><span class="lines">@@ -1279,7 +1279,7 @@
</span><span class="cx">         LayoutUnit stripHeight = isHorizontal() ? LayoutUnit(height()) : totalLogicalWidth;
</span><span class="cx"> 
</span><span class="cx">         GraphicsContextStateSaver stateSaver(paintInfo.context());
</span><del>-        paintInfo.context().clip(LayoutRect(rect.x(), rect.y(), width(), height()));
</del><ins>+        paintInfo.context().clip({ rect.x(), rect.y(), LayoutUnit(width()), LayoutUnit(height()) });
</ins><span class="cx">         renderer().paintFillLayerExtended(paintInfo, color, fillLayer, LayoutRect(stripX, stripY, stripWidth, stripHeight), BackgroundBleedNone, this, rect.size(), op);
</span><span class="cx">     }
</span><span class="cx"> }
</span><span class="lines">@@ -1642,10 +1642,10 @@
</span><span class="cx">             Optional<bool> markExistsAndIsAbove = downcast<InlineTextBox>(*child).emphasisMarkExistsAndIsAbove(childLineStyle);
</span><span class="cx">             if (markExistsAndIsAbove && !*markExistsAndIsAbove) {
</span><span class="cx">                 if (!childLineStyle.isFlippedLinesWritingMode()) {
</span><del>-                    LayoutUnit bottomOfEmphasisMark = child->logicalBottom() + childLineStyle.fontCascade().emphasisMarkHeight(childLineStyle.textEmphasisMarkString());
</del><ins>+                    LayoutUnit bottomOfEmphasisMark { child->logicalBottom() + childLineStyle.fontCascade().emphasisMarkHeight(childLineStyle.textEmphasisMarkString()) };
</ins><span class="cx">                     result = std::max(result, bottomOfEmphasisMark - allowedPosition);
</span><span class="cx">                 } else {
</span><del>-                    LayoutUnit topOfEmphasisMark = child->logicalTop() - childLineStyle.fontCascade().emphasisMarkHeight(childLineStyle.textEmphasisMarkString());
</del><ins>+                    LayoutUnit topOfEmphasisMark { child->logicalTop() - childLineStyle.fontCascade().emphasisMarkHeight(childLineStyle.textEmphasisMarkString()) };
</ins><span class="cx">                     result = std::max(result, allowedPosition - topOfEmphasisMark);
</span><span class="cx">                 }
</span><span class="cx">             }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingInlineFlowBoxh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/InlineFlowBox.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/InlineFlowBox.h   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/InlineFlowBox.h      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -124,8 +124,8 @@
</span><span class="cx">     bool boxShadowCanBeAppliedToBackground(const FillLayer&) const;
</span><span class="cx"> 
</span><span class="cx">     // logicalLeft = left in a horizontal line and top in a vertical line.
</span><del>-    LayoutUnit marginBorderPaddingLogicalLeft() const { return marginLogicalLeft() + borderLogicalLeft() + paddingLogicalLeft(); }
-    LayoutUnit marginBorderPaddingLogicalRight() const { return marginLogicalRight() + borderLogicalRight() + paddingLogicalRight(); }
</del><ins>+    LayoutUnit marginBorderPaddingLogicalLeft() const { return LayoutUnit(marginLogicalLeft() + borderLogicalLeft() + paddingLogicalLeft()); }
+    LayoutUnit marginBorderPaddingLogicalRight() const { return LayoutUnit(marginLogicalRight() + borderLogicalRight() + paddingLogicalRight()); }
</ins><span class="cx">     LayoutUnit marginLogicalLeft() const
</span><span class="cx">     {
</span><span class="cx">         if (!includeLogicalLeftEdge())
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingInlineTextBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/InlineTextBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/InlineTextBox.cpp 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/InlineTextBox.cpp    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -215,7 +215,7 @@
</span><span class="cx"> 
</span><span class="cx">     TextRun textRun = createTextRun();
</span><span class="cx"> 
</span><del>-    LayoutRect selectionRect = LayoutRect(LayoutPoint(logicalLeft(), selectionTop), LayoutSize(logicalWidth(), selectionHeight));
</del><ins>+    LayoutRect selectionRect { LayoutUnit(logicalLeft()), selectionTop, LayoutUnit(logicalWidth()), selectionHeight };
</ins><span class="cx">     // Avoid measuring the text when the entire line box is selected as an optimization.
</span><span class="cx">     if (sPos || ePos != textRun.length())
</span><span class="cx">         lineFont().adjustSelectionRectForText(textRun, selectionRect, sPos, ePos);
</span><span class="lines">@@ -347,7 +347,7 @@
</span><span class="cx">     FloatRect rect(locationIncludingFlipping(), size());
</span><span class="cx">     // Make sure truncated text is ignored while hittesting.
</span><span class="cx">     if (m_truncation != cNoTruncation) {
</span><del>-        LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
</del><ins>+        LayoutUnit widthOfVisibleText { renderer().width(m_start, m_truncation, textPos(), isFirstLine()) };
</ins><span class="cx"> 
</span><span class="cx">         if (isHorizontal())
</span><span class="cx">             renderer().style().isLeftToRightDirection() ? rect.setWidth(widthOfVisibleText) : rect.shiftXEdgeTo(right() - widthOfVisibleText);
</span><span class="lines">@@ -486,8 +486,8 @@
</span><span class="cx">             // farther to the right.
</span><span class="cx">             // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
</span><span class="cx">             // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
</span><del>-            LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isFirstLine());
-            LayoutUnit widthOfHiddenText = logicalWidth() - widthOfVisibleText;
</del><ins>+            LayoutUnit widthOfVisibleText { renderer().width(m_start, m_truncation, textPos(), isFirstLine()) };
+            LayoutUnit widthOfHiddenText { logicalWidth() - widthOfVisibleText };
</ins><span class="cx">             LayoutSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0_lu);
</span><span class="cx">             localPaintOffset.move(isHorizontal() ? truncationOffset : truncationOffset.transposedSize());
</span><span class="cx">         }
</span><span class="lines">@@ -1018,10 +1018,10 @@
</span><span class="cx"> 
</span><span class="cx">     // Use same y positioning and height as for selection, so that when the selection and this subrange are on
</span><span class="cx">     // the same word there are no pieces sticking out.
</span><del>-    LayoutUnit deltaY = renderer().style().isFlippedLinesWritingMode() ? selectionBottom - logicalBottom() : logicalTop() - selectionTop;
</del><ins>+    LayoutUnit deltaY { renderer().style().isFlippedLinesWritingMode() ? selectionBottom - logicalBottom() : logicalTop() - selectionTop };
</ins><span class="cx">     LayoutUnit selectionHeight = std::max<LayoutUnit>(0, selectionBottom - selectionTop);
</span><span class="cx"> 
</span><del>-    LayoutRect selectionRect = LayoutRect(boxOrigin.x(), boxOrigin.y() - deltaY, logicalWidth(), selectionHeight);
</del><ins>+    LayoutRect selectionRect { LayoutUnit(boxOrigin.x()), LayoutUnit(boxOrigin.y() - deltaY), LayoutUnit(logicalWidth()), selectionHeight };
</ins><span class="cx">     lineFont().adjustSelectionRectForText(textRun, selectionRect, clampedStartOffset, clampedEndOffset);
</span><span class="cx"> 
</span><span class="cx">     // FIXME: Support painting combined text. See <https://bugs.webkit.org/show_bug.cgi?id=180993>.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlock.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2856,8 +2856,8 @@
</span><span class="cx">         // FIXME: This is wrong for block-flows that are horizontal.
</span><span class="cx">         // https://bugs.webkit.org/show_bug.cgi?id=46781
</span><span class="cx">         bool prevInlineHasLineBox = downcast<RenderInline>(*inlineContinuation->element()->renderer()).firstLineBox();
</span><del>-        float topMargin = prevInlineHasLineBox ? collapsedMarginBefore() : 0_lu;
-        float bottomMargin = nextInlineHasLineBox ? collapsedMarginAfter() : 0_lu;
</del><ins>+        auto topMargin = prevInlineHasLineBox ? collapsedMarginBefore() : 0_lu;
+        auto bottomMargin = nextInlineHasLineBox ? collapsedMarginAfter() : 0_lu;
</ins><span class="cx">         LayoutRect rect(additionalOffset.x(), additionalOffset.y() - topMargin, width(), height() + topMargin + bottomMargin);
</span><span class="cx">         if (!rect.isEmpty())
</span><span class="cx">             rects.append(rect);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockFlowcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -388,7 +388,7 @@
</span><span class="cx"> 
</span><span class="cx">     LayoutUnit availWidth = desiredColumnWidth;
</span><span class="cx">     LayoutUnit colGap = columnGap();
</span><del>-    LayoutUnit colWidth = std::max<LayoutUnit>(1, style().columnWidth());
</del><ins>+    LayoutUnit colWidth = std::max(1_lu, LayoutUnit(style().columnWidth()));
</ins><span class="cx">     unsigned colCount = std::max<unsigned>(1, style().columnCount());
</span><span class="cx"> 
</span><span class="cx">     if (style().hasAutoColumnWidth() && !style().hasAutoColumnCount()) {
</span><span class="lines">@@ -3096,7 +3096,7 @@
</span><span class="cx">             selectionState() != SelectionStart && selectionState() != SelectionBoth && !isRubyBase())
</span><span class="cx">             result.uniteCenter(blockSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop, lastLogicalLeft, lastLogicalRight, selTop, cache, paintInfo));
</span><span class="cx">         
</span><del>-        LayoutRect logicalRect(curr->logicalLeft(), selTop, curr->logicalWidth(), selTop + selHeight);
</del><ins>+        LayoutRect logicalRect { LayoutUnit(curr->logicalLeft()), selTop, LayoutUnit(curr->logicalWidth()), selTop + selHeight };
</ins><span class="cx">         logicalRect.move(isHorizontalWritingMode() ? offsetFromRootBlock : offsetFromRootBlock.transposedSize());
</span><span class="cx">         LayoutRect physicalRect = rootBlock.logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
</span><span class="cx">         if (!paintInfo || (isHorizontalWritingMode() && physicalRect.y() < paintInfo->rect.maxY() && physicalRect.maxY() > paintInfo->rect.y())
</span><span class="lines">@@ -3412,7 +3412,7 @@
</span><span class="cx"> 
</span><span class="cx">     if (closestBox) {
</span><span class="cx">         if (moveCaretToBoundary) {
</span><del>-            LayoutUnit firstRootBoxWithChildrenTop = std::min<LayoutUnit>(firstRootBoxWithChildren->selectionTop(), firstRootBoxWithChildren->logicalTop());
</del><ins>+            LayoutUnit firstRootBoxWithChildrenTop = std::min(firstRootBoxWithChildren->selectionTop(), LayoutUnit(firstRootBoxWithChildren->logicalTop()));
</ins><span class="cx">             if (pointInLogicalContents.y() < firstRootBoxWithChildrenTop
</span><span class="cx">                 || (blocksAreFlipped && pointInLogicalContents.y() == firstRootBoxWithChildrenTop)) {
</span><span class="cx">                 InlineBox* box = firstRootBoxWithChildren->firstLeafChild();
</span><span class="lines">@@ -3465,9 +3465,9 @@
</span><span class="cx"> {
</span><span class="cx">     ASSERT(childrenInline());
</span><span class="cx">     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
</span><del>-        LayoutUnit top = std::max<LayoutUnit>(curr->lineTop(), curr->top());
-        LayoutUnit bottom = std::min<LayoutUnit>(curr->lineBottom(), curr->top() + curr->height());
-        LayoutRect rect(additionalOffset.x() + curr->x(), additionalOffset.y() + top, curr->width(), bottom - top);
</del><ins>+        LayoutUnit top = std::max(curr->lineTop(), LayoutUnit(curr->top()));
+        LayoutUnit bottom = std::min(curr->lineBottom(), LayoutUnit(curr->top() + curr->height()));
+        LayoutRect rect { LayoutUnit(additionalOffset.x() + curr->x()), additionalOffset.y() + top, LayoutUnit(curr->width()), bottom - top };
</ins><span class="cx">         if (!rect.isEmpty())
</span><span class="cx">             rects.append(rect);
</span><span class="cx">     }
</span><span class="lines">@@ -4228,7 +4228,7 @@
</span><span class="cx"> 
</span><span class="cx">                 // Add in text-indent. This is added in only once.
</span><span class="cx">                 if (!addedTextIndent && !child->isFloating()) {
</span><del>-                    LayoutUnit ceiledIndent = textIndent.ceilToFloat();
</del><ins>+                    LayoutUnit ceiledIndent { textIndent.ceilToFloat() };
</ins><span class="cx">                     childMin += ceiledIndent;
</span><span class="cx">                     childMax += ceiledIndent;
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockLineLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -446,8 +446,8 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx">     renderer.getOverhang(lineInfo.isFirstLine(), renderer.style().isLeftToRightDirection() ? previousObject : nextObject, renderer.style().isLeftToRightDirection() ? nextObject : previousObject, startOverhang, endOverhang);
</span><del>-    setMarginStartForChild(renderer, -startOverhang);
-    setMarginEndForChild(renderer, -endOverhang);
</del><ins>+    setMarginStartForChild(renderer, LayoutUnit(-startOverhang));
+    setMarginEndForChild(renderer, LayoutUnit(-endOverhang));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> static inline void setLogicalWidthForTextRun(RootInlineBox* lineBox, BidiRun* run, RenderText& renderer, float xPos, const LineInfo& lineInfo,
</span><span class="lines">@@ -568,7 +568,7 @@
</span><span class="cx">     float newBaseWidth = rubyRun.logicalWidth() + totalExpansion + marginStartForChild(rubyRun) + marginEndForChild(rubyRun);
</span><span class="cx">     float newRubyRunWidth = rubyRun.logicalWidth() + totalExpansion;
</span><span class="cx">     rubyBase.setInitialOffset((newRubyRunWidth - newBaseWidth) / 2);
</span><del>-    rubyRun.setOverrideContentLogicalWidth(newRubyRunWidth);
</del><ins>+    rubyRun.setOverrideContentLogicalWidth(LayoutUnit(newRubyRunWidth));
</ins><span class="cx">     rubyRun.setNeedsLayout(MarkOnlyThis);
</span><span class="cx">     rootBox.markDirty();
</span><span class="cx">     if (RenderRubyText* rubyText = rubyRun.rubyText()) {
</span><span class="lines">@@ -2143,14 +2143,14 @@
</span><span class="cx">         IndentTextOrNot shouldIndentText = firstLine ? IndentText : DoNotIndentText;
</span><span class="cx">         LayoutUnit blockRightEdge = logicalRightOffsetForLine(curr->lineTop(), shouldIndentText);
</span><span class="cx">         LayoutUnit blockLeftEdge = logicalLeftOffsetForLine(curr->lineTop(), shouldIndentText);
</span><del>-        LayoutUnit lineBoxEdge = ltr ? curr->x() + curr->logicalWidth() : curr->x();
</del><ins>+        LayoutUnit lineBoxEdge { ltr ? curr->x() + curr->logicalWidth() : curr->x() };
</ins><span class="cx">         if ((ltr && lineBoxEdge > blockRightEdge) || (!ltr && lineBoxEdge < blockLeftEdge)) {
</span><span class="cx">             // This line spills out of our box in the appropriate direction.  Now we need to see if the line
</span><span class="cx">             // can be truncated.  In order for truncation to be possible, the line must have sufficient space to
</span><span class="cx">             // accommodate our truncation string, and no replaced elements (images, tables) can overlap the ellipsis
</span><span class="cx">             // space.
</span><del>-            LayoutUnit width = firstLine ? firstLineEllipsisWidth : ellipsisWidth;
-            LayoutUnit blockEdge = ltr ? blockRightEdge : blockLeftEdge;
</del><ins>+            LayoutUnit width { firstLine ? firstLineEllipsisWidth : ellipsisWidth };
+            LayoutUnit blockEdge { ltr ? blockRightEdge : blockLeftEdge };
</ins><span class="cx">             if (curr->lineCanAccommodateEllipsis(ltr, blockEdge, lineBoxEdge, width)) {
</span><span class="cx">                 float totalLogicalWidth = curr->placeEllipsis(ellipsisStr, ltr, blockLeftEdge, blockRightEdge, width);
</span><span class="cx"> 
</span><span class="lines">@@ -2258,8 +2258,8 @@
</span><span class="cx">     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
</span><span class="cx"> 
</span><span class="cx">     if (!style().isLeftToRightDirection())
</span><del>-        return logicalWidth() - logicalLeft;
-    return logicalLeft;
</del><ins>+        return LayoutUnit(logicalWidth() - logicalLeft);
+    return LayoutUnit(logicalLeft);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderBlockFlow::updateFragmentForLine(RootInlineBox* lineBox) const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.cpp     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2144,7 +2144,7 @@
</span><span class="cx">             // just below the line box (as though all the inlines that came before us got
</span><span class="cx">             // wrapped in an anonymous block, which is what would have happened had we been
</span><span class="cx">             // in flow).  This value was cached in the y() of the box.
</span><del>-            layer()->setStaticBlockPosition(box.logicalTop());
</del><ins>+            layer()->setStaticBlockPosition(LayoutUnit(box.logicalTop()));
</ins><span class="cx">             if (style().hasStaticBlockPosition(box.isHorizontal()))
</span><span class="cx">                 setChildNeedsLayout(MarkOnlyThis); // Just mark the positioned object as needing layout, so it will update its position properly.
</span><span class="cx">         }
</span><span class="lines">@@ -2395,7 +2395,7 @@
</span><span class="cx">         computedValues.m_margins.m_start = minimumValueForLength(styleToUse.marginStart(), containerLogicalWidth);
</span><span class="cx">         computedValues.m_margins.m_end = minimumValueForLength(styleToUse.marginEnd(), containerLogicalWidth);
</span><span class="cx">         if (treatAsReplaced)
</span><del>-            computedValues.m_extent = std::max<LayoutUnit>(floatValueForLength(logicalWidthLength, 0) + borderAndPaddingLogicalWidth(), minPreferredLogicalWidth());
</del><ins>+            computedValues.m_extent = std::max(LayoutUnit(floatValueForLength(logicalWidthLength, 0) + borderAndPaddingLogicalWidth()), minPreferredLogicalWidth());
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -4568,7 +4568,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (outlineStyleForRepaint().hasOutlineInVisualOverflow()) {
</span><del>-        LayoutUnit outlineSize = outlineStyleForRepaint().outlineSize();
</del><ins>+        LayoutUnit outlineSize { outlineStyleForRepaint().outlineSize() };
</ins><span class="cx">         overflowMinX = std::min(overflowMinX, borderBox.x() - outlineSize);
</span><span class="cx">         overflowMaxX = std::max(overflowMaxX, borderBox.maxX() + outlineSize);
</span><span class="cx">         overflowMinY = std::min(overflowMinY, borderBox.y() - outlineSize);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.h       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBox.h  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -71,10 +71,10 @@
</span><span class="cx">     LayoutUnit top() const { return topLeftLocation().y(); }
</span><span class="cx">     LayoutUnit left() const { return topLeftLocation().x(); }
</span><span class="cx"> 
</span><del>-    void setX(LayoutUnit x) { m_frameRect.setX(x); }
-    void setY(LayoutUnit y) { m_frameRect.setY(y); }
-    void setWidth(LayoutUnit width) { m_frameRect.setWidth(width); }
-    void setHeight(LayoutUnit height) { m_frameRect.setHeight(height); }
</del><ins>+    template<typename T> void setX(T x) { m_frameRect.setX(x); }
+    template<typename T> void setY(T y) { m_frameRect.setY(y); }
+    template<typename T> void setWidth(T width) { m_frameRect.setWidth(width); }
+    template<typename T> void setHeight(T height) { m_frameRect.setHeight(height); }
</ins><span class="cx"> 
</span><span class="cx">     LayoutUnit logicalLeft() const { return style().isHorizontalWritingMode() ? x() : y(); }
</span><span class="cx">     LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); }
</span><span class="lines">@@ -336,6 +336,9 @@
</span><span class="cx">     LayoutUnit adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const;
</span><span class="cx">     LayoutUnit adjustContentBoxLogicalWidthForBoxSizing(LayoutUnit width) const;
</span><span class="cx"> 
</span><ins>+    template<typename T> LayoutUnit adjustBorderBoxLogicalWidthForBoxSizing(T width) const { return adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit(width)); }
+    template<typename T> LayoutUnit adjustContentBoxLogicalWidthForBoxSizing(T width) const { return adjustContentBoxLogicalWidthForBoxSizing(LayoutUnit(width)); }
+
</ins><span class="cx">     // Overridden by fieldsets to subtract out the intrinsic border.
</span><span class="cx">     virtual LayoutUnit adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const;
</span><span class="cx">     virtual LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(Optional<LayoutUnit> height) const;
</span><span class="lines">@@ -437,6 +440,9 @@
</span><span class="cx">     LayoutUnit computeReplacedLogicalHeightUsing(SizeType, Length height) const;
</span><span class="cx">     LayoutUnit computeReplacedLogicalHeightRespectingMinMaxHeight(LayoutUnit logicalHeight) const;
</span><span class="cx"> 
</span><ins>+    template<typename T> LayoutUnit computeReplacedLogicalWidthRespectingMinMaxWidth(T logicalWidth, ShouldComputePreferred shouldComputePreferred = ComputeActual) const { return computeReplacedLogicalWidthRespectingMinMaxWidth(LayoutUnit(logicalWidth), shouldComputePreferred); }
+    template<typename T> LayoutUnit computeReplacedLogicalHeightRespectingMinMaxHeight(T logicalHeight) const { return computeReplacedLogicalHeightRespectingMinMaxHeight(LayoutUnit(logicalHeight)); }
+
</ins><span class="cx">     virtual LayoutUnit computeReplacedLogicalWidth(ShouldComputePreferred  = ComputeActual) const;
</span><span class="cx">     virtual LayoutUnit computeReplacedLogicalHeight(Optional<LayoutUnit> estimatedUsedWidth = WTF::nullopt) const;
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxModelObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2083,10 +2083,10 @@
</span><span class="cx"> 
</span><span class="cx">         // Paint inner only
</span><span class="cx">         GraphicsContextStateSaver stateSaver(graphicsContext);
</span><del>-        LayoutUnit topWidth = edges[BSTop].widthForPainting() / 2;
-        LayoutUnit bottomWidth = edges[BSBottom].widthForPainting() / 2;
-        LayoutUnit leftWidth = edges[BSLeft].widthForPainting() / 2;
-        LayoutUnit rightWidth = edges[BSRight].widthForPainting() / 2;
</del><ins>+        LayoutUnit topWidth { edges[BSTop].widthForPainting() / 2 };
+        LayoutUnit bottomWidth { edges[BSBottom].widthForPainting() / 2 };
+        LayoutUnit leftWidth { edges[BSLeft].widthForPainting() / 2 };
+        LayoutUnit rightWidth { edges[BSRight].widthForPainting() / 2 };
</ins><span class="cx"> 
</span><span class="cx">         RoundedRect clipRect = style.getRoundedInnerBorderFor(borderRect,
</span><span class="cx">             topWidth, bottomWidth, leftWidth, rightWidth,
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxModelObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBoxModelObject.h    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.h       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -152,16 +152,16 @@
</span><span class="cx">     virtual LayoutUnit paddingStart() const { return computedCSSPaddingStart(); }
</span><span class="cx">     virtual LayoutUnit paddingEnd() const { return computedCSSPaddingEnd(); }
</span><span class="cx"> 
</span><del>-    virtual LayoutUnit borderTop() const { return style().borderTopWidth(); }
-    virtual LayoutUnit borderBottom() const { return style().borderBottomWidth(); }
-    virtual LayoutUnit borderLeft() const { return style().borderLeftWidth(); }
-    virtual LayoutUnit borderRight() const { return style().borderRightWidth(); }
</del><ins>+    virtual LayoutUnit borderTop() const { return LayoutUnit(style().borderTopWidth()); }
+    virtual LayoutUnit borderBottom() const { return LayoutUnit(style().borderBottomWidth()); }
+    virtual LayoutUnit borderLeft() const { return LayoutUnit(style().borderLeftWidth()); }
+    virtual LayoutUnit borderRight() const { return LayoutUnit(style().borderRightWidth()); }
</ins><span class="cx">     virtual LayoutUnit horizontalBorderExtent() const { return borderLeft() + borderRight(); }
</span><span class="cx">     virtual LayoutUnit verticalBorderExtent() const { return borderTop() + borderBottom(); }
</span><del>-    virtual LayoutUnit borderBefore() const { return style().borderBeforeWidth(); }
-    virtual LayoutUnit borderAfter() const { return style().borderAfterWidth(); }
-    virtual LayoutUnit borderStart() const { return style().borderStartWidth(); }
-    virtual LayoutUnit borderEnd() const { return style().borderEndWidth(); }
</del><ins>+    virtual LayoutUnit borderBefore() const { return LayoutUnit(style().borderBeforeWidth()); }
+    virtual LayoutUnit borderAfter() const { return LayoutUnit(style().borderAfterWidth()); }
+    virtual LayoutUnit borderStart() const { return LayoutUnit(style().borderStartWidth()); }
+    virtual LayoutUnit borderEnd() const { return LayoutUnit(style().borderEndWidth()); }
</ins><span class="cx"> 
</span><span class="cx">     LayoutUnit borderAndPaddingStart() const { return borderStart() + paddingStart(); }
</span><span class="cx">     LayoutUnit borderAndPaddingBefore() const { return borderBefore() + paddingBefore(); }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderDeprecatedFlexibleBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -839,7 +839,7 @@
</span><span class="cx">                     // Now distribute the space to objects.
</span><span class="cx">                     for (RenderBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
</span><span class="cx">                         if (allowedChildFlex(child, expanding, i)) {
</span><del>-                            LayoutUnit spaceAdd = spaceAvailableThisPass * (child->style().boxFlex() / totalFlex);
</del><ins>+                            LayoutUnit spaceAdd { spaceAvailableThisPass * (child->style().boxFlex() / totalFlex) };
</ins><span class="cx">                             if (spaceAdd) {
</span><span class="cx">                                 child->setOverrideContentLogicalHeight(contentHeightForChild(child) + spaceAdd);
</span><span class="cx">                                 flexingChildren = true;
</span><span class="lines">@@ -1017,13 +1017,13 @@
</span><span class="cx">         if (!leftToRight)
</span><span class="cx">             continue;
</span><span class="cx"> 
</span><del>-        LayoutUnit blockRightEdge = destBlock.logicalRightOffsetForLine(lastVisibleLine->y(), DoNotIndentText);
</del><ins>+        LayoutUnit blockRightEdge = destBlock.logicalRightOffsetForLine(LayoutUnit(lastVisibleLine->y()), DoNotIndentText);
</ins><span class="cx">         if (!lastVisibleLine->lineCanAccommodateEllipsis(leftToRight, blockRightEdge, lastVisibleLine->x() + lastVisibleLine->logicalWidth(), totalWidth))
</span><span class="cx">             continue;
</span><span class="cx"> 
</span><span class="cx">         // Let the truncation code kick in.
</span><span class="cx">         // FIXME: the text alignment should be recomputed after the width changes due to truncation.
</span><del>-        LayoutUnit blockLeftEdge = destBlock.logicalLeftOffsetForLine(lastVisibleLine->y(), DoNotIndentText);
</del><ins>+        LayoutUnit blockLeftEdge = destBlock.logicalLeftOffsetForLine(LayoutUnit(lastVisibleLine->y()), DoNotIndentText);
</ins><span class="cx">         lastVisibleLine->placeEllipsis(anchorBox ? ellipsisAndSpaceStr : ellipsisStr, leftToRight, blockLeftEdge, blockRightEdge, totalWidth, anchorBox);
</span><span class="cx">         destBlock.setHasMarkupTruncation(true);
</span><span class="cx">     }
</span><span class="lines">@@ -1106,7 +1106,7 @@
</span><span class="cx">     } else {
</span><span class="cx">         Length minHeight = child->style().minHeight();
</span><span class="cx">         if (minHeight.isFixed() || minHeight.isAuto()) {
</span><del>-            LayoutUnit minHeight = child->style().minHeight().value();
</del><ins>+            LayoutUnit minHeight { child->style().minHeight().value() };
</ins><span class="cx">             LayoutUnit height = contentHeightForChild(child);
</span><span class="cx">             LayoutUnit allowedShrinkage = std::min<LayoutUnit>(0, minHeight - height);
</span><span class="cx">             return allowedShrinkage;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderElementcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderElement.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderElement.cpp 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderElement.cpp    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -38,6 +38,7 @@
</span><span class="cx"> #include "HTMLHtmlElement.h"
</span><span class="cx"> #include "HTMLImageElement.h"
</span><span class="cx"> #include "HTMLNames.h"
</span><ins>+#include "LengthFunctions.h"
</ins><span class="cx"> #include "Logging.h"
</span><span class="cx"> #include "Page.h"
</span><span class="cx"> #include "PathUtilities.h"
</span><span class="lines">@@ -1140,7 +1141,7 @@
</span><span class="cx">     // We didn't move, but we did change size. Invalidate the delta, which will consist of possibly
</span><span class="cx">     // two rectangles (but typically only one).
</span><span class="cx">     const RenderStyle& outlineStyle = outlineStyleForRepaint();
</span><del>-    LayoutUnit outlineWidth = outlineStyle.outlineSize();
</del><ins>+    LayoutUnit outlineWidth { outlineStyle.outlineSize() };
</ins><span class="cx">     LayoutBoxExtent insetShadowExtent = style().getBoxShadowInsetExtent();
</span><span class="cx">     LayoutUnit width = absoluteValue(newOutlineBox.width() - oldOutlineBox.width());
</span><span class="cx">     if (width) {
</span><span class="lines">@@ -1151,7 +1152,7 @@
</span><span class="cx">         LayoutUnit boxWidth = is<RenderBox>(*this) ? downcast<RenderBox>(*this).width() : 0_lu;
</span><span class="cx">         LayoutUnit minInsetRightShadowExtent = std::min<LayoutUnit>(-insetShadowExtent.right(), std::min(newBounds.width(), oldBounds.width()));
</span><span class="cx">         LayoutUnit borderWidth = std::max(borderRight, std::max(valueForLength(style().borderTopRightRadius().width, boxWidth), valueForLength(style().borderBottomRightRadius().width, boxWidth)));
</span><del>-        LayoutUnit decorationsWidth = std::max<LayoutUnit>(-outlineStyle.outlineOffset(), borderWidth + minInsetRightShadowExtent) + std::max(outlineWidth, shadowRight);
</del><ins>+        LayoutUnit decorationsWidth = std::max(LayoutUnit(-outlineStyle.outlineOffset()), borderWidth + minInsetRightShadowExtent) + std::max(outlineWidth, shadowRight);
</ins><span class="cx">         LayoutRect rightRect(newOutlineBox.x() + std::min(newOutlineBox.width(), oldOutlineBox.width()) - decorationsWidth,
</span><span class="cx">             newOutlineBox.y(),
</span><span class="cx">             width + decorationsWidth,
</span><span class="lines">@@ -1172,7 +1173,7 @@
</span><span class="cx">         LayoutUnit minInsetBottomShadowExtent = std::min<LayoutUnit>(-insetShadowExtent.bottom(), std::min(newBounds.height(), oldBounds.height()));
</span><span class="cx">         LayoutUnit borderHeight = std::max(borderBottom, std::max(valueForLength(style().borderBottomLeftRadius().height, boxHeight),
</span><span class="cx">             valueForLength(style().borderBottomRightRadius().height, boxHeight)));
</span><del>-        LayoutUnit decorationsHeight = std::max<LayoutUnit>(-outlineStyle.outlineOffset(), borderHeight + minInsetBottomShadowExtent) + std::max(outlineWidth, shadowBottom);
</del><ins>+        LayoutUnit decorationsHeight = std::max(LayoutUnit(-outlineStyle.outlineOffset()), borderHeight + minInsetBottomShadowExtent) + std::max(outlineWidth, shadowBottom);
</ins><span class="cx">         LayoutRect bottomRect(newOutlineBox.x(),
</span><span class="cx">             std::min(newOutlineBox.maxY(), oldOutlineBox.maxY()) - decorationsHeight,
</span><span class="cx">             std::max(newOutlineBox.width(), oldOutlineBox.width()),
</span><span class="lines">@@ -1636,13 +1637,13 @@
</span><span class="cx">             switch (side) {
</span><span class="cx">             case BSTop:
</span><span class="cx">             case BSBottom:
</span><del>-                drawBorderRect(snapRectToDevicePixels(x1, y1, length, thirdOfThickness, deviceScaleFactor));
-                drawBorderRect(snapRectToDevicePixels(x1, y2 - thirdOfThickness, length, thirdOfThickness, deviceScaleFactor));
</del><ins>+                drawBorderRect(snapRectToDevicePixels(LayoutRect(x1, y1, length, thirdOfThickness), deviceScaleFactor));
+                drawBorderRect(snapRectToDevicePixels(LayoutRect(x1, y2 - thirdOfThickness, length, thirdOfThickness), deviceScaleFactor));
</ins><span class="cx">                 break;
</span><span class="cx">             case BSLeft:
</span><span class="cx">             case BSRight:
</span><del>-                drawBorderRect(snapRectToDevicePixels(x1, y1, thirdOfThickness, length, deviceScaleFactor));
-                drawBorderRect(snapRectToDevicePixels(x2 - thirdOfThickness, y1, thirdOfThickness, length, deviceScaleFactor));
</del><ins>+                drawBorderRect(snapRectToDevicePixels(LayoutRect(x1, y1, thirdOfThickness, length), deviceScaleFactor));
+                drawBorderRect(snapRectToDevicePixels(LayoutRect(x2 - thirdOfThickness, y1, thirdOfThickness, length), deviceScaleFactor));
</ins><span class="cx">                 break;
</span><span class="cx">             }
</span><span class="cx"> 
</span><span class="lines">@@ -1772,7 +1773,7 @@
</span><span class="cx">             graphicsContext.setFillColor(color);
</span><span class="cx">             bool wasAntialiased = graphicsContext.shouldAntialias();
</span><span class="cx">             graphicsContext.setShouldAntialias(antialias);
</span><del>-            drawBorderRect(snapRectToDevicePixels(x1, y1, x2 - x1, y2 - y1, deviceScaleFactor));
</del><ins>+            drawBorderRect(snapRectToDevicePixels(LayoutRect(x1, y1, x2 - x1, y2 - y1), deviceScaleFactor));
</ins><span class="cx">             graphicsContext.setShouldAntialias(wasAntialiased);
</span><span class="cx">             graphicsContext.setStrokeStyle(oldStrokeStyle);
</span><span class="cx">             return;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderElementh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderElement.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderElement.h   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderElement.h      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -253,9 +253,6 @@
</span><span class="cx">     enum StylePropagationType { PropagateToAllChildren, PropagateToBlockChildrenOnly };
</span><span class="cx">     void propagateStyleToAnonymousChildren(StylePropagationType);
</span><span class="cx"> 
</span><del>-    LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue) const;
-    LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue) const;
-
</del><span class="cx">     void setFirstChild(RenderObject* child) { m_firstChild = child; }
</span><span class="cx">     void setLastChild(RenderObject* child) { m_lastChild = child; }
</span><span class="cx"> 
</span><span class="lines">@@ -376,16 +373,6 @@
</span><span class="cx">         markContainingBlocksForLayout();
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-inline LayoutUnit RenderElement::valueForLength(const Length& length, LayoutUnit maximumValue) const
-{
-    return WebCore::valueForLength(length, maximumValue);
-}
-
-inline LayoutUnit RenderElement::minimumValueForLength(const Length& length, LayoutUnit maximumValue) const
-{
-    return WebCore::minimumValueForLength(length, maximumValue);
-}
-
</del><span class="cx"> inline bool RenderElement::isRenderLayerModelObject() const
</span><span class="cx"> {
</span><span class="cx">     return m_baseTypeFlags & RenderLayerModelObjectFlag;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderImagecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderImage.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderImage.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderImage.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -109,8 +109,8 @@
</span><span class="cx">         isFirstOnLine = !inlineBox->previousOnLineExists();
</span><span class="cx">         isLastOnLine = !inlineBox->nextOnLineExists();
</span><span class="cx">         LogicalSelectionOffsetCaches cache(*containingBlock);
</span><del>-        LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, inlineBox->logicalTop(), cache);
-        LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, inlineBox->logicalTop(), cache);
</del><ins>+        LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, LayoutUnit(inlineBox->logicalTop()), cache);
+        LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, LayoutUnit(inlineBox->logicalTop()), cache);
</ins><span class="cx">         lineExtentRect = IntRect(leftOffset - logicalLeft(), imageRect.y(), rightOffset - leftOffset, imageRect.height());
</span><span class="cx">         if (!inlineBox->isHorizontal()) {
</span><span class="cx">             imageRect = imageRect.transposedRect();
</span><span class="lines">@@ -461,10 +461,10 @@
</span><span class="cx">                 FloatSize imageSize = image->size();
</span><span class="cx">                 imageSize.scale(1 / brokenImageAndImageScaleFactor.second);
</span><span class="cx">                 // Center the error image, accounting for border and padding.
</span><del>-                LayoutUnit centerX = (usableSize.width() - imageSize.width()) / 2;
</del><ins>+                LayoutUnit centerX { (usableSize.width() - imageSize.width()) / 2 };
</ins><span class="cx">                 if (centerX < 0)
</span><span class="cx">                     centerX = 0;
</span><del>-                LayoutUnit centerY = (usableSize.height() - imageSize.height()) / 2;
</del><ins>+                LayoutUnit centerY { (usableSize.height() - imageSize.height()) / 2 };
</ins><span class="cx">                 if (centerY < 0)
</span><span class="cx">                     centerY = 0;
</span><span class="cx">                 imageOffset = LayoutSize(leftBorder + leftPad + centerX + missingImageBorderWidth, topBorder + topPad + centerY + missingImageBorderWidth);
</span><span class="lines">@@ -489,7 +489,7 @@
</span><span class="cx">                 // Only draw the alt text if it'll fit within the content box,
</span><span class="cx">                 // and only if it fits above the error image.
</span><span class="cx">                 TextRun textRun = RenderBlock::constructTextRun(text, style());
</span><del>-                LayoutUnit textWidth = font.width(textRun);
</del><ins>+                LayoutUnit textWidth { font.width(textRun) };
</ins><span class="cx">                 if (errorPictureDrawn) {
</span><span class="cx">                     if (usableSize.width() >= textWidth && fontMetrics.height() <= imageOffset.height())
</span><span class="cx">                         context.drawText(font, textRun, altTextOffset);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderInlinecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderInline.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderInline.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderInline.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -452,7 +452,7 @@
</span><span class="cx">     if (margin.isAuto())
</span><span class="cx">         return 0;
</span><span class="cx">     if (margin.isFixed())
</span><del>-        return margin.value();
</del><ins>+        return LayoutUnit(margin.value());
</ins><span class="cx">     if (margin.isPercentOrCalculated())
</span><span class="cx">         return minimumValueForLength(margin, std::max<LayoutUnit>(0, renderer->containingBlock()->availableLogicalWidth()));
</span><span class="cx">     return 0;
</span><span class="lines">@@ -840,7 +840,7 @@
</span><span class="cx">             repaintRect.move(downcast<RenderInline>(*inlineFlow).layer()->offsetForInFlowPosition());
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    LayoutUnit outlineSize = style().outlineSize();
</del><ins>+    LayoutUnit outlineSize { style().outlineSize() };
</ins><span class="cx">     repaintRect.inflate(outlineSize);
</span><span class="cx"> 
</span><span class="cx">     if (hitRepaintContainer || !containingBlock)
</span><span class="lines">@@ -1235,9 +1235,9 @@
</span><span class="cx">     rects.append(LayoutRect());
</span><span class="cx">     for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
</span><span class="cx">         const RootInlineBox& rootBox = curr->root();
</span><del>-        LayoutUnit top = std::max<LayoutUnit>(rootBox.lineTop(), curr->logicalTop());
-        LayoutUnit bottom = std::min<LayoutUnit>(rootBox.lineBottom(), curr->logicalBottom());
-        rects.append(LayoutRect(curr->x(), top, curr->logicalWidth(), bottom - top));
</del><ins>+        LayoutUnit top = std::max(rootBox.lineTop(), LayoutUnit(curr->logicalTop()));
+        LayoutUnit bottom = std::min(rootBox.lineBottom(), LayoutUnit(curr->logicalBottom()));
+        rects.append({ LayoutUnit(curr->x()), top, LayoutUnit(curr->logicalWidth()), bottom - top });
</ins><span class="cx">     }
</span><span class="cx">     rects.append(LayoutRect());
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLineBreakcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLineBreak.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLineBreak.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderLineBreak.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -248,8 +248,8 @@
</span><span class="cx">     auto* containingBlock = containingBlockForObjectInFlow();
</span><span class="cx">     // Map rect, extended left to leftOffset, and right to rightOffset, through transforms to get minX and maxX.
</span><span class="cx">     LogicalSelectionOffsetCaches cache(*containingBlock);
</span><del>-    LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, box->logicalTop(), cache);
-    LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, box->logicalTop(), cache);
</del><ins>+    LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, LayoutUnit(box->logicalTop()), cache);
+    LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, LayoutUnit(box->logicalTop()), cache);
</ins><span class="cx">     LayoutRect extentsRect = rect;
</span><span class="cx">     if (box->isHorizontal()) {
</span><span class="cx">         extentsRect.setX(leftOffset);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderListMarkercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderListMarker.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderListMarker.cpp      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderListMarker.cpp 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -1180,7 +1180,7 @@
</span><span class="cx">     if (!box)
</span><span class="cx">         return LayoutRect(LayoutPoint(), size());
</span><span class="cx">     const RootInlineBox& rootBox = m_inlineBoxWrapper->root();
</span><del>-    LayoutUnit newLogicalTop = rootBox.blockFlow().style().isFlippedBlocksWritingMode() ? m_inlineBoxWrapper->logicalBottom() - rootBox.selectionBottom() : rootBox.selectionTop() - m_inlineBoxWrapper->logicalTop();
</del><ins>+    LayoutUnit newLogicalTop { rootBox.blockFlow().style().isFlippedBlocksWritingMode() ? m_inlineBoxWrapper->logicalBottom() - rootBox.selectionBottom() : rootBox.selectionTop() - m_inlineBoxWrapper->logicalTop() };
</ins><span class="cx">     if (rootBox.blockFlow().style().isHorizontalWritingMode())
</span><span class="cx">         return LayoutRect(0_lu, newLogicalTop, width(), rootBox.selectionHeight());
</span><span class="cx">     return LayoutRect(newLogicalTop, 0_lu, rootBox.selectionHeight(), height());
</span><span class="lines">@@ -1409,9 +1409,9 @@
</span><span class="cx">     Length startMargin = style().marginStart();
</span><span class="cx">     Length endMargin = style().marginEnd();
</span><span class="cx">     if (startMargin.isFixed())
</span><del>-        setMarginStart(startMargin.value());
</del><ins>+        setMarginStart(LayoutUnit(startMargin.value()));
</ins><span class="cx">     if (endMargin.isFixed())
</span><del>-        setMarginEnd(endMargin.value());
</del><ins>+        setMarginEnd(LayoutUnit(endMargin.value()));
</ins><span class="cx"> 
</span><span class="cx">     clearNeedsLayout();
</span><span class="cx"> }
</span><span class="lines">@@ -1654,9 +1654,9 @@
</span><span class="cx">             logicalWidth = 0;
</span><span class="cx">         else {
</span><span class="cx">             TextRun run = RenderBlock::constructTextRun(m_text, style());
</span><del>-            LayoutUnit itemWidth = font.width(run);
</del><ins>+            LayoutUnit itemWidth { font.width(run) };
</ins><span class="cx">             UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem->value()), ' ' };
</span><del>-            LayoutUnit suffixSpaceWidth = font.width(RenderBlock::constructTextRun(suffixSpace, 2, style()));
</del><ins>+            LayoutUnit suffixSpaceWidth { font.width(RenderBlock::constructTextRun(suffixSpace, 2, style())) };
</ins><span class="cx">             logicalWidth = itemWidth + suffixSpaceWidth;
</span><span class="cx">         }
</span><span class="cx">         break;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnSetcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -584,7 +584,7 @@
</span><span class="cx">     const Color& ruleColor = blockStyle.visitedDependentColorWithColorFilter(CSSPropertyColumnRuleColor);
</span><span class="cx">     bool ruleTransparent = blockStyle.columnRuleIsTransparent();
</span><span class="cx">     BorderStyle ruleStyle = collapsedBorderStyle(blockStyle.columnRuleStyle());
</span><del>-    LayoutUnit ruleThickness = blockStyle.columnRuleWidth();
</del><ins>+    LayoutUnit ruleThickness { blockStyle.columnRuleWidth() };
</ins><span class="cx">     LayoutUnit colGap = columnGap();
</span><span class="cx">     bool renderRule = ruleStyle > BorderStyle::Hidden && !ruleTransparent;
</span><span class="cx">     if (!renderRule)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnSeth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnSet.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnSet.h    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnSet.h       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -217,7 +217,7 @@
</span><span class="cx"> 
</span><span class="cx">         // Return the column height that this content run would require, considering the implicit
</span><span class="cx">         // breaks assumed so far.
</span><del>-        LayoutUnit columnLogicalHeight(LayoutUnit startOffset) const { return ceilf(float(m_breakOffset - startOffset) / float(m_assumedImplicitBreaks + 1)); }
</del><ins>+        LayoutUnit columnLogicalHeight(LayoutUnit startOffset) const { return LayoutUnit(ceilf(float(m_breakOffset - startOffset) / float(m_assumedImplicitBreaks + 1))); }
</ins><span class="cx"> 
</span><span class="cx">     private:
</span><span class="cx">         LayoutUnit m_breakOffset; // Flow thread offset where this run ends.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderObject.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -1694,7 +1694,7 @@
</span><span class="cx"> 
</span><span class="cx"> void RenderObject::adjustRectForOutlineAndShadow(LayoutRect& rect) const
</span><span class="cx"> {
</span><del>-    LayoutUnit outlineSize = outlineStyleForRepaint().outlineSize();
</del><ins>+    LayoutUnit outlineSize { outlineStyleForRepaint().outlineSize() };
</ins><span class="cx">     if (const ShadowData* boxShadow = style().boxShadow()) {
</span><span class="cx">         boxShadow->adjustRectForShadow(rect, outlineSize);
</span><span class="cx">         return;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderReplacedcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderReplaced.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderReplaced.cpp        2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderReplaced.cpp   2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -632,7 +632,7 @@
</span><span class="cx">         return LayoutRect(LayoutPoint(), size());
</span><span class="cx">     
</span><span class="cx">     const RootInlineBox& rootBox = m_inlineBoxWrapper->root();
</span><del>-    LayoutUnit newLogicalTop = rootBox.blockFlow().style().isFlippedBlocksWritingMode() ? m_inlineBoxWrapper->logicalBottom() - rootBox.selectionBottom() : rootBox.selectionTop() - m_inlineBoxWrapper->logicalTop();
</del><ins>+    LayoutUnit newLogicalTop { rootBox.blockFlow().style().isFlippedBlocksWritingMode() ? m_inlineBoxWrapper->logicalBottom() - rootBox.selectionBottom() : rootBox.selectionTop() - m_inlineBoxWrapper->logicalTop() };
</ins><span class="cx">     if (rootBox.blockFlow().style().isHorizontalWritingMode())
</span><span class="cx">         return LayoutRect(0_lu, newLogicalTop, width(), rootBox.selectionHeight());
</span><span class="cx">     return LayoutRect(newLogicalTop, 0_lu, rootBox.selectionHeight(), height());
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTablecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTable.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTable.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderTable.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -320,7 +320,7 @@
</span><span class="cx">         if (is<HTMLTableElement>(element()) || style().boxSizing() == BoxSizing::BorderBox) {
</span><span class="cx">             borders = borderAndPadding;
</span><span class="cx">         }
</span><del>-        return styleLogicalHeight.value() - borders;
</del><ins>+        return LayoutUnit(styleLogicalHeight.value() - borders);
</ins><span class="cx">     } else if (styleLogicalHeight.isPercentOrCalculated())
</span><span class="cx">         return computePercentageLogicalHeight(styleLogicalHeight).valueOr(0);
</span><span class="cx">     else if (styleLogicalHeight.isIntrinsic())
</span><span class="lines">@@ -1218,7 +1218,7 @@
</span><span class="cx">     if (tb.style() == BorderStyle::Hidden)
</span><span class="cx">         return 0;
</span><span class="cx">     if (tb.style() > BorderStyle::Hidden) {
</span><del>-        LayoutUnit collapsedBorderWidth = std::max<LayoutUnit>(borderWidth, tb.width() / 2);
</del><ins>+        LayoutUnit collapsedBorderWidth = std::max(borderWidth, LayoutUnit(tb.width() / 2));
</ins><span class="cx">         borderWidth = floorToDevicePixel(collapsedBorderWidth, document().deviceScaleFactor());
</span><span class="cx">     }
</span><span class="cx">     return borderWidth;
</span><span class="lines">@@ -1240,7 +1240,7 @@
</span><span class="cx">         return 0;
</span><span class="cx">     if (tb.style() > BorderStyle::Hidden) {
</span><span class="cx">         float deviceScaleFactor = document().deviceScaleFactor();
</span><del>-        LayoutUnit collapsedBorderWidth = std::max<LayoutUnit>(borderWidth, (tb.width() + (1 / deviceScaleFactor)) / 2);
</del><ins>+        LayoutUnit collapsedBorderWidth = std::max(borderWidth, LayoutUnit((tb.width() + (1 / deviceScaleFactor)) / 2));
</ins><span class="cx">         borderWidth = floorToDevicePixel(collapsedBorderWidth, deviceScaleFactor);
</span><span class="cx">     }
</span><span class="cx">     return borderWidth;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTableCellcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTableCell.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTableCell.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderTableCell.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -198,7 +198,7 @@
</span><span class="cx">         // to make the minwidth of the cell into the fixed width. They do this
</span><span class="cx">         // even in strict mode, so do not make this a quirk. Affected the top
</span><span class="cx">         // of hiptop.com.
</span><del>-        m_minPreferredLogicalWidth = std::max<LayoutUnit>(w.value(), m_minPreferredLogicalWidth);
</del><ins>+        m_minPreferredLogicalWidth = std::max(LayoutUnit(w.value()), m_minPreferredLogicalWidth);
</ins><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -357,7 +357,7 @@
</span><span class="cx">         return RenderBlockFlow::clippedOverflowRectForRepaint(repaintContainer);
</span><span class="cx"> 
</span><span class="cx">     bool rtl = !styleForCellFlow().isLeftToRightDirection();
</span><del>-    LayoutUnit outlineSize = style().outlineSize();
</del><ins>+    LayoutUnit outlineSize { style().outlineSize() };
</ins><span class="cx">     LayoutUnit left = std::max(borderHalfLeft(true), outlineSize);
</span><span class="cx">     LayoutUnit right = std::max(borderHalfRight(true), outlineSize);
</span><span class="cx">     LayoutUnit top = std::max(borderHalfTop(true), outlineSize);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTableSectioncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTableSection.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTableSection.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderTableSection.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -214,9 +214,9 @@
</span><span class="cx"> static LayoutUnit resolveLogicalHeightForRow(const Length& rowLogicalHeight)
</span><span class="cx"> {
</span><span class="cx">     if (rowLogicalHeight.isFixed())
</span><del>-        return rowLogicalHeight.value();
</del><ins>+        return LayoutUnit(rowLogicalHeight.value());
</ins><span class="cx">     if (rowLogicalHeight.isCalculated())
</span><del>-        return rowLogicalHeight.nonNanCalculatedValue(0);
</del><ins>+        return LayoutUnit(rowLogicalHeight.nonNanCalculatedValue(0));
</ins><span class="cx">     return 0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -388,7 +388,7 @@
</span><span class="cx">     LayoutUnit rowHeight = m_rowPos[1] - m_rowPos[0];
</span><span class="cx">     for (unsigned r = 0; r < totalRows; ++r) {
</span><span class="cx">         if (totalPercent > 0 && m_grid[r].logicalHeight.isPercent()) {
</span><del>-            LayoutUnit toAdd = std::min<LayoutUnit>(extraLogicalHeight, (totalHeight * m_grid[r].logicalHeight.percent() / 100) - rowHeight);
</del><ins>+            LayoutUnit toAdd = std::min(extraLogicalHeight, LayoutUnit((totalHeight * m_grid[r].logicalHeight.percent() / 100) - rowHeight));
</ins><span class="cx">             // If toAdd is negative, then we don't want to shrink the row (this bug
</span><span class="cx">             // affected Outlook Web Access).
</span><span class="cx">             toAdd = std::max(0_lu, toAdd);
</span><span class="lines">@@ -1142,18 +1142,18 @@
</span><span class="cx">     switch (borderSide) {
</span><span class="cx">     case BSTop:
</span><span class="cx">         paintRowGroupBorder(paintInfo, antialias, LayoutRect(paintOffset.x() + offsetLeftForRowGroupBorder(cell, rowGroupRect, row), rowGroupRect.y(), 
</span><del>-            horizontalRowGroupBorderWidth(cell, rowGroupRect, row, column), style.borderTop().width()), BSTop, CSSPropertyBorderTopColor, style.borderTopStyle(), table()->style().borderTopStyle());
</del><ins>+            horizontalRowGroupBorderWidth(cell, rowGroupRect, row, column), LayoutUnit(style.borderTop().width())), BSTop, CSSPropertyBorderTopColor, style.borderTopStyle(), table()->style().borderTopStyle());
</ins><span class="cx">         break;
</span><span class="cx">     case BSBottom:
</span><span class="cx">         paintRowGroupBorder(paintInfo, antialias, LayoutRect(paintOffset.x() + offsetLeftForRowGroupBorder(cell, rowGroupRect, row), rowGroupRect.y() + rowGroupRect.height(), 
</span><del>-            horizontalRowGroupBorderWidth(cell, rowGroupRect, row, column), style.borderBottom().width()), BSBottom, CSSPropertyBorderBottomColor, style.borderBottomStyle(), table()->style().borderBottomStyle());
</del><ins>+            horizontalRowGroupBorderWidth(cell, rowGroupRect, row, column), LayoutUnit(style.borderBottom().width())), BSBottom, CSSPropertyBorderBottomColor, style.borderBottomStyle(), table()->style().borderBottomStyle());
</ins><span class="cx">         break;
</span><span class="cx">     case BSLeft:
</span><del>-        paintRowGroupBorder(paintInfo, antialias, LayoutRect(rowGroupRect.x(), rowGroupRect.y() + offsetTopForRowGroupBorder(cell, borderSide, row), style.borderLeft().width(),
</del><ins>+        paintRowGroupBorder(paintInfo, antialias, LayoutRect(rowGroupRect.x(), rowGroupRect.y() + offsetTopForRowGroupBorder(cell, borderSide, row), LayoutUnit(style.borderLeft().width()),
</ins><span class="cx">             verticalRowGroupBorderHeight(cell, rowGroupRect, row)), BSLeft, CSSPropertyBorderLeftColor, style.borderLeftStyle(), table()->style().borderLeftStyle());
</span><span class="cx">         break;
</span><span class="cx">     case BSRight:
</span><del>-        paintRowGroupBorder(paintInfo, antialias, LayoutRect(rowGroupRect.x() + rowGroupRect.width(), rowGroupRect.y() + offsetTopForRowGroupBorder(cell, borderSide, row), style.borderRight().width(),
</del><ins>+        paintRowGroupBorder(paintInfo, antialias, LayoutRect(rowGroupRect.x() + rowGroupRect.width(), rowGroupRect.y() + offsetTopForRowGroupBorder(cell, borderSide, row), LayoutUnit(style.borderRight().width()),
</ins><span class="cx">             verticalRowGroupBorderHeight(cell, rowGroupRect, row)), BSRight, CSSPropertyBorderRightColor, style.borderRightStyle(), table()->style().borderRightStyle());
</span><span class="cx">         break;
</span><span class="cx">     default:
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTextcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderText.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderText.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderText.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -378,8 +378,8 @@
</span><span class="cx">         RenderBlock* containingBlock = this->containingBlock();
</span><span class="cx">         // Map rect, extended left to leftOffset, and right to rightOffset, through transforms to get minX and maxX.
</span><span class="cx">         LogicalSelectionOffsetCaches cache(*containingBlock);
</span><del>-        LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, box->logicalTop(), cache);
-        LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, box->logicalTop(), cache);
</del><ins>+        LayoutUnit leftOffset = containingBlock->logicalLeftSelectionOffset(*containingBlock, LayoutUnit(box->logicalTop()), cache);
+        LayoutUnit rightOffset = containingBlock->logicalRightSelectionOffset(*containingBlock, LayoutUnit(box->logicalTop()), cache);
</ins><span class="cx">         LayoutRect extentsRect = rect;
</span><span class="cx">         if (box->isHorizontal()) {
</span><span class="cx">             extentsRect.setX(leftOffset);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTextControlMultiLinecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderTextControlMultiLine.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderTextControlMultiLine.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderTextControlMultiLine.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -84,7 +84,7 @@
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit RenderTextControlMultiLine::preferredContentLogicalWidth(float charWidth) const
</span><span class="cx"> {
</span><del>-    return ceilf(charWidth * textAreaElement().cols()) + scrollbarThickness();
</del><ins>+    return LayoutUnit(ceilf(charWidth * textAreaElement().cols()) + scrollbarThickness());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit RenderTextControlMultiLine::computeControlLogicalHeight(LayoutUnit lineHeight, LayoutUnit nonContentHeight) const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderThemeMacmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderThemeMac.mm (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderThemeMac.mm 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderThemeMac.mm    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2920,7 +2920,7 @@
</span><span class="cx">     GraphicsContextStateSaver saver(context);
</span><span class="cx"> 
</span><span class="cx">     context.translate(toFloatSize(paintRect.location()));
</span><del>-    context.translate(floorSizeToDevicePixels(LayoutSize((paintRect.width() - attachmentIconBackgroundSize) / 2, 0), renderer.document().deviceScaleFactor()));
</del><ins>+    context.translate(floorSizeToDevicePixels({ LayoutUnit((paintRect.width() - attachmentIconBackgroundSize) / 2), 0 }, renderer.document().deviceScaleFactor()));
</ins><span class="cx"> 
</span><span class="cx">     bool usePlaceholder = validProgress && !progress;
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderVTTCuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderVTTCue.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderVTTCue.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderVTTCue.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -180,8 +180,8 @@
</span><span class="cx"> {
</span><span class="cx">     LayoutUnit top = y();
</span><span class="cx">     LayoutUnit left = x();
</span><del>-    LayoutUnit bottom = top + firstLineBox->height();
-    LayoutUnit right = left + firstLineBox->width();
</del><ins>+    LayoutUnit bottom { top + firstLineBox->height() };
+    LayoutUnit right { left + firstLineBox->width() };
</ins><span class="cx"> 
</span><span class="cx">     // 12. Horizontal: If step is negative and the top of the first line
</span><span class="cx">     // box in boxes is now above the top of the video's rendering area,
</span><span class="lines">@@ -352,7 +352,7 @@
</span><span class="cx">     InlineFlowBox* firstLineBox = downcast<RenderInline>(*backdropElement.firstChild()).firstLineBox();
</span><span class="cx">     if (static_cast<TextTrackCueGeneric*>(m_cue)->useDefaultPosition() && firstLineBox) {
</span><span class="cx">         LayoutUnit parentWidth = containingBlock()->logicalWidth();
</span><del>-        LayoutUnit width = firstLineBox->width();
</del><ins>+        LayoutUnit width { firstLineBox->width() };
</ins><span class="cx">         LayoutUnit right = (parentWidth / 2) - (width / 2);
</span><span class="cx">         setX(right);
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderViewcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderView.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderView.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RenderView.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -263,7 +263,7 @@
</span><span class="cx"> {
</span><span class="cx">     // FIXME: If the FrameView's fixedVisibleContentRect() is not empty, perhaps it should be consulted here too?
</span><span class="cx">     if (frameView().fixedElementsLayoutRelativeToFrame())
</span><del>-        return (isHorizontalWritingMode() ? frameView().visibleWidth() : frameView().visibleHeight()) / frameView().frame().frameScaleFactor();
</del><ins>+        return LayoutUnit((isHorizontalWritingMode() ? frameView().visibleWidth() : frameView().visibleHeight()) / frameView().frame().frameScaleFactor());
</ins><span class="cx"> 
</span><span class="cx"> #if PLATFORM(IOS_FAMILY)
</span><span class="cx">     if (frameView().useCustomFixedPositionLayoutRect())
</span><span class="lines">@@ -280,7 +280,7 @@
</span><span class="cx"> {
</span><span class="cx">     // FIXME: If the FrameView's fixedVisibleContentRect() is not empty, perhaps it should be consulted here too?
</span><span class="cx">     if (frameView().fixedElementsLayoutRelativeToFrame())
</span><del>-        return (isHorizontalWritingMode() ? frameView().visibleHeight() : frameView().visibleWidth()) / frameView().frame().frameScaleFactor();
</del><ins>+        return LayoutUnit((isHorizontalWritingMode() ? frameView().visibleHeight() : frameView().visibleWidth()) / frameView().frame().frameScaleFactor());
</ins><span class="cx"> 
</span><span class="cx"> #if PLATFORM(IOS_FAMILY)
</span><span class="cx">     if (frameView().useCustomFixedPositionLayoutRect())
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRootInlineBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RootInlineBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RootInlineBox.cpp 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/RootInlineBox.cpp    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -183,7 +183,7 @@
</span><span class="cx"> void RootInlineBox::adjustPosition(float dx, float dy)
</span><span class="cx"> {
</span><span class="cx">     InlineFlowBox::adjustPosition(dx, dy);
</span><del>-    LayoutUnit blockDirectionDelta = isHorizontal() ? dy : dx; // The block direction delta is a LayoutUnit.
</del><ins>+    LayoutUnit blockDirectionDelta { isHorizontal() ? dy : dx }; // The block direction delta is a LayoutUnit.
</ins><span class="cx">     m_lineTop += blockDirectionDelta;
</span><span class="cx">     m_lineBottom += blockDirectionDelta;
</span><span class="cx">     m_lineTopWithLeading += blockDirectionDelta;
</span><span class="lines">@@ -360,12 +360,12 @@
</span><span class="cx">         return 0;
</span><span class="cx"> 
</span><span class="cx">     LayoutUnit lineGridFontAscent = lineGrid->style().fontMetrics().ascent(baselineType());
</span><del>-    LayoutUnit lineGridFontHeight = lineGridBox->logicalHeight();
-    LayoutUnit firstTextTop = lineGridBlockOffset + lineGridBox->logicalTop();
</del><ins>+    LayoutUnit lineGridFontHeight { lineGridBox->logicalHeight() };
+    LayoutUnit firstTextTop { lineGridBlockOffset + lineGridBox->logicalTop() };
</ins><span class="cx">     LayoutUnit firstLineTopWithLeading = lineGridBlockOffset + lineGridBox->lineTopWithLeading();
</span><span class="cx">     LayoutUnit firstBaselinePosition = firstTextTop + lineGridFontAscent;
</span><span class="cx"> 
</span><del>-    LayoutUnit currentTextTop = blockOffset + logicalTop() + delta;
</del><ins>+    LayoutUnit currentTextTop { blockOffset + logicalTop() + delta };
</ins><span class="cx">     LayoutUnit currentFontAscent = blockFlow().style().fontMetrics().ascent(baselineType());
</span><span class="cx">     LayoutUnit currentBaselinePosition = currentTextTop + currentFontAscent;
</span><span class="cx"> 
</span><span class="lines">@@ -388,7 +388,7 @@
</span><span class="cx">         if (logicalHeight() <= lineGridFontHeight)
</span><span class="cx">             firstTextTop += (lineGridFontHeight - logicalHeight()) / 2;
</span><span class="cx">         else {
</span><del>-            LayoutUnit numberOfLinesWithLeading = ceilf(static_cast<float>(logicalHeight() - lineGridFontHeight) / gridLineHeight);
</del><ins>+            LayoutUnit numberOfLinesWithLeading { ceilf(static_cast<float>(logicalHeight() - lineGridFontHeight) / gridLineHeight) };
</ins><span class="cx">             LayoutUnit totalHeight = lineGridFontHeight + numberOfLinesWithLeading * gridLineHeight;
</span><span class="cx">             firstTextTop += (totalHeight - logicalHeight()) / 2;
</span><span class="cx">         }
</span><span class="lines">@@ -433,11 +433,11 @@
</span><span class="cx">     InlineBox* firstBox = firstSelectedBox();
</span><span class="cx">     InlineBox* lastBox = lastSelectedBox();
</span><span class="cx">     if (leftGap) {
</span><del>-        result.uniteLeft(blockFlow().logicalLeftSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, &firstBox->parent()->renderer(), firstBox->logicalLeft(),
</del><ins>+        result.uniteLeft(blockFlow().logicalLeftSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, &firstBox->parent()->renderer(), LayoutUnit(firstBox->logicalLeft()),
</ins><span class="cx">             selTop, selHeight, cache, paintInfo));
</span><span class="cx">     }
</span><span class="cx">     if (rightGap) {
</span><del>-        result.uniteRight(blockFlow().logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, &lastBox->parent()->renderer(), lastBox->logicalRight(),
</del><ins>+        result.uniteRight(blockFlow().logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, &lastBox->parent()->renderer(), LayoutUnit(lastBox->logicalRight()),
</ins><span class="cx">             selTop, selHeight, cache, paintInfo));
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -450,11 +450,11 @@
</span><span class="cx">     // We can see that the |bbb| run is not part of the selection while the runs around it are.
</span><span class="cx">     if (firstBox && firstBox != lastBox) {
</span><span class="cx">         // Now fill in any gaps on the line that occurred between two selected elements.
</span><del>-        LayoutUnit lastLogicalLeft = firstBox->logicalRight();
</del><ins>+        LayoutUnit lastLogicalLeft { firstBox->logicalRight() };
</ins><span class="cx">         bool isPreviousBoxSelected = firstBox->selectionState() != RenderObject::SelectionNone;
</span><span class="cx">         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
</span><span class="cx">             if (box->selectionState() != RenderObject::SelectionNone) {
</span><del>-                LayoutRect logicalRect(lastLogicalLeft, selTop, box->logicalLeft() - lastLogicalLeft, selHeight);
</del><ins>+                LayoutRect logicalRect { lastLogicalLeft, selTop, LayoutUnit(box->logicalLeft() - lastLogicalLeft), selHeight };
</ins><span class="cx">                 logicalRect.move(renderer().isHorizontalWritingMode() ? offsetFromRootBlock : LayoutSize(offsetFromRootBlock.height(), offsetFromRootBlock.width()));
</span><span class="cx">                 LayoutRect gapRect = rootBlock.logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
</span><span class="cx">                 if (isPreviousBoxSelected && gapRect.width() > 0 && gapRect.height() > 0) {
</span><span class="lines">@@ -849,14 +849,14 @@
</span><span class="cx">     
</span><span class="cx">     if (isHorizontal()) {
</span><span class="cx">         if (isLeftToRightDirection())
</span><del>-            lineLayoutOverflow.shiftMaxXEdgeTo(std::max<LayoutUnit>(lineLayoutOverflow.maxX(), logicalRight() + endPadding));
</del><ins>+            lineLayoutOverflow.shiftMaxXEdgeTo(std::max(lineLayoutOverflow.maxX(), LayoutUnit(logicalRight() + endPadding)));
</ins><span class="cx">         else
</span><del>-            lineLayoutOverflow.shiftXEdgeTo(std::min<LayoutUnit>(lineLayoutOverflow.x(), logicalLeft() - endPadding));
</del><ins>+            lineLayoutOverflow.shiftXEdgeTo(std::min(lineLayoutOverflow.x(), LayoutUnit(logicalLeft() - endPadding)));
</ins><span class="cx">     } else {
</span><span class="cx">         if (isLeftToRightDirection())
</span><del>-            lineLayoutOverflow.shiftMaxYEdgeTo(std::max<LayoutUnit>(lineLayoutOverflow.maxY(), logicalRight() + endPadding));
</del><ins>+            lineLayoutOverflow.shiftMaxYEdgeTo(std::max(lineLayoutOverflow.maxY(), LayoutUnit(logicalRight() + endPadding)));
</ins><span class="cx">         else
</span><del>-            lineLayoutOverflow.shiftYEdgeTo(std::min<LayoutUnit>(lineLayoutOverflow.y(), logicalLeft() - endPadding));
</del><ins>+            lineLayoutOverflow.shiftYEdgeTo(std::min(lineLayoutOverflow.y(), LayoutUnit(logicalLeft() - endPadding)));
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     return lineLayoutOverflow;
</span><span class="lines">@@ -993,7 +993,7 @@
</span><span class="cx"> LayoutUnit RootInlineBox::verticalPositionForBox(InlineBox* box, VerticalPositionCache& verticalPositionCache)
</span><span class="cx"> {
</span><span class="cx">     if (box->renderer().isTextOrLineBreak())
</span><del>-        return box->parent()->logicalTop();
</del><ins>+        return LayoutUnit(box->parent()->logicalTop());
</ins><span class="cx">     
</span><span class="cx">     RenderBoxModelObject* renderer = box->boxModelObject();
</span><span class="cx">     ASSERT(renderer->isInline());
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingSimpleLineLayoutFunctionscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/SimpleLineLayoutFunctions.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/SimpleLineLayoutFunctions.cpp     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/SimpleLineLayoutFunctions.cpp        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -379,7 +379,7 @@
</span><span class="cx">         auto lineTop = firstRun.rect().y();
</span><span class="cx">         auto lineHeight = firstRun.rect().height();
</span><span class="cx">         rootLineBox.setLogicalTop(lineTop);
</span><del>-        rootLineBox.setLineTopBottomPositions(lineTop, lineTop + lineHeight, lineTop, lineTop + lineHeight);
</del><ins>+        rootLineBox.setLineTopBottomPositions(LayoutUnit(lineTop), LayoutUnit(lineTop + lineHeight), LayoutUnit(lineTop), LayoutUnit(lineTop + lineHeight));
</ins><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingSimpleLineLayoutPaginationcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/SimpleLineLayoutPagination.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/SimpleLineLayoutPagination.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/SimpleLineLayoutPagination.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -105,7 +105,7 @@
</span><span class="cx">     if (firstLineDoesNotFit || orphanDoesNotFit) {
</span><span class="cx">         auto firstLine = lines.first();
</span><span class="cx">         auto firstLineOverflowRect = computeOverflow(flow, LayoutRect(0_lu, firstLine.top, 0_lu, firstLine.height));
</span><del>-        auto firstLineUpperOverhang = std::max<LayoutUnit>(-firstLineOverflowRect.y(), 0_lu);
</del><ins>+        auto firstLineUpperOverhang = std::max(LayoutUnit(-firstLineOverflowRect.y()), 0_lu);
</ins><span class="cx">         flow.setPaginationStrut(line.top + remainingLogicalHeight + firstLineUpperOverhang);
</span><span class="cx">         return;
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingSimpleLineLayoutResolvercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/SimpleLineLayoutResolver.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/SimpleLineLayoutResolver.cpp      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/SimpleLineLayoutResolver.cpp 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -206,7 +206,7 @@
</span><span class="cx">     adjustedY = std::max<float>(adjustedY, 0);
</span><span class="cx">     auto lineIndexCandidate =  std::min<unsigned>(adjustedY / m_lineHeight, m_layout.lineCount() - 1);
</span><span class="cx">     if (m_layout.hasLineStruts())
</span><del>-        return adjustLineIndexForStruts(y, type, lineIndexCandidate);
</del><ins>+        return adjustLineIndexForStruts(LayoutUnit(y), type, lineIndexCandidate);
</ins><span class="cx">     return lineIndexCandidate;
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderinglineLineWidthcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/line/LineWidth.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/line/LineWidth.cpp        2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/line/LineWidth.cpp   2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -182,7 +182,7 @@
</span><span class="cx"> 
</span><span class="cx">         ++newLineTop;
</span><span class="cx">     }
</span><del>-    updateLineDimension(newLineTop, newLineWidth, newLineLeft, newLineRight);
</del><ins>+    updateLineDimension(newLineTop, LayoutUnit(newLineWidth), LayoutUnit(newLineLeft), LayoutUnit(newLineRight));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void LineWidth::fitBelowFloats(bool isFirstLine)
</span><span class="lines">@@ -212,7 +212,7 @@
</span><span class="cx">             break;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    updateLineDimension(lastFloatLogicalBottom, newLineWidth, newLineLeft, newLineRight);
</del><ins>+    updateLineDimension(lastFloatLogicalBottom, LayoutUnit(newLineWidth), LayoutUnit(newLineLeft), LayoutUnit(newLineRight));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void LineWidth::setTrailingWhitespaceWidth(float collapsedWhitespace, float borderPaddingMargin)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlMathOperatorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/MathOperator.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/MathOperator.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/MathOperator.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -184,10 +184,10 @@
</span><span class="cx"> 
</span><span class="cx">     if (m_operatorType == Type::VerticalOperator) {
</span><span class="cx">         m_width = 0;
</span><del>-        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(topOrRight));
-        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(extension));
-        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(bottomOrLeft));
-        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(middle));
</del><ins>+        m_width = std::max(m_width, LayoutUnit(advanceWidthForGlyph(topOrRight)));
+        m_width = std::max(m_width, LayoutUnit(advanceWidthForGlyph(extension)));
+        m_width = std::max(m_width, LayoutUnit(advanceWidthForGlyph(bottomOrLeft)));
+        m_width = std::max(m_width, LayoutUnit(advanceWidthForGlyph(middle)));
</ins><span class="cx">     } else {
</span><span class="cx">         m_ascent = 0;
</span><span class="cx">         m_descent = 0;
</span><span class="lines">@@ -401,10 +401,10 @@
</span><span class="cx">         for (auto& sizeVariant : sizeVariants) {
</span><span class="cx">             GlyphData glyphData(sizeVariant, baseGlyph.font);
</span><span class="cx">             if (calculateMaxPreferredWidth)
</span><del>-                m_maxPreferredWidth = std::max<LayoutUnit>(m_maxPreferredWidth, advanceWidthForGlyph(glyphData));
</del><ins>+                m_maxPreferredWidth = std::max(m_maxPreferredWidth, LayoutUnit(advanceWidthForGlyph(glyphData)));
</ins><span class="cx">             else {
</span><span class="cx">                 setSizeVariant(glyphData);
</span><del>-                LayoutUnit size = isVertical ? heightForGlyph(glyphData) : advanceWidthForGlyph(glyphData);
</del><ins>+                LayoutUnit size { isVertical ? heightForGlyph(glyphData) : advanceWidthForGlyph(glyphData) };
</ins><span class="cx">                 if (size >= targetSize)
</span><span class="cx">                     return;
</span><span class="cx">             }
</span><span class="lines">@@ -462,10 +462,10 @@
</span><span class="cx"> 
</span><span class="cx">     // If we are measuring the maximum width, verify each component.
</span><span class="cx">     if (calculateMaxPreferredWidth) {
</span><del>-        m_maxPreferredWidth = std::max<LayoutUnit>(m_maxPreferredWidth, advanceWidthForGlyph(topOrRight));
-        m_maxPreferredWidth = std::max<LayoutUnit>(m_maxPreferredWidth, advanceWidthForGlyph(extension));
-        m_maxPreferredWidth = std::max<LayoutUnit>(m_maxPreferredWidth, advanceWidthForGlyph(middle));
-        m_maxPreferredWidth = std::max<LayoutUnit>(m_maxPreferredWidth, advanceWidthForGlyph(bottomOrLeft));
</del><ins>+        m_maxPreferredWidth = std::max(m_maxPreferredWidth, LayoutUnit(advanceWidthForGlyph(topOrRight)));
+        m_maxPreferredWidth = std::max(m_maxPreferredWidth, LayoutUnit(advanceWidthForGlyph(extension)));
+        m_maxPreferredWidth = std::max(m_maxPreferredWidth, LayoutUnit(advanceWidthForGlyph(middle)));
+        m_maxPreferredWidth = std::max(m_maxPreferredWidth, LayoutUnit(advanceWidthForGlyph(bottomOrLeft)));
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -571,7 +571,7 @@
</span><span class="cx"> 
</span><span class="cx">     // Trimming may remove up to two pixels from the top of the extender glyph, so we move it up by two pixels.
</span><span class="cx">     float offsetToGlyphTop = glyphBounds.y() + 2;
</span><del>-    LayoutPoint glyphOrigin = LayoutPoint(from.x(), from.y() - offsetToGlyphTop);
</del><ins>+    LayoutPoint glyphOrigin { from.x(), LayoutUnit(from.y() - offsetToGlyphTop) };
</ins><span class="cx">     FloatRect lastPaintedGlyphRect(from, FloatSize());
</span><span class="cx"> 
</span><span class="cx">     // In practice, only small stretch sizes are requested but we limit the number of glyphs to avoid hangs.
</span><span class="lines">@@ -612,7 +612,7 @@
</span><span class="cx"> 
</span><span class="cx">     // Trimming may remove up to two pixels from the left of the extender glyph, so we move it left by two pixels.
</span><span class="cx">     float offsetToGlyphLeft = -2;
</span><del>-    LayoutPoint glyphOrigin = LayoutPoint(from.x() + offsetToGlyphLeft, from.y());
</del><ins>+    LayoutPoint glyphOrigin { LayoutUnit(from.x() + offsetToGlyphLeft), from.y() };
</ins><span class="cx">     FloatRect lastPaintedGlyphRect(from, FloatSize());
</span><span class="cx"> 
</span><span class="cx">     // In practice, only small stretch sizes are requested but we limit the number of glyphs to avoid hangs.
</span><span class="lines">@@ -645,11 +645,11 @@
</span><span class="cx">     // We are positioning the glyphs so that the edge of the tight glyph bounds line up exactly with the edges of our paint box.
</span><span class="cx">     LayoutPoint operatorTopLeft = paintOffset;
</span><span class="cx">     FloatRect topGlyphBounds = boundsForGlyph(topOrRight);
</span><del>-    LayoutPoint topGlyphOrigin(operatorTopLeft.x(), operatorTopLeft.y() - topGlyphBounds.y());
</del><ins>+    LayoutPoint topGlyphOrigin { operatorTopLeft.x(), LayoutUnit(operatorTopLeft.y() - topGlyphBounds.y()) };
</ins><span class="cx">     LayoutRect topGlyphPaintRect = paintGlyph(style, info, topOrRight, topGlyphOrigin, TrimBottom);
</span><span class="cx"> 
</span><span class="cx">     FloatRect bottomGlyphBounds = boundsForGlyph(bottomOrLeft);
</span><del>-    LayoutPoint bottomGlyphOrigin(operatorTopLeft.x(), operatorTopLeft.y() + stretchSize() - (bottomGlyphBounds.height() + bottomGlyphBounds.y()));
</del><ins>+    LayoutPoint bottomGlyphOrigin { operatorTopLeft.x(), LayoutUnit(operatorTopLeft.y() + stretchSize() - (bottomGlyphBounds.height() + bottomGlyphBounds.y())) };
</ins><span class="cx">     LayoutRect bottomGlyphPaintRect = paintGlyph(style, info, bottomOrLeft, bottomGlyphOrigin, TrimTop);
</span><span class="cx"> 
</span><span class="cx">     if (m_assembly.hasMiddle()) {
</span><span class="lines">@@ -690,7 +690,7 @@
</span><span class="cx">     LayoutRect leftGlyphPaintRect = paintGlyph(style, info, bottomOrLeft, leftGlyphOrigin, TrimRight);
</span><span class="cx"> 
</span><span class="cx">     FloatRect rightGlyphBounds = boundsForGlyph(topOrRight);
</span><del>-    LayoutPoint rightGlyphOrigin(operatorTopLeft.x() + stretchSize() - rightGlyphBounds.width(), baselineY);
</del><ins>+    LayoutPoint rightGlyphOrigin { LayoutUnit(operatorTopLeft.x() + stretchSize() - rightGlyphBounds.width()), baselineY };
</ins><span class="cx">     LayoutRect rightGlyphPaintRect = paintGlyph(style, info, topOrRight, rightGlyphOrigin, TrimLeft);
</span><span class="cx"> 
</span><span class="cx">     if (m_assembly.hasMiddle()) {
</span><span class="lines">@@ -745,7 +745,7 @@
</span><span class="cx">     buffer.add(glyphData.glyph, glyphData.font, advanceWidthForGlyph(glyphData));
</span><span class="cx">     LayoutPoint operatorTopLeft = paintOffset;
</span><span class="cx">     FloatRect glyphBounds = boundsForGlyph(glyphData);
</span><del>-    LayoutPoint operatorOrigin(operatorTopLeft.x(), operatorTopLeft.y() - glyphBounds.y());
</del><ins>+    LayoutPoint operatorOrigin { operatorTopLeft.x(), LayoutUnit(operatorTopLeft.y() - glyphBounds.y()) };
</ins><span class="cx">     paintInfo.context().drawGlyphs(*glyphData.font, buffer, 0, 1, operatorOrigin, style.fontCascade().fontDescription().fontSmoothing());
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -75,11 +75,11 @@
</span><span class="cx">     // If we have a MATH table we just return the AxisHeight constant.
</span><span class="cx">     const auto& primaryFont = style.fontCascade().primaryFont();
</span><span class="cx">     if (auto* mathData = primaryFont.mathData())
</span><del>-        return mathData->getMathConstant(primaryFont, OpenTypeMathData::AxisHeight);
</del><ins>+        return LayoutUnit(mathData->getMathConstant(primaryFont, OpenTypeMathData::AxisHeight));
</ins><span class="cx"> 
</span><span class="cx">     // Otherwise, the idea is to try and use the middle of operators as the math axis which we thus approximate by "half of the x-height".
</span><span class="cx">     // Note that Gecko has a slower but more accurate version that measures half of the height of U+2212 MINUS SIGN.
</span><del>-    return style.fontMetrics().xHeight() / 2;
</del><ins>+    return LayoutUnit(style.fontMetrics().xHeight() / 2);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit RenderMathMLBlock::mathAxisHeight() const
</span><span class="lines">@@ -145,29 +145,29 @@
</span><span class="cx">     switch (length.type) {
</span><span class="cx">     // Zoom for physical units needs to be accounted for.
</span><span class="cx">     case MathMLElement::LengthType::Cm:
</span><del>-        return style.effectiveZoom() * length.value * cssPixelsPerInch / 2.54f;
</del><ins>+        return LayoutUnit(style.effectiveZoom() * length.value * cssPixelsPerInch / 2.54f);
</ins><span class="cx">     case MathMLElement::LengthType::In:
</span><del>-        return style.effectiveZoom() * length.value * cssPixelsPerInch;
</del><ins>+        return LayoutUnit(style.effectiveZoom() * length.value * cssPixelsPerInch);
</ins><span class="cx">     case MathMLElement::LengthType::Mm:
</span><del>-        return style.effectiveZoom() * length.value * cssPixelsPerInch / 25.4f;
</del><ins>+        return LayoutUnit(style.effectiveZoom() * length.value * cssPixelsPerInch / 25.4f);
</ins><span class="cx">     case MathMLElement::LengthType::Pc:
</span><del>-        return style.effectiveZoom() * length.value * cssPixelsPerInch / 6;
</del><ins>+        return LayoutUnit(style.effectiveZoom() * length.value * cssPixelsPerInch / 6);
</ins><span class="cx">     case MathMLElement::LengthType::Pt:
</span><del>-        return style.effectiveZoom() * length.value * cssPixelsPerInch / 72;
</del><ins>+        return LayoutUnit(style.effectiveZoom() * length.value * cssPixelsPerInch / 72);
</ins><span class="cx">     case MathMLElement::LengthType::Px:
</span><del>-        return style.effectiveZoom() * length.value;
</del><ins>+        return LayoutUnit(style.effectiveZoom() * length.value);
</ins><span class="cx"> 
</span><span class="cx">     // Zoom for logical units is accounted for either in the font info or referenceValue.
</span><span class="cx">     case MathMLElement::LengthType::Em:
</span><del>-        return length.value * style.fontCascade().size();
</del><ins>+        return LayoutUnit(length.value * style.fontCascade().size());
</ins><span class="cx">     case MathMLElement::LengthType::Ex:
</span><del>-        return length.value * style.fontMetrics().xHeight();
</del><ins>+        return LayoutUnit(length.value * style.fontMetrics().xHeight());
</ins><span class="cx">     case MathMLElement::LengthType::MathUnit:
</span><del>-        return length.value * style.fontCascade().size() / 18;
</del><ins>+        return LayoutUnit(length.value * style.fontCascade().size() / 18);
</ins><span class="cx">     case MathMLElement::LengthType::Percentage:
</span><del>-        return referenceValue * length.value / 100;
</del><ins>+        return LayoutUnit(referenceValue * length.value / 100);
</ins><span class="cx">     case MathMLElement::LengthType::UnitLess:
</span><del>-        return referenceValue * length.value;
</del><ins>+        return LayoutUnit(referenceValue * length.value);
</ins><span class="cx">     case MathMLElement::LengthType::ParsingFailed:
</span><span class="cx">         return referenceValue;
</span><span class="cx">     case MathMLElement::LengthType::Infinity:
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLBlockh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.h        2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.h   2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -71,7 +71,7 @@
</span><span class="cx">         // This function returns a value for the default rule thickness (TeX's \xi_8) to be used as a fallback when we lack a MATH table.
</span><span class="cx">         // This arbitrary value of 0.05em was used in early WebKit MathML implementations for the thickness of the fraction bars.
</span><span class="cx">         // Note that Gecko has a slower but more accurate version that measures the thickness of U+00AF MACRON to be more accurate and otherwise fallback to some arbitrary value.
</span><del>-        return 0.05f * style().fontCascade().size();
</del><ins>+        return LayoutUnit(0.05f * style().fontCascade().size());
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     LayoutUnit mathAxisHeight() const;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLFencedOperatorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLFencedOperator.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLFencedOperator.h       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLFencedOperator.h  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -47,7 +47,7 @@
</span><span class="cx">     LayoutUnit trailingSpace() const final;
</span><span class="cx"> 
</span><span class="cx">     // minsize always has the default value "1em".
</span><del>-    LayoutUnit minSize() const final { return style().fontCascade().size(); }
</del><ins>+    LayoutUnit minSize() const final { return LayoutUnit(style().fontCascade().size()); }
</ins><span class="cx"> 
</span><span class="cx">     // maxsize always has the default value "infinity".
</span><span class="cx">     LayoutUnit maxSize() const final { return intMaxForLayoutUnit; }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLFractioncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -72,7 +72,7 @@
</span><span class="cx"> {
</span><span class="cx">     const auto& primaryFont = style().fontCascade().primaryFont();
</span><span class="cx">     if (const auto* mathData = primaryFont.mathData())
</span><del>-        return mathData->getMathConstant(primaryFont, OpenTypeMathData::FractionRuleThickness);
</del><ins>+        return LayoutUnit(mathData->getMathConstant(primaryFont, OpenTypeMathData::FractionRuleThickness));
</ins><span class="cx">     return ruleThicknessFallback();
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -267,7 +267,7 @@
</span><span class="cx">     info.context().setStrokeThickness(thickness);
</span><span class="cx">     info.context().setStrokeStyle(SolidStroke);
</span><span class="cx">     info.context().setStrokeColor(style().visitedDependentColorWithColorFilter(CSSPropertyColor));
</span><del>-    info.context().drawLine(adjustedPaintOffset, roundedIntPoint(LayoutPoint(adjustedPaintOffset.x() + logicalWidth(), adjustedPaintOffset.y())));
</del><ins>+    info.context().drawLine(adjustedPaintOffset, roundedIntPoint(LayoutPoint(adjustedPaintOffset.x() + logicalWidth(), LayoutUnit(adjustedPaintOffset.y()))));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> Optional<int> RenderMathMLFraction::firstLineBaseline() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLMenclosecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLMenclose.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLMenclose.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLMenclose.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -59,7 +59,7 @@
</span><span class="cx"> // See https://bugs.webkit.org/show_bug.cgi?id=122297
</span><span class="cx"> LayoutUnit RenderMathMLMenclose::ruleThickness() const
</span><span class="cx"> {
</span><del>-    return 0.05f * style().fontCascade().size();
</del><ins>+    return LayoutUnit(0.05f * style().fontCascade().size());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RenderMathMLMenclose::SpaceAroundContent RenderMathMLMenclose::spaceAroundContent(LayoutUnit contentWidth, LayoutUnit contentHeight) const
</span><span class="lines">@@ -139,7 +139,7 @@
</span><span class="cx">     // - We add extra margin of \xi_8
</span><span class="cx">     // Then for example the top space is \sqrt{2}contentHeight/2 - contentHeight/2 + \xi_8/2 + \xi_8.
</span><span class="cx">     if (hasNotation(MathMLMencloseElement::Circle)) {
</span><del>-        LayoutUnit extraSpace = (contentWidth * (sqrtOfTwoFloat - 1) + 3 * thickness) / 2;
</del><ins>+        LayoutUnit extraSpace { (contentWidth * (sqrtOfTwoFloat - 1) + 3 * thickness) / 2 };
</ins><span class="cx">         space.left = std::max(space.left, extraSpace);
</span><span class="cx">         space.right = std::max(space.right, extraSpace);
</span><span class="cx">         extraSpace = (contentHeight * (sqrtOfTwoFloat - 1) + 3 * thickness) / 2;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLOperatorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp   2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp      2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -100,7 +100,7 @@
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit RenderMathMLOperator::minSize() const
</span><span class="cx"> {
</span><del>-    LayoutUnit minSize = style().fontCascade().size(); // Default minsize is "1em".
</del><ins>+    LayoutUnit minSize { style().fontCascade().size() }; // Default minsize is "1em".
</ins><span class="cx">     minSize = toUserUnits(element().minSize(), style(), minSize);
</span><span class="cx">     return std::max<LayoutUnit>(0, minSize);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLRootcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -219,7 +219,7 @@
</span><span class="cx">     // We can then determine the metrics of the radical operator + the base.
</span><span class="cx">     m_radicalOperator.stretchTo(style(), baseAscent + baseDescent);
</span><span class="cx">     LayoutUnit radicalOperatorHeight = m_radicalOperator.ascent() + m_radicalOperator.descent();
</span><del>-    LayoutUnit indexBottomRaise = vertical.degreeBottomRaisePercent * radicalOperatorHeight;
</del><ins>+    LayoutUnit indexBottomRaise { vertical.degreeBottomRaisePercent * radicalOperatorHeight };
</ins><span class="cx">     LayoutUnit radicalAscent = baseAscent + vertical.verticalGap + vertical.ruleThickness + vertical.extraAscender;
</span><span class="cx">     LayoutUnit radicalDescent = std::max<LayoutUnit>(baseDescent, radicalOperatorHeight + vertical.extraAscender - radicalAscent);
</span><span class="cx">     LayoutUnit descent = radicalDescent;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLScriptscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -158,8 +158,8 @@
</span><span class="cx"> {
</span><span class="cx">     const auto& primaryFont = style().fontCascade().primaryFont();
</span><span class="cx">     if (auto* mathData = primaryFont.mathData())
</span><del>-        return mathData->getMathConstant(primaryFont, OpenTypeMathData::SpaceAfterScript);
-    return style().fontCascade().size() / 5;
</del><ins>+        return LayoutUnit(mathData->getMathConstant(primaryFont, OpenTypeMathData::SpaceAfterScript));
+    return LayoutUnit(style().fontCascade().size() / 5);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> LayoutUnit RenderMathMLScripts::italicCorrection(const ReferenceChildren& reference)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingmathmlRenderMathMLTokencpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/mathml/RenderMathMLToken.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/mathml/RenderMathMLToken.cpp      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/mathml/RenderMathMLToken.cpp 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -583,8 +583,8 @@
</span><span class="cx">     for (auto* child = firstChildBox(); child; child = child->nextSiblingBox())
</span><span class="cx">         child->layoutIfNeeded();
</span><span class="cx"> 
</span><del>-    setLogicalWidth(mathVariantGlyph.font->widthForGlyph(mathVariantGlyph.glyph));
-    setLogicalHeight(mathVariantGlyph.font->boundsForGlyph(mathVariantGlyph.glyph).height());
</del><ins>+    setLogicalWidth(LayoutUnit(mathVariantGlyph.font->widthForGlyph(mathVariantGlyph.glyph)));
+    setLogicalHeight(LayoutUnit(mathVariantGlyph.font->boundsForGlyph(mathVariantGlyph.glyph).height()));
</ins><span class="cx"> 
</span><span class="cx">     updateScrollInfoAfterLayout();
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingshapesBoxShapecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/shapes/BoxShape.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/shapes/BoxShape.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/shapes/BoxShape.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -43,7 +43,7 @@
</span><span class="cx"> 
</span><span class="cx">     LayoutUnit ratio = radius / margin;
</span><span class="cx">     if (ratio < 1)
</span><del>-        return radius + (margin * (1 + pow(ratio - 1, 3.0)));
</del><ins>+        return LayoutUnit(radius + (margin * (1 + pow(ratio - 1, 3.0))));
</ins><span class="cx"> 
</span><span class="cx">     return radius + margin;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingshapesShapeOutsideInfocpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -337,11 +337,11 @@
</span><span class="cx">             LineSegment segment = computedShape().getExcludedInterval((borderBoxLineTop - logicalTopOffset()), std::min(lineHeight, shapeLogicalBottom() - borderBoxLineTop));
</span><span class="cx">             if (segment.isValid) {
</span><span class="cx">                 LayoutUnit logicalLeftMargin = containingBlock.style().isLeftToRightDirection() ? containingBlock.marginStartForChild(m_renderer) : containingBlock.marginEndForChild(m_renderer);
</span><del>-                LayoutUnit rawLeftMarginBoxDelta = segment.logicalLeft + logicalLeftOffset() + logicalLeftMargin;
</del><ins>+                LayoutUnit rawLeftMarginBoxDelta { segment.logicalLeft + logicalLeftOffset() + logicalLeftMargin };
</ins><span class="cx">                 LayoutUnit leftMarginBoxDelta = clampTo<LayoutUnit>(rawLeftMarginBoxDelta, 0_lu, floatMarginBoxWidth);
</span><span class="cx"> 
</span><span class="cx">                 LayoutUnit logicalRightMargin = containingBlock.style().isLeftToRightDirection() ? containingBlock.marginEndForChild(m_renderer) : containingBlock.marginStartForChild(m_renderer);
</span><del>-                LayoutUnit rawRightMarginBoxDelta = segment.logicalRight + logicalLeftOffset() - containingBlock.logicalWidthForChild(m_renderer) - logicalRightMargin;
</del><ins>+                LayoutUnit rawRightMarginBoxDelta { segment.logicalRight + logicalLeftOffset() - containingBlock.logicalWidthForChild(m_renderer) - logicalRightMargin };
</ins><span class="cx">                 LayoutUnit rightMarginBoxDelta = clampTo<LayoutUnit>(rawRightMarginBoxDelta, -floatMarginBoxWidth, 0_lu);
</span><span class="cx"> 
</span><span class="cx">                 m_shapeOutsideDeltas = ShapeOutsideDeltas(leftMarginBoxDelta, rightMarginBoxDelta, true, borderBoxLineTop, lineHeight);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleCollapsedBorderValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/CollapsedBorderValue.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/CollapsedBorderValue.h      2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/style/CollapsedBorderValue.h 2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -72,7 +72,7 @@
</span><span class="cx"> inline LayoutUnit CollapsedBorderValue::adjustedCollapsedBorderWidth(float borderWidth, float deviceScaleFactor, bool roundUp)
</span><span class="cx"> {
</span><span class="cx">     float halfCollapsedBorderWidth = (borderWidth + (roundUp ? (1 / deviceScaleFactor) : 0)) / 2;
</span><del>-    return floorToDevicePixel(halfCollapsedBorderWidth, deviceScaleFactor);
</del><ins>+    return LayoutUnit(floorToDevicePixel(halfCollapsedBorderWidth, deviceScaleFactor));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleNinePieceImagecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/NinePieceImage.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/NinePieceImage.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/style/NinePieceImage.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -53,7 +53,7 @@
</span><span class="cx"> LayoutUnit NinePieceImage::computeSlice(Length length, LayoutUnit width, LayoutUnit slice, LayoutUnit extent)
</span><span class="cx"> {
</span><span class="cx">     if (length.isRelative())
</span><del>-        return length.value() * width;
</del><ins>+        return LayoutUnit(length.value() * width);
</ins><span class="cx">     if (length.isAuto())
</span><span class="cx">         return slice;
</span><span class="cx">     return valueForLength(length, extent);
</span><span class="lines">@@ -72,17 +72,17 @@
</span><span class="cx"> LayoutBoxExtent NinePieceImage::computeSlices(const LayoutSize& size, const LengthBox& lengths, const FloatBoxExtent& widths, const LayoutBoxExtent& slices)
</span><span class="cx"> {
</span><span class="cx">     return {
</span><del>-        computeSlice(lengths.top(), widths.top(), slices.top(), size.height()),
-        computeSlice(lengths.right(), widths.right(), slices.right(), size.width()),
-        computeSlice(lengths.bottom(), widths.bottom(), slices.bottom(), size.height()),
-        computeSlice(lengths.left(), widths.left(), slices.left(), size.width())
</del><ins>+        computeSlice(lengths.top(), LayoutUnit(widths.top()), slices.top(), size.height()),
+        computeSlice(lengths.right(), LayoutUnit(widths.right()), slices.right(), size.width()),
+        computeSlice(lengths.bottom(), LayoutUnit(widths.bottom()), slices.bottom(), size.height()),
+        computeSlice(lengths.left(), LayoutUnit(widths.left()), slices.left(), size.width())
</ins><span class="cx">     };
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void NinePieceImage::scaleSlicesIfNeeded(const LayoutSize& size, LayoutBoxExtent& slices, float deviceScaleFactor)
</span><span class="cx"> {
</span><del>-    LayoutUnit width  = std::max<LayoutUnit>(1 / deviceScaleFactor, slices.left() + slices.right());
-    LayoutUnit height = std::max<LayoutUnit>(1 / deviceScaleFactor, slices.top() + slices.bottom());
</del><ins>+    LayoutUnit width  = std::max(LayoutUnit(1 / deviceScaleFactor), slices.left() + slices.right());
+    LayoutUnit height = std::max(LayoutUnit(1 / deviceScaleFactor), slices.top() + slices.bottom());
</ins><span class="cx"> 
</span><span class="cx">     float sliceScaleFactor = std::min((float)size.width() / width, (float)size.height() / height);
</span><span class="cx"> 
</span><span class="lines">@@ -120,18 +120,18 @@
</span><span class="cx"> 
</span><span class="cx">     Vector<FloatRect> rects(MaxPiece);
</span><span class="cx"> 
</span><del>-    rects[TopLeftPiece]     = snapRectToDevicePixels(outer.x(),    outer.y(),    slices.left(),  slices.top(),    deviceScaleFactor);
-    rects[BottomLeftPiece]  = snapRectToDevicePixels(outer.x(),    inner.maxY(), slices.left(),  slices.bottom(), deviceScaleFactor);
-    rects[LeftPiece]        = snapRectToDevicePixels(outer.x(),    inner.y(),    slices.left(),  inner.height(),  deviceScaleFactor);
</del><ins>+    rects[TopLeftPiece] = snapRectToDevicePixels(LayoutUnit(outer.x()), LayoutUnit(outer.y()), slices.left(), slices.top(), deviceScaleFactor);
+    rects[BottomLeftPiece] = snapRectToDevicePixels(LayoutUnit(outer.x()), LayoutUnit(inner.maxY()), slices.left(), slices.bottom(), deviceScaleFactor);
+    rects[LeftPiece] = snapRectToDevicePixels(LayoutUnit(outer.x()), LayoutUnit(inner.y()), slices.left(), LayoutUnit(inner.height()), deviceScaleFactor);
</ins><span class="cx"> 
</span><del>-    rects[TopRightPiece]    = snapRectToDevicePixels(inner.maxX(), outer.y(),    slices.right(), slices.top(),    deviceScaleFactor);
-    rects[BottomRightPiece] = snapRectToDevicePixels(inner.maxX(), inner.maxY(), slices.right(), slices.bottom(), deviceScaleFactor);
-    rects[RightPiece]       = snapRectToDevicePixels(inner.maxX(), inner.y(),    slices.right(), inner.height(),  deviceScaleFactor);
</del><ins>+    rects[TopRightPiece] = snapRectToDevicePixels(LayoutUnit(inner.maxX()), LayoutUnit(outer.y()), slices.right(), slices.top(), deviceScaleFactor);
+    rects[BottomRightPiece] = snapRectToDevicePixels(LayoutUnit(inner.maxX()), LayoutUnit(inner.maxY()), slices.right(), slices.bottom(), deviceScaleFactor);
+    rects[RightPiece] = snapRectToDevicePixels(LayoutUnit(inner.maxX()), LayoutUnit(inner.y()), slices.right(), LayoutUnit(inner.height()), deviceScaleFactor);
</ins><span class="cx"> 
</span><del>-    rects[TopPiece]         = snapRectToDevicePixels(inner.x(),    outer.y(),    inner.width(),  slices.top(),    deviceScaleFactor);
-    rects[BottomPiece]      = snapRectToDevicePixels(inner.x(),    inner.maxY(), inner.width(),  slices.bottom(), deviceScaleFactor);
</del><ins>+    rects[TopPiece] = snapRectToDevicePixels(LayoutUnit(inner.x()), LayoutUnit(outer.y()), LayoutUnit(inner.width()), slices.top(), deviceScaleFactor);
+    rects[BottomPiece] = snapRectToDevicePixels(LayoutUnit(inner.x()), LayoutUnit(inner.maxY()), LayoutUnit(inner.width()), slices.bottom(), deviceScaleFactor);
</ins><span class="cx"> 
</span><del>-    rects[MiddlePiece]      = snapRectToDevicePixels(inner.x(),    inner.y(),    inner.width(),  inner.height(),  deviceScaleFactor);
</del><ins>+    rects[MiddlePiece] = snapRectToDevicePixels(LayoutUnit(inner.x()), LayoutUnit(inner.y()), LayoutUnit(inner.width()), LayoutUnit(inner.height()), deviceScaleFactor);
</ins><span class="cx">     return rects;
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleNinePieceImageh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/NinePieceImage.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/NinePieceImage.h    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/style/NinePieceImage.h       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -160,8 +160,8 @@
</span><span class="cx">     static LayoutUnit computeOutset(const Length& outsetSide, LayoutUnit borderSide)
</span><span class="cx">     {
</span><span class="cx">         if (outsetSide.isRelative())
</span><del>-            return outsetSide.value() * borderSide;
-        return outsetSide.value();
</del><ins>+            return LayoutUnit(outsetSide.value() * borderSide);
+        return LayoutUnit(outsetSide.value());
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     static LayoutUnit computeSlice(Length, LayoutUnit width, LayoutUnit slice, LayoutUnit extent);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleRenderStylecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/RenderStyle.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/RenderStyle.cpp     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/style/RenderStyle.cpp        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -1423,10 +1423,10 @@
</span><span class="cx"> RoundedRect RenderStyle::getRoundedInnerBorderFor(const LayoutRect& borderRect, bool includeLogicalLeftEdge, bool includeLogicalRightEdge) const
</span><span class="cx"> {
</span><span class="cx">     bool horizontal = isHorizontalWritingMode();
</span><del>-    auto leftWidth = (!horizontal || includeLogicalLeftEdge) ? borderLeftWidth() : 0;
-    auto rightWidth = (!horizontal || includeLogicalRightEdge) ? borderRightWidth() : 0;
-    auto topWidth = (horizontal || includeLogicalLeftEdge) ? borderTopWidth() : 0;
-    auto bottomWidth = (horizontal || includeLogicalRightEdge) ? borderBottomWidth() : 0;
</del><ins>+    LayoutUnit leftWidth { (!horizontal || includeLogicalLeftEdge) ? borderLeftWidth() : 0 };
+    LayoutUnit rightWidth { (!horizontal || includeLogicalRightEdge) ? borderRightWidth() : 0 };
+    LayoutUnit topWidth { (horizontal || includeLogicalLeftEdge) ? borderTopWidth() : 0 };
+    LayoutUnit bottomWidth { (horizontal || includeLogicalRightEdge) ? borderBottomWidth() : 0 };
</ins><span class="cx">     return getRoundedInnerBorderFor(borderRect, topWidth, bottomWidth, leftWidth, rightWidth, includeLogicalLeftEdge, includeLogicalRightEdge);
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -2127,10 +2127,12 @@
</span><span class="cx"> 
</span><span class="cx"> LayoutBoxExtent RenderStyle::imageOutsets(const NinePieceImage& image) const
</span><span class="cx"> {
</span><del>-    return LayoutBoxExtent(NinePieceImage::computeOutset(image.outset().top(), borderTopWidth()),
-                           NinePieceImage::computeOutset(image.outset().right(), borderRightWidth()),
-                           NinePieceImage::computeOutset(image.outset().bottom(), borderBottomWidth()),
-                           NinePieceImage::computeOutset(image.outset().left(), borderLeftWidth()));
</del><ins>+    return {
+        NinePieceImage::computeOutset(image.outset().top(), LayoutUnit(borderTopWidth())),
+        NinePieceImage::computeOutset(image.outset().right(), LayoutUnit(borderRightWidth())),
+        NinePieceImage::computeOutset(image.outset().bottom(), LayoutUnit(borderBottomWidth())),
+        NinePieceImage::computeOutset(image.outset().left(), LayoutUnit(borderLeftWidth()))
+    };
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> std::pair<FontOrientation, NonCJKGlyphOrientation> RenderStyle::fontAndGlyphOrientation()
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleRenderStyleh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/RenderStyle.h (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/RenderStyle.h       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/style/RenderStyle.h  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2025,7 +2025,7 @@
</span><span class="cx"> 
</span><span class="cx"> inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const RenderStyle& style)
</span><span class="cx"> {
</span><del>-    return value / style.effectiveZoom();
</del><ins>+    return LayoutUnit(value / style.effectiveZoom());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> inline BorderStyle collapsedBorderStyle(BorderStyle style)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingsvgRenderSVGTextcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp     2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp        2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -471,7 +471,7 @@
</span><span class="cx">     if (!closestBox)
</span><span class="cx">         return createVisiblePosition(0, DOWNSTREAM);
</span><span class="cx"> 
</span><del>-    return closestBox->renderer().positionForPoint(LayoutPoint(pointInContents.x(), closestBox->y()), fragment);
</del><ins>+    return closestBox->renderer().positionForPoint({ pointInContents.x(), LayoutUnit(closestBox->y()) }, fragment);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void RenderSVGText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingsvgSVGInlineTextBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/svg/SVGInlineTextBox.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/svg/SVGInlineTextBox.cpp  2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebCore/rendering/svg/SVGInlineTextBox.cpp     2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -123,7 +123,7 @@
</span><span class="cx"> 
</span><span class="cx">     textOrigin.move(0, -scaledFontMetrics.floatAscent());
</span><span class="cx"> 
</span><del>-    LayoutRect selectionRect = LayoutRect(textOrigin, LayoutSize(0, fragment.height * scalingFactor));
</del><ins>+    LayoutRect selectionRect { textOrigin, LayoutSize(0, LayoutUnit(fragment.height * scalingFactor)) };
</ins><span class="cx">     TextRun run = constructTextRun(style, fragment);
</span><span class="cx">     scaledFont.adjustSelectionRectForText(run, selectionRect, startPosition, endPosition);
</span><span class="cx">     FloatRect snappedSelectionRect = snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), run.ltr());
</span></span></pre></div>
<a id="trunkSourceWebKitChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/ChangeLog (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/ChangeLog    2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebKit/ChangeLog       2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -1,3 +1,14 @@
</span><ins>+2019-05-20  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Make lossy LayoutUnit constructors explicit
+        https://bugs.webkit.org/show_bug.cgi?id=191811
+
+        Reviewed by Antti Koivisto.
+
+        * WebProcess/WebPage/WebPage.cpp:
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        Make usage of LayoutUnit(float) explicit.
+
</ins><span class="cx"> 2019-05-20  Per Arne Vollan  <pvollan@apple.com>
</span><span class="cx"> 
</span><span class="cx">         [iOS] WebKit crash loop
</span></span></pre></div>
<a id="trunkSourceWebKitWebProcessWebPageWebPagecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp       2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp  2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -5923,8 +5923,8 @@
</span><span class="cx">             IntRect elementRectRelativeToView = element->clientRect();
</span><span class="cx">             IntRect elementRectRelativeToTopDocument(elementRectRelativeToView.location() + scrollPosition, elementRectRelativeToView.size());
</span><span class="cx">             LayoutRect inflatedPluginRect = plugInRectRelativeToTopDocument;
</span><del>-            LayoutUnit xOffset = (inflatedPluginRect.width() * overlappingImageBoundsScale - inflatedPluginRect.width()) / 2;
-            LayoutUnit yOffset = (inflatedPluginRect.height() * overlappingImageBoundsScale - inflatedPluginRect.height()) / 2;
</del><ins>+            LayoutUnit xOffset { (inflatedPluginRect.width() * overlappingImageBoundsScale - inflatedPluginRect.width()) / 2 };
+            LayoutUnit yOffset { (inflatedPluginRect.height() * overlappingImageBoundsScale - inflatedPluginRect.height()) / 2 };
</ins><span class="cx">             inflatedPluginRect.inflateX(xOffset);
</span><span class="cx">             inflatedPluginRect.inflateY(yOffset);
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebKitWebProcessWebPageiosWebPageIOSmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm (245542 => 245543)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm 2019-05-21 01:09:44 UTC (rev 245542)
+++ trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm    2019-05-21 01:36:11 UTC (rev 245543)
</span><span class="lines">@@ -2902,8 +2902,11 @@
</span><span class="cx"> 
</span><span class="cx"> FloatSize WebPage::viewLayoutSizeAdjustedForQuirks(const FloatSize& size)
</span><span class="cx"> {
</span><del>-    if (auto* document = m_page->mainFrame().document())
-        return { document->quirks().overriddenViewLayoutWidth(size.width()).valueOr(size.width()), size.height() };
</del><ins>+    if (auto* document = m_page->mainFrame().document()) {
+        LayoutUnit width { size.width() };
+        return { document->quirks().overriddenViewLayoutWidth(width).valueOr(width), size.height() };
+    }
+
</ins><span class="cx">     return size;
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre>
</div>
</div>

</body>
</html>