<!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>[167937] trunk/Source/WebCore</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/167937">167937</a></dd>
<dt>Author</dt> <dd>bjonesbe@adobe.com</dd>
<dt>Date</dt> <dd>2014-04-29 09:36:43 -0700 (Tue, 29 Apr 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Wrap CSS length conversion arguments in an object
https://bugs.webkit.org/show_bug.cgi?id=131552
Reviewed by Andreas Kling.
This patch introduces a class CSSToLengthConversionData to wrap the
data required to convert CSS lengths to Lengths. This simplifies the
plumbing that goes on whenever we need to resolve CSS lengths and
makes it easier to update the arguments needed for resolving these (in
particular adding a RenderView for resolving viewport units at style
recalc time; removing the computingFontSize bool also appears
possible).
Note that the zoom argument, which was previously a float in some
places and a double in others is now a float.
This is a port of a Blink patch by timloh@chromium.org.
No new tests, no behavior change.
* CMakeLists.txt:
* WebCore.vcxproj/WebCore.vcxproj:
* WebCore.xcodeproj/project.pbxproj:
* css/BasicShapeFunctions.cpp:
(WebCore::convertToLength):
(WebCore::convertToLengthSize):
(WebCore::convertToCenterCoordinate):
(WebCore::cssValueToBasicShapeRadius):
(WebCore::basicShapeForValue):
* css/BasicShapeFunctions.h:
* css/CSSCalculationValue.cpp:
(WebCore::CSSCalcValue::computeLengthPx):
(WebCore::determineCategory):
* css/CSSCalculationValue.h:
(WebCore::CSSCalcValue::createCalculationValue):
* css/CSSGradientValue.cpp:
(WebCore::CSSGradientValue::addStops):
(WebCore::positionFromValue):
(WebCore::CSSGradientValue::computeEndPoint):
(WebCore::CSSLinearGradientValue::createGradient):
(WebCore::CSSRadialGradientValue::resolveRadius):
(WebCore::CSSRadialGradientValue::createGradient):
* css/CSSGradientValue.h:
* css/CSSPrimitiveValue.cpp:
(WebCore::CSSPrimitiveValue::computeLength):
(WebCore::CSSPrimitiveValue::computeLengthDouble):
* css/CSSPrimitiveValue.h:
* css/CSSPrimitiveValueMappings.h:
(WebCore::CSSPrimitiveValue::convertToLength):
* css/CSSToLengthConversionData.cpp: Added.
(WebCore::CSSToLengthConversionData::zoom):
* css/CSSToLengthConversionData.h: Added.
(WebCore::CSSToLengthConversionData::CSSToLengthConversionData):
(WebCore::CSSToLengthConversionData::style):
(WebCore::CSSToLengthConversionData::rootStyle):
(WebCore::CSSToLengthConversionData::computingFontSize):
(WebCore::CSSToLengthConversionData::copyWithAdjustedZoom):
* css/CSSToStyleMap.cpp:
(WebCore::CSSToStyleMap::CSSToStyleMap):
(WebCore::CSSToStyleMap::mapFillSize):
(WebCore::CSSToStyleMap::mapFillXPosition):
(WebCore::CSSToStyleMap::mapFillYPosition):
(WebCore::CSSToStyleMap::mapNinePieceImageQuad):
* css/CSSToStyleMap.h:
(WebCore::CSSToStyleMap::CSSToStyleMap): Deleted.
* css/DeprecatedStyleBuilder.cpp:
(WebCore::ApplyPropertyAuto::applyValue):
(WebCore::ApplyPropertyClip::convertToLength):
(WebCore::ApplyPropertyLength::applyValue):
(WebCore::ApplyPropertyBorderRadius::applyValue):
(WebCore::ApplyPropertyComputeLength::applyValue):
(WebCore::ApplyPropertyFontSize::applyValue):
(WebCore::csstoLengthConversionDataWithTextZoomFactor):
(WebCore::ApplyPropertyMarqueeIncrement::applyValue):
(WebCore::ApplyPropertyLineHeight::applyValue):
(WebCore::ApplyPropertyLineHeightForIOSTextAutosizing::applyValue):
(WebCore::ApplyPropertyWordSpacing::applyValue):
(WebCore::ApplyPropertyPageSize::mmLength):
(WebCore::ApplyPropertyPageSize::inchLength):
(WebCore::ApplyPropertyPageSize::applyValue):
(WebCore::ApplyPropertyVerticalAlign::applyValue):
(WebCore::ApplyPropertyClipPath::applyValue):
(WebCore::ApplyPropertyShape::applyValue):
(WebCore::ApplyPropertyTextIndent::applyValue):
* css/MediaQueryEvaluator.cpp:
(WebCore::colorMediaFeatureEval):
(WebCore::color_indexMediaFeatureEval):
(WebCore::monochromeMediaFeatureEval):
(WebCore::orientationMediaFeatureEval):
(WebCore::aspect_ratioMediaFeatureEval):
(WebCore::device_aspect_ratioMediaFeatureEval):
(WebCore::device_pixel_ratioMediaFeatureEval):
(WebCore::resolutionMediaFeatureEval):
(WebCore::gridMediaFeatureEval):
(WebCore::computeLength):
(WebCore::device_heightMediaFeatureEval):
(WebCore::device_widthMediaFeatureEval):
(WebCore::heightMediaFeatureEval):
(WebCore::widthMediaFeatureEval):
(WebCore::min_colorMediaFeatureEval):
(WebCore::max_colorMediaFeatureEval):
(WebCore::min_color_indexMediaFeatureEval):
(WebCore::max_color_indexMediaFeatureEval):
(WebCore::min_monochromeMediaFeatureEval):
(WebCore::max_monochromeMediaFeatureEval):
(WebCore::min_aspect_ratioMediaFeatureEval):
(WebCore::max_aspect_ratioMediaFeatureEval):
(WebCore::min_device_aspect_ratioMediaFeatureEval):
(WebCore::max_device_aspect_ratioMediaFeatureEval):
(WebCore::min_device_pixel_ratioMediaFeatureEval):
(WebCore::max_device_pixel_ratioMediaFeatureEval):
(WebCore::min_heightMediaFeatureEval):
(WebCore::max_heightMediaFeatureEval):
(WebCore::min_widthMediaFeatureEval):
(WebCore::max_widthMediaFeatureEval):
(WebCore::min_device_heightMediaFeatureEval):
(WebCore::max_device_heightMediaFeatureEval):
(WebCore::min_device_widthMediaFeatureEval):
(WebCore::max_device_widthMediaFeatureEval):
(WebCore::min_resolutionMediaFeatureEval):
(WebCore::max_resolutionMediaFeatureEval):
(WebCore::animationMediaFeatureEval):
(WebCore::transitionMediaFeatureEval):
(WebCore::transform_2dMediaFeatureEval):
(WebCore::transform_3dMediaFeatureEval):
(WebCore::view_modeMediaFeatureEval):
(WebCore::video_playable_inlineMediaFeatureEval):
(WebCore::hoverMediaFeatureEval):
(WebCore::pointerMediaFeatureEval):
(WebCore::MediaQueryEvaluator::eval):
* css/SVGCSSStyleSelector.cpp:
(WebCore::StyleResolver::applySVGProperty):
* css/StyleResolver.cpp:
(WebCore::StyleResolver::State::clear):
(WebCore::StyleResolver::State::initForStyleResolve):
(WebCore::StyleResolver::convertToIntLength):
(WebCore::StyleResolver::convertToFloatLength):
(WebCore::createGridTrackBreadth):
(WebCore::StyleResolver::applyProperty):
(WebCore::StyleResolver::createFilterOperations):
* css/StyleResolver.h:
(WebCore::StyleResolver::State::setStyle):
(WebCore::StyleResolver::State::cssToLengthConversionData):
* css/TransformFunctions.cpp:
(WebCore::convertToFloatLength):
(WebCore::transformsForValue):
* css/TransformFunctions.h:
* css/WebKitCSSMatrix.cpp:
(WebCore::WebKitCSSMatrix::setMatrixValue):
* rendering/RenderThemeIOS.mm:
(WebCore::applyCommonButtonPaddingToStyle):
(WebCore::RenderThemeIOS::adjustButtonStyle):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreCMakeListstxt">trunk/Source/WebCore/CMakeLists.txt</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreWebCorevcxprojWebCorevcxproj">trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj</a></li>
<li><a href="#trunkSourceWebCoreWebCorexcodeprojprojectpbxproj">trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj</a></li>
<li><a href="#trunkSourceWebCorecssBasicShapeFunctionscpp">trunk/Source/WebCore/css/BasicShapeFunctions.cpp</a></li>
<li><a href="#trunkSourceWebCorecssBasicShapeFunctionsh">trunk/Source/WebCore/css/BasicShapeFunctions.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSCalculationValuecpp">trunk/Source/WebCore/css/CSSCalculationValue.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSCalculationValueh">trunk/Source/WebCore/css/CSSCalculationValue.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSGradientValuecpp">trunk/Source/WebCore/css/CSSGradientValue.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSGradientValueh">trunk/Source/WebCore/css/CSSGradientValue.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSPrimitiveValuecpp">trunk/Source/WebCore/css/CSSPrimitiveValue.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSPrimitiveValueh">trunk/Source/WebCore/css/CSSPrimitiveValue.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSPrimitiveValueMappingsh">trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSToStyleMapcpp">trunk/Source/WebCore/css/CSSToStyleMap.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSToStyleMaph">trunk/Source/WebCore/css/CSSToStyleMap.h</a></li>
<li><a href="#trunkSourceWebCorecssDeprecatedStyleBuildercpp">trunk/Source/WebCore/css/DeprecatedStyleBuilder.cpp</a></li>
<li><a href="#trunkSourceWebCorecssMediaQueryEvaluatorcpp">trunk/Source/WebCore/css/MediaQueryEvaluator.cpp</a></li>
<li><a href="#trunkSourceWebCorecssSVGCSSStyleSelectorcpp">trunk/Source/WebCore/css/SVGCSSStyleSelector.cpp</a></li>
<li><a href="#trunkSourceWebCorecssStyleResolvercpp">trunk/Source/WebCore/css/StyleResolver.cpp</a></li>
<li><a href="#trunkSourceWebCorecssStyleResolverh">trunk/Source/WebCore/css/StyleResolver.h</a></li>
<li><a href="#trunkSourceWebCorecssTransformFunctionscpp">trunk/Source/WebCore/css/TransformFunctions.cpp</a></li>
<li><a href="#trunkSourceWebCorecssTransformFunctionsh">trunk/Source/WebCore/css/TransformFunctions.h</a></li>
<li><a href="#trunkSourceWebCorecssWebKitCSSMatrixcpp">trunk/Source/WebCore/css/WebKitCSSMatrix.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderThemeIOSmm">trunk/Source/WebCore/rendering/RenderThemeIOS.mm</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkSourceWebCorecssCSSToLengthConversionDatacpp">trunk/Source/WebCore/css/CSSToLengthConversionData.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSToLengthConversionDatah">trunk/Source/WebCore/css/CSSToLengthConversionData.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreCMakeListstxt"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/CMakeLists.txt (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/CMakeLists.txt 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/CMakeLists.txt 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -1225,6 +1225,7 @@
</span><span class="cx"> css/CSSStyleSheet.cpp
</span><span class="cx"> css/CSSSupportsRule.cpp
</span><span class="cx"> css/CSSTimingFunctionValue.cpp
</span><ins>+ css/CSSToLengthConversionData.cpp
</ins><span class="cx"> css/CSSToStyleMap.cpp
</span><span class="cx"> css/CSSUnicodeRangeValue.cpp
</span><span class="cx"> css/CSSValue.cpp
</span></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/ChangeLog 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -1,3 +1,158 @@
</span><ins>+2014-04-29 Bem Jones-Bey <bjonesbe@adobe.com>
+
+ Wrap CSS length conversion arguments in an object
+ https://bugs.webkit.org/show_bug.cgi?id=131552
+
+ Reviewed by Andreas Kling.
+
+ This patch introduces a class CSSToLengthConversionData to wrap the
+ data required to convert CSS lengths to Lengths. This simplifies the
+ plumbing that goes on whenever we need to resolve CSS lengths and
+ makes it easier to update the arguments needed for resolving these (in
+ particular adding a RenderView for resolving viewport units at style
+ recalc time; removing the computingFontSize bool also appears
+ possible).
+
+ Note that the zoom argument, which was previously a float in some
+ places and a double in others is now a float.
+
+ This is a port of a Blink patch by timloh@chromium.org.
+
+ No new tests, no behavior change.
+
+ * CMakeLists.txt:
+ * WebCore.vcxproj/WebCore.vcxproj:
+ * WebCore.xcodeproj/project.pbxproj:
+ * css/BasicShapeFunctions.cpp:
+ (WebCore::convertToLength):
+ (WebCore::convertToLengthSize):
+ (WebCore::convertToCenterCoordinate):
+ (WebCore::cssValueToBasicShapeRadius):
+ (WebCore::basicShapeForValue):
+ * css/BasicShapeFunctions.h:
+ * css/CSSCalculationValue.cpp:
+ (WebCore::CSSCalcValue::computeLengthPx):
+ (WebCore::determineCategory):
+ * css/CSSCalculationValue.h:
+ (WebCore::CSSCalcValue::createCalculationValue):
+ * css/CSSGradientValue.cpp:
+ (WebCore::CSSGradientValue::addStops):
+ (WebCore::positionFromValue):
+ (WebCore::CSSGradientValue::computeEndPoint):
+ (WebCore::CSSLinearGradientValue::createGradient):
+ (WebCore::CSSRadialGradientValue::resolveRadius):
+ (WebCore::CSSRadialGradientValue::createGradient):
+ * css/CSSGradientValue.h:
+ * css/CSSPrimitiveValue.cpp:
+ (WebCore::CSSPrimitiveValue::computeLength):
+ (WebCore::CSSPrimitiveValue::computeLengthDouble):
+ * css/CSSPrimitiveValue.h:
+ * css/CSSPrimitiveValueMappings.h:
+ (WebCore::CSSPrimitiveValue::convertToLength):
+ * css/CSSToLengthConversionData.cpp: Added.
+ (WebCore::CSSToLengthConversionData::zoom):
+ * css/CSSToLengthConversionData.h: Added.
+ (WebCore::CSSToLengthConversionData::CSSToLengthConversionData):
+ (WebCore::CSSToLengthConversionData::style):
+ (WebCore::CSSToLengthConversionData::rootStyle):
+ (WebCore::CSSToLengthConversionData::computingFontSize):
+ (WebCore::CSSToLengthConversionData::copyWithAdjustedZoom):
+ * css/CSSToStyleMap.cpp:
+ (WebCore::CSSToStyleMap::CSSToStyleMap):
+ (WebCore::CSSToStyleMap::mapFillSize):
+ (WebCore::CSSToStyleMap::mapFillXPosition):
+ (WebCore::CSSToStyleMap::mapFillYPosition):
+ (WebCore::CSSToStyleMap::mapNinePieceImageQuad):
+ * css/CSSToStyleMap.h:
+ (WebCore::CSSToStyleMap::CSSToStyleMap): Deleted.
+ * css/DeprecatedStyleBuilder.cpp:
+ (WebCore::ApplyPropertyAuto::applyValue):
+ (WebCore::ApplyPropertyClip::convertToLength):
+ (WebCore::ApplyPropertyLength::applyValue):
+ (WebCore::ApplyPropertyBorderRadius::applyValue):
+ (WebCore::ApplyPropertyComputeLength::applyValue):
+ (WebCore::ApplyPropertyFontSize::applyValue):
+ (WebCore::csstoLengthConversionDataWithTextZoomFactor):
+ (WebCore::ApplyPropertyMarqueeIncrement::applyValue):
+ (WebCore::ApplyPropertyLineHeight::applyValue):
+ (WebCore::ApplyPropertyLineHeightForIOSTextAutosizing::applyValue):
+ (WebCore::ApplyPropertyWordSpacing::applyValue):
+ (WebCore::ApplyPropertyPageSize::mmLength):
+ (WebCore::ApplyPropertyPageSize::inchLength):
+ (WebCore::ApplyPropertyPageSize::applyValue):
+ (WebCore::ApplyPropertyVerticalAlign::applyValue):
+ (WebCore::ApplyPropertyClipPath::applyValue):
+ (WebCore::ApplyPropertyShape::applyValue):
+ (WebCore::ApplyPropertyTextIndent::applyValue):
+ * css/MediaQueryEvaluator.cpp:
+ (WebCore::colorMediaFeatureEval):
+ (WebCore::color_indexMediaFeatureEval):
+ (WebCore::monochromeMediaFeatureEval):
+ (WebCore::orientationMediaFeatureEval):
+ (WebCore::aspect_ratioMediaFeatureEval):
+ (WebCore::device_aspect_ratioMediaFeatureEval):
+ (WebCore::device_pixel_ratioMediaFeatureEval):
+ (WebCore::resolutionMediaFeatureEval):
+ (WebCore::gridMediaFeatureEval):
+ (WebCore::computeLength):
+ (WebCore::device_heightMediaFeatureEval):
+ (WebCore::device_widthMediaFeatureEval):
+ (WebCore::heightMediaFeatureEval):
+ (WebCore::widthMediaFeatureEval):
+ (WebCore::min_colorMediaFeatureEval):
+ (WebCore::max_colorMediaFeatureEval):
+ (WebCore::min_color_indexMediaFeatureEval):
+ (WebCore::max_color_indexMediaFeatureEval):
+ (WebCore::min_monochromeMediaFeatureEval):
+ (WebCore::max_monochromeMediaFeatureEval):
+ (WebCore::min_aspect_ratioMediaFeatureEval):
+ (WebCore::max_aspect_ratioMediaFeatureEval):
+ (WebCore::min_device_aspect_ratioMediaFeatureEval):
+ (WebCore::max_device_aspect_ratioMediaFeatureEval):
+ (WebCore::min_device_pixel_ratioMediaFeatureEval):
+ (WebCore::max_device_pixel_ratioMediaFeatureEval):
+ (WebCore::min_heightMediaFeatureEval):
+ (WebCore::max_heightMediaFeatureEval):
+ (WebCore::min_widthMediaFeatureEval):
+ (WebCore::max_widthMediaFeatureEval):
+ (WebCore::min_device_heightMediaFeatureEval):
+ (WebCore::max_device_heightMediaFeatureEval):
+ (WebCore::min_device_widthMediaFeatureEval):
+ (WebCore::max_device_widthMediaFeatureEval):
+ (WebCore::min_resolutionMediaFeatureEval):
+ (WebCore::max_resolutionMediaFeatureEval):
+ (WebCore::animationMediaFeatureEval):
+ (WebCore::transitionMediaFeatureEval):
+ (WebCore::transform_2dMediaFeatureEval):
+ (WebCore::transform_3dMediaFeatureEval):
+ (WebCore::view_modeMediaFeatureEval):
+ (WebCore::video_playable_inlineMediaFeatureEval):
+ (WebCore::hoverMediaFeatureEval):
+ (WebCore::pointerMediaFeatureEval):
+ (WebCore::MediaQueryEvaluator::eval):
+ * css/SVGCSSStyleSelector.cpp:
+ (WebCore::StyleResolver::applySVGProperty):
+ * css/StyleResolver.cpp:
+ (WebCore::StyleResolver::State::clear):
+ (WebCore::StyleResolver::State::initForStyleResolve):
+ (WebCore::StyleResolver::convertToIntLength):
+ (WebCore::StyleResolver::convertToFloatLength):
+ (WebCore::createGridTrackBreadth):
+ (WebCore::StyleResolver::applyProperty):
+ (WebCore::StyleResolver::createFilterOperations):
+ * css/StyleResolver.h:
+ (WebCore::StyleResolver::State::setStyle):
+ (WebCore::StyleResolver::State::cssToLengthConversionData):
+ * css/TransformFunctions.cpp:
+ (WebCore::convertToFloatLength):
+ (WebCore::transformsForValue):
+ * css/TransformFunctions.h:
+ * css/WebKitCSSMatrix.cpp:
+ (WebCore::WebKitCSSMatrix::setMatrixValue):
+ * rendering/RenderThemeIOS.mm:
+ (WebCore::applyCommonButtonPaddingToStyle):
+ (WebCore::RenderThemeIOS::adjustButtonStyle):
+
</ins><span class="cx"> 2014-04-29 Zoltan Horvath <zoltan@webkit.org>
</span><span class="cx">
</span><span class="cx"> [CSS Shapes] complex calc args for inset round vanish
</span></span></pre></div>
<a id="trunkSourceWebCoreWebCorevcxprojWebCorevcxproj"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -9522,6 +9522,7 @@
</span><span class="cx"> <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|x64'">true</ExcludedFromBuild>
</span><span class="cx"> </ClCompile>
</span><span class="cx"> <ClCompile Include="..\css\CSSToStyleMap.cpp" />
</span><ins>+ <ClCompile Include="..\css\CSSToLengthConversionData.cpp" />
</ins><span class="cx"> <ClCompile Include="..\css\CSSUnicodeRangeValue.cpp">
</span><span class="cx"> <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
</span><span class="cx"> <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
</span><span class="lines">@@ -19913,6 +19914,7 @@
</span><span class="cx"> <ClInclude Include="..\css\CSSSupportsRule.h" />
</span><span class="cx"> <ClInclude Include="..\css\CSSTimingFunctionValue.h" />
</span><span class="cx"> <ClInclude Include="..\css\CSSToStyleMap.h" />
</span><ins>+ <ClInclude Include="..\css\CSSToLengthConversionData.h" />
</ins><span class="cx"> <ClInclude Include="..\css\CSSUnicodeRangeValue.h" />
</span><span class="cx"> <ClInclude Include="..\css\CSSUnknownRule.h" />
</span><span class="cx"> <ClInclude Include="..\css\CSSValue.h" />
</span></span></pre></div>
<a id="trunkSourceWebCoreWebCorexcodeprojprojectpbxproj"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -3576,6 +3576,8 @@
</span><span class="cx"> 9A1B6F97158869C80011A8C4 /* JSDOMStringListCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9A1B6F96158869C80011A8C4 /* JSDOMStringListCustom.cpp */; };
</span><span class="cx"> 9A528E8317D7F52F00AA9518 /* FloatingObjects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9A528E8117D7F52F00AA9518 /* FloatingObjects.cpp */; };
</span><span class="cx"> 9A528E8417D7F52F00AA9518 /* FloatingObjects.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A528E8217D7F52F00AA9518 /* FloatingObjects.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><ins>+ 9AB1F38018E2489A00534743 /* CSSToLengthConversionData.h in Headers */ = {isa = PBXBuildFile; fileRef = 9AB1F37E18E2489A00534743 /* CSSToLengthConversionData.h */; };
+ 9AB1F38118E2489A00534743 /* CSSToLengthConversionData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9AB1F37F18E2489A00534743 /* CSSToLengthConversionData.cpp */; };
</ins><span class="cx"> 9B1AB07C1648C7C40051F3F2 /* JSHTMLFormControlsCollectionCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9B1AB07B1648C7C40051F3F2 /* JSHTMLFormControlsCollectionCustom.cpp */; };
</span><span class="cx"> 9B24DE8E15194B9500C59C27 /* HTMLBDIElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B24DE8C15194B9500C59C27 /* HTMLBDIElement.h */; };
</span><span class="cx"> 9B2D8A7914997CCF00ECEF3E /* UndoStep.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B2D8A7814997CCF00ECEF3E /* UndoStep.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="lines">@@ -10642,6 +10644,8 @@
</span><span class="cx"> 9A1B6F96158869C80011A8C4 /* JSDOMStringListCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMStringListCustom.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 9A528E8117D7F52F00AA9518 /* FloatingObjects.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FloatingObjects.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 9A528E8217D7F52F00AA9518 /* FloatingObjects.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FloatingObjects.h; sourceTree = "<group>"; };
</span><ins>+ 9AB1F37E18E2489A00534743 /* CSSToLengthConversionData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSToLengthConversionData.h; sourceTree = "<group>"; };
+ 9AB1F37F18E2489A00534743 /* CSSToLengthConversionData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSToLengthConversionData.cpp; sourceTree = "<group>"; };
</ins><span class="cx"> 9B1AB0791648C69D0051F3F2 /* HTMLFormControlsCollection.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = HTMLFormControlsCollection.idl; sourceTree = "<group>"; };
</span><span class="cx"> 9B1AB07B1648C7C40051F3F2 /* JSHTMLFormControlsCollectionCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSHTMLFormControlsCollectionCustom.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 9B24DE8C15194B9500C59C27 /* HTMLBDIElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTMLBDIElement.h; sourceTree = "<group>"; };
</span><span class="lines">@@ -21749,6 +21753,8 @@
</span><span class="cx"> FC63BDB2167AABAC00F9380F /* CSSSupportsRule.idl */,
</span><span class="cx"> BC80C9850CD294EE00A0B7B3 /* CSSTimingFunctionValue.cpp */,
</span><span class="cx"> BC80C9860CD294EE00A0B7B3 /* CSSTimingFunctionValue.h */,
</span><ins>+ 9AB1F37E18E2489A00534743 /* CSSToLengthConversionData.h */,
+ 9AB1F37F18E2489A00534743 /* CSSToLengthConversionData.cpp */,
</ins><span class="cx"> A882DA1F1593846A000115ED /* CSSToStyleMap.cpp */,
</span><span class="cx"> A882DA221593848D000115ED /* CSSToStyleMap.h */,
</span><span class="cx"> 371F53E80D2704F900ECE0D5 /* CSSUnicodeRangeValue.cpp */,
</span><span class="lines">@@ -24140,6 +24146,7 @@
</span><span class="cx"> 43107BE218CC19DE00CC18E8 /* SelectorPseudoTypeMap.h in Headers */,
</span><span class="cx"> D66817FB166FE6D700FA07B4 /* HTMLTemplateElement.h in Headers */,
</span><span class="cx"> A81369D6097374F600D74463 /* HTMLTextAreaElement.h in Headers */,
</span><ins>+ 9AB1F38018E2489A00534743 /* CSSToLengthConversionData.h in Headers */,
</ins><span class="cx"> 9BC6C21B13CCC97B008E0337 /* HTMLTextFormControlElement.h in Headers */,
</span><span class="cx"> A871DC280A15205700B12A68 /* HTMLTitleElement.h in Headers */,
</span><span class="cx"> 977B3878122883E900B81FF8 /* HTMLTokenizer.h in Headers */,
</span><span class="lines">@@ -27766,6 +27773,7 @@
</span><span class="cx"> E1F80B8A183172A2007885C3 /* JSCryptoKeyPairCustom.cpp in Sources */,
</span><span class="cx"> E125F85118283A5600D84CD9 /* JSCryptoKeySerializationJWK.cpp in Sources */,
</span><span class="cx"> E125F83D182411E700D84CD9 /* JSCryptoOperationData.cpp in Sources */,
</span><ins>+ 9AB1F38118E2489A00534743 /* CSSToLengthConversionData.cpp in Sources */,
</ins><span class="cx"> BC46C1FA0C0DDC8F0020CFC3 /* JSCSSCharsetRule.cpp in Sources */,
</span><span class="cx"> 409EBDC516B7F3CA00CBA3FC /* JSCSSFontFaceLoadEvent.cpp in Sources */,
</span><span class="cx"> BC46C1FC0C0DDC8F0020CFC3 /* JSCSSFontFaceRule.cpp in Sources */,
</span></span></pre></div>
<a id="trunkSourceWebCorecssBasicShapeFunctionscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/BasicShapeFunctions.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/BasicShapeFunctions.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/BasicShapeFunctions.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -127,21 +127,21 @@
</span><span class="cx"> return pool.createValue(basicShapeValue.release());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static Length convertToLength(const RenderStyle* style, const RenderStyle* rootStyle, CSSPrimitiveValue* value)
</del><ins>+static Length convertToLength(const CSSToLengthConversionData& conversionData, CSSPrimitiveValue* value)
</ins><span class="cx"> {
</span><del>- return value->convertToLength<FixedIntegerConversion | FixedFloatConversion | PercentConversion | CalculatedConversion | ViewportPercentageConversion>(style, rootStyle, style->effectiveZoom());
</del><ins>+ return value->convertToLength<FixedIntegerConversion | FixedFloatConversion | PercentConversion | CalculatedConversion | ViewportPercentageConversion>(conversionData);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static LengthSize convertToLengthSize(const RenderStyle* style, const RenderStyle* rootStyle, CSSPrimitiveValue* value)
</del><ins>+static LengthSize convertToLengthSize(const CSSToLengthConversionData& conversionData, CSSPrimitiveValue* value)
</ins><span class="cx"> {
</span><span class="cx"> if (!value)
</span><span class="cx"> return LengthSize(Length(0, Fixed), Length(0, Fixed));
</span><span class="cx">
</span><span class="cx"> Pair* pair = value->getPairValue();
</span><del>- return LengthSize(convertToLength(style, rootStyle, pair->first()), convertToLength(style, rootStyle, pair->second()));
</del><ins>+ return LengthSize(convertToLength(conversionData, pair->first()), convertToLength(conversionData, pair->second()));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static BasicShapeCenterCoordinate convertToCenterCoordinate(const RenderStyle* style, const RenderStyle* rootStyle, CSSPrimitiveValue* value)
</del><ins>+static BasicShapeCenterCoordinate convertToCenterCoordinate(const CSSToLengthConversionData& conversionData, CSSPrimitiveValue* value)
</ins><span class="cx"> {
</span><span class="cx"> BasicShapeCenterCoordinate::Direction direction;
</span><span class="cx"> Length offset = Length(0, Fixed);
</span><span class="lines">@@ -153,9 +153,9 @@
</span><span class="cx"> keyword = value->getValueID();
</span><span class="cx"> else if (Pair* pair = value->getPairValue()) {
</span><span class="cx"> keyword = pair->first()->getValueID();
</span><del>- offset = convertToLength(style, rootStyle, pair->second());
</del><ins>+ offset = convertToLength(conversionData, pair->second());
</ins><span class="cx"> } else
</span><del>- offset = convertToLength(style, rootStyle, value);
</del><ins>+ offset = convertToLength(conversionData, value);
</ins><span class="cx">
</span><span class="cx"> switch (keyword) {
</span><span class="cx"> case CSSValueTop:
</span><span class="lines">@@ -179,7 +179,7 @@
</span><span class="cx"> return BasicShapeCenterCoordinate(direction, offset);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static BasicShapeRadius cssValueToBasicShapeRadius(const RenderStyle* style, const RenderStyle* rootStyle, PassRefPtr<CSSPrimitiveValue> radius)
</del><ins>+static BasicShapeRadius cssValueToBasicShapeRadius(const CSSToLengthConversionData& conversionData, PassRefPtr<CSSPrimitiveValue> radius)
</ins><span class="cx"> {
</span><span class="cx"> if (!radius)
</span><span class="cx"> return BasicShapeRadius(BasicShapeRadius::ClosestSide);
</span><span class="lines">@@ -196,10 +196,10 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- return BasicShapeRadius(convertToLength(style, rootStyle, radius.get()));
</del><ins>+ return BasicShapeRadius(convertToLength(conversionData, radius.get()));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<BasicShape> basicShapeForValue(const RenderStyle* style, const RenderStyle* rootStyle, const CSSBasicShape* basicShapeValue)
</del><ins>+PassRefPtr<BasicShape> basicShapeForValue(const CSSToLengthConversionData& conversionData, const CSSBasicShape* basicShapeValue)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<BasicShape> basicShape;
</span><span class="cx">
</span><span class="lines">@@ -208,9 +208,9 @@
</span><span class="cx"> const CSSBasicShapeCircle* circleValue = static_cast<const CSSBasicShapeCircle *>(basicShapeValue);
</span><span class="cx"> RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
</span><span class="cx">
</span><del>- circle->setCenterX(convertToCenterCoordinate(style, rootStyle, circleValue->centerX()));
- circle->setCenterY(convertToCenterCoordinate(style, rootStyle, circleValue->centerY()));
- circle->setRadius(cssValueToBasicShapeRadius(style, rootStyle, circleValue->radius()));
</del><ins>+ circle->setCenterX(convertToCenterCoordinate(conversionData, circleValue->centerX()));
+ circle->setCenterY(convertToCenterCoordinate(conversionData, circleValue->centerY()));
+ circle->setRadius(cssValueToBasicShapeRadius(conversionData, circleValue->radius()));
</ins><span class="cx">
</span><span class="cx"> basicShape = circle.release();
</span><span class="cx"> break;
</span><span class="lines">@@ -219,11 +219,11 @@
</span><span class="cx"> const CSSBasicShapeEllipse* ellipseValue = static_cast<const CSSBasicShapeEllipse *>(basicShapeValue);
</span><span class="cx"> RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
</span><span class="cx">
</span><del>- ellipse->setCenterX(convertToCenterCoordinate(style, rootStyle, ellipseValue->centerX()));
- ellipse->setCenterY(convertToCenterCoordinate(style, rootStyle, ellipseValue->centerY()));
</del><ins>+ ellipse->setCenterX(convertToCenterCoordinate(conversionData, ellipseValue->centerX()));
+ ellipse->setCenterY(convertToCenterCoordinate(conversionData, ellipseValue->centerY()));
</ins><span class="cx">
</span><del>- ellipse->setRadiusX(cssValueToBasicShapeRadius(style, rootStyle, ellipseValue->radiusX()));
- ellipse->setRadiusY(cssValueToBasicShapeRadius(style, rootStyle, ellipseValue->radiusY()));
</del><ins>+ ellipse->setRadiusX(cssValueToBasicShapeRadius(conversionData, ellipseValue->radiusX()));
+ ellipse->setRadiusY(cssValueToBasicShapeRadius(conversionData, ellipseValue->radiusY()));
</ins><span class="cx">
</span><span class="cx"> basicShape = ellipse.release();
</span><span class="cx"> break;
</span><span class="lines">@@ -235,7 +235,7 @@
</span><span class="cx"> polygon->setWindRule(polygonValue->windRule());
</span><span class="cx"> const Vector<RefPtr<CSSPrimitiveValue>>& values = polygonValue->values();
</span><span class="cx"> for (unsigned i = 0; i < values.size(); i += 2)
</span><del>- polygon->appendPoint(convertToLength(style, rootStyle, values.at(i).get()), convertToLength(style, rootStyle, values.at(i + 1).get()));
</del><ins>+ polygon->appendPoint(convertToLength(conversionData, values.at(i).get()), convertToLength(conversionData, values.at(i + 1).get()));
</ins><span class="cx">
</span><span class="cx"> basicShape = polygon.release();
</span><span class="cx"> break;
</span><span class="lines">@@ -244,15 +244,15 @@
</span><span class="cx"> const CSSBasicShapeInset* rectValue = static_cast<const CSSBasicShapeInset* >(basicShapeValue);
</span><span class="cx"> RefPtr<BasicShapeInset> rect = BasicShapeInset::create();
</span><span class="cx">
</span><del>- rect->setTop(convertToLength(style, rootStyle, rectValue->top()));
- rect->setRight(convertToLength(style, rootStyle, rectValue->right()));
- rect->setBottom(convertToLength(style, rootStyle, rectValue->bottom()));
- rect->setLeft(convertToLength(style, rootStyle, rectValue->left()));
</del><ins>+ rect->setTop(convertToLength(conversionData, rectValue->top()));
+ rect->setRight(convertToLength(conversionData, rectValue->right()));
+ rect->setBottom(convertToLength(conversionData, rectValue->bottom()));
+ rect->setLeft(convertToLength(conversionData, rectValue->left()));
</ins><span class="cx">
</span><del>- rect->setTopLeftRadius(convertToLengthSize(style, rootStyle, rectValue->topLeftRadius()));
- rect->setTopRightRadius(convertToLengthSize(style, rootStyle, rectValue->topRightRadius()));
- rect->setBottomRightRadius(convertToLengthSize(style, rootStyle, rectValue->bottomRightRadius()));
- rect->setBottomLeftRadius(convertToLengthSize(style, rootStyle, rectValue->bottomLeftRadius()));
</del><ins>+ rect->setTopLeftRadius(convertToLengthSize(conversionData, rectValue->topLeftRadius()));
+ rect->setTopRightRadius(convertToLengthSize(conversionData, rectValue->topRightRadius()));
+ rect->setBottomRightRadius(convertToLengthSize(conversionData, rectValue->bottomRightRadius()));
+ rect->setBottomLeftRadius(convertToLengthSize(conversionData, rectValue->bottomLeftRadius()));
</ins><span class="cx">
</span><span class="cx"> basicShape = rect.release();
</span><span class="cx"> break;
</span></span></pre></div>
<a id="trunkSourceWebCorecssBasicShapeFunctionsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/BasicShapeFunctions.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/BasicShapeFunctions.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/BasicShapeFunctions.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -37,11 +37,12 @@
</span><span class="cx">
</span><span class="cx"> class CSSBasicShape;
</span><span class="cx"> class CSSPrimitiveValue;
</span><ins>+class CSSToLengthConversionData;
</ins><span class="cx"> class CSSValue;
</span><span class="cx"> class RenderStyle;
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> valueForBasicShape(const RenderStyle*, const BasicShape*);
</span><del>-PassRefPtr<BasicShape> basicShapeForValue(const RenderStyle*, const RenderStyle* rootStyle, const CSSBasicShape*);
</del><ins>+PassRefPtr<BasicShape> basicShapeForValue(const CSSToLengthConversionData&, const CSSBasicShape*);
</ins><span class="cx">
</span><span class="cx"> float floatValueForCenterCoordinate(const BasicShapeCenterCoordinate&, float);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSCalculationValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSCalculationValue.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSCalculationValue.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSCalculationValue.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -171,9 +171,9 @@
</span><span class="cx"> return clampToPermittedRange(m_expression->doubleValue());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-double CSSCalcValue::computeLengthPx(const RenderStyle* currentStyle, const RenderStyle* rootStyle, double multiplier, bool computingFontSize) const
</del><ins>+double CSSCalcValue::computeLengthPx(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return clampToPermittedRange(m_expression->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize));
</del><ins>+ return clampToPermittedRange(m_expression->computeLengthPx(conversionData));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> class CSSCalcPrimitiveValue final : public CSSCalcExpressionNode {
</span><span class="lines">@@ -202,18 +202,18 @@
</span><span class="cx"> return m_value->cssText();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- virtual std::unique_ptr<CalcExpressionNode> createCalcExpression(const RenderStyle* style, const RenderStyle* rootStyle, double zoom) const override
</del><ins>+ virtual std::unique_ptr<CalcExpressionNode> createCalcExpression(const CSSToLengthConversionData& conversionData) const override
</ins><span class="cx"> {
</span><span class="cx"> switch (category()) {
</span><span class="cx"> case CalcNumber:
</span><span class="cx"> return std::make_unique<CalcExpressionNumber>(m_value->getFloatValue());
</span><span class="cx"> case CalcLength:
</span><del>- return std::make_unique<CalcExpressionLength>(Length(m_value->computeLength<float>(style, rootStyle, zoom), WebCore::Fixed));
</del><ins>+ return std::make_unique<CalcExpressionLength>(Length(m_value->computeLength<float>(conversionData), WebCore::Fixed));
</ins><span class="cx"> case CalcPercent:
</span><span class="cx"> case CalcPercentLength: {
</span><span class="cx"> CSSPrimitiveValue* primitiveValue = m_value.get();
</span><span class="cx"> return std::make_unique<CalcExpressionLength>(primitiveValue
</span><del>- ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | FractionConversion>(style, rootStyle, zoom) : Length(Undefined));
</del><ins>+ ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | FractionConversion>(conversionData) : Length(Undefined));
</ins><span class="cx"> }
</span><span class="cx"> // Only types that could be part of a Length expression can be converted
</span><span class="cx"> // to a CalcExpressionNode. CalcPercentNumber makes no sense as a Length.
</span><span class="lines">@@ -232,11 +232,11 @@
</span><span class="cx"> return 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- virtual double computeLengthPx(const RenderStyle* currentStyle, const RenderStyle* rootStyle, double multiplier, bool computingFontSize) const override
</del><ins>+ virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const override
</ins><span class="cx"> {
</span><span class="cx"> switch (category()) {
</span><span class="cx"> case CalcLength:
</span><del>- return m_value->computeLength<double>(currentStyle, rootStyle, multiplier, computingFontSize);
</del><ins>+ return m_value->computeLength<double>(conversionData);
</ins><span class="cx"> case CalcPercent:
</span><span class="cx"> case CalcNumber:
</span><span class="cx"> return m_value->getDoubleValue();
</span><span class="lines">@@ -394,12 +394,12 @@
</span><span class="cx"> return !doubleValue();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- virtual std::unique_ptr<CalcExpressionNode> createCalcExpression(const RenderStyle* style, const RenderStyle* rootStyle, double zoom) const override
</del><ins>+ virtual std::unique_ptr<CalcExpressionNode> createCalcExpression(const CSSToLengthConversionData& conversionData) const override
</ins><span class="cx"> {
</span><del>- std::unique_ptr<CalcExpressionNode> left(m_leftSide->createCalcExpression(style, rootStyle, zoom));
</del><ins>+ std::unique_ptr<CalcExpressionNode> left(m_leftSide->createCalcExpression(conversionData));
</ins><span class="cx"> if (!left)
</span><span class="cx"> return nullptr;
</span><del>- std::unique_ptr<CalcExpressionNode> right(m_rightSide->createCalcExpression(style, rootStyle, zoom));
</del><ins>+ std::unique_ptr<CalcExpressionNode> right(m_rightSide->createCalcExpression(conversionData));
</ins><span class="cx"> if (!right)
</span><span class="cx"> return nullptr;
</span><span class="cx"> return std::make_unique<CalcExpressionBinaryOperation>(std::move(left), std::move(right), m_operator);
</span><span class="lines">@@ -410,10 +410,10 @@
</span><span class="cx"> return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- virtual double computeLengthPx(const RenderStyle* currentStyle, const RenderStyle* rootStyle, double multiplier, bool computingFontSize) const override
</del><ins>+ virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const override
</ins><span class="cx"> {
</span><del>- const double leftValue = m_leftSide->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize);
- const double rightValue = m_rightSide->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize);
</del><ins>+ const double leftValue = m_leftSide->computeLengthPx(conversionData);
+ const double rightValue = m_rightSide->computeLengthPx(conversionData);
</ins><span class="cx"> return evaluate(leftValue, rightValue);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSCalculationValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSCalculationValue.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSCalculationValue.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSCalculationValue.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -37,6 +37,7 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><ins>+class CSSToLengthConversionData;
</ins><span class="cx"> class RenderStyle;
</span><span class="cx">
</span><span class="cx"> enum CalculationCategory {
</span><span class="lines">@@ -57,9 +58,9 @@
</span><span class="cx">
</span><span class="cx"> virtual ~CSSCalcExpressionNode() { }
</span><span class="cx"> virtual bool isZero() const = 0;
</span><del>- virtual std::unique_ptr<CalcExpressionNode> createCalcExpression(const RenderStyle*, const RenderStyle* rootStyle, double zoom = 1.0) const = 0;
</del><ins>+ virtual std::unique_ptr<CalcExpressionNode> createCalcExpression(const CSSToLengthConversionData&) const = 0;
</ins><span class="cx"> virtual double doubleValue() const = 0;
</span><del>- virtual double computeLengthPx(const RenderStyle* currentStyle, const RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false) const = 0;
</del><ins>+ virtual double computeLengthPx(const CSSToLengthConversionData&) const = 0;
</ins><span class="cx"> virtual String customCSSText() const = 0;
</span><span class="cx"> virtual bool equals(const CSSCalcExpressionNode& other) const { return m_category == other.m_category && m_isInteger == other.m_isInteger; }
</span><span class="cx"> virtual Type type() const = 0;
</span><span class="lines">@@ -89,9 +90,9 @@
</span><span class="cx"> bool isInt() const { return m_expression->isInteger(); }
</span><span class="cx"> double doubleValue() const;
</span><span class="cx"> bool isNegative() const { return m_expression->doubleValue() < 0; }
</span><del>- double computeLengthPx(const RenderStyle* currentStyle, const RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false) const;
</del><ins>+ double computeLengthPx(const CSSToLengthConversionData&) const;
</ins><span class="cx">
</span><del>- PassRef<CalculationValue> createCalculationValue(const RenderStyle* currentStyle, const RenderStyle* rootStyle, double zoom = 1.0) const;
</del><ins>+ PassRef<CalculationValue> createCalculationValue(const CSSToLengthConversionData&) const;
</ins><span class="cx">
</span><span class="cx"> String customCSSText() const;
</span><span class="cx"> bool equals(const CSSCalcValue&) const;
</span><span class="lines">@@ -112,9 +113,9 @@
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline PassRef<CalculationValue> CSSCalcValue::createCalculationValue(const RenderStyle* style, const RenderStyle* rootStyle, double zoom) const
</del><ins>+inline PassRef<CalculationValue> CSSCalcValue::createCalculationValue(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return CalculationValue::create(m_expression->createCalcExpression(style, rootStyle, zoom),
</del><ins>+ return CalculationValue::create(m_expression->createCalcExpression(conversionData),
</ins><span class="cx"> m_shouldClampToNonNegative ? CalculationRangeNonNegative : CalculationRangeAll);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGradientValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGradientValue.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGradientValue.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSGradientValue.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -27,6 +27,7 @@
</span><span class="cx"> #include "CSSGradientValue.h"
</span><span class="cx">
</span><span class="cx"> #include "CSSCalculationValue.h"
</span><ins>+#include "CSSToLengthConversionData.h"
</ins><span class="cx"> #include "CSSValueKeywords.h"
</span><span class="cx"> #include "FloatSize.h"
</span><span class="cx"> #include "FloatSizeHash.h"
</span><span class="lines">@@ -128,10 +129,8 @@
</span><span class="cx"> return result.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSGradientValue::addStops(Gradient* gradient, RenderElement* renderer, const RenderStyle& rootStyle, float maxLengthForRepeat)
</del><ins>+void CSSGradientValue::addStops(Gradient* gradient, const CSSToLengthConversionData& conversionData, float maxLengthForRepeat)
</ins><span class="cx"> {
</span><del>- RenderStyle& style = renderer->style();
-
</del><span class="cx"> if (m_gradientType == CSSDeprecatedLinearGradient || m_gradientType == CSSDeprecatedRadialGradient) {
</span><span class="cx"> sortStopsIfNeeded();
</span><span class="cx">
</span><span class="lines">@@ -181,9 +180,9 @@
</span><span class="cx"> }
</span><span class="cx"> float length;
</span><span class="cx"> if (stop.m_position->isLength())
</span><del>- length = stop.m_position->computeLength<float>(&style, &rootStyle, style.effectiveZoom());
</del><ins>+ length = stop.m_position->computeLength<float>(conversionData);
</ins><span class="cx"> else {
</span><del>- Ref<CalculationValue> calculationValue { stop.m_position->cssCalcValue()->createCalculationValue(&style, &rootStyle, style.effectiveZoom()) };
</del><ins>+ Ref<CalculationValue> calculationValue { stop.m_position->cssCalcValue()->createCalculationValue(conversionData) };
</ins><span class="cx"> length = calculationValue->evaluate(gradientLength);
</span><span class="cx"> }
</span><span class="cx"> stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
</span><span class="lines">@@ -392,19 +391,17 @@
</span><span class="cx"> gradient->setStopsSorted(true);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static float positionFromValue(CSSPrimitiveValue* value, const RenderStyle& style, const RenderStyle& rootStyle, const FloatSize& size, bool isHorizontal)
</del><ins>+static float positionFromValue(CSSPrimitiveValue* value, const CSSToLengthConversionData& conversionData, const FloatSize& size, bool isHorizontal)
</ins><span class="cx"> {
</span><del>- float zoomFactor = style.effectiveZoom();
-
</del><span class="cx"> if (value->isNumber())
</span><del>- return value->getFloatValue() * zoomFactor;
</del><ins>+ return value->getFloatValue() * conversionData.zoom();
</ins><span class="cx">
</span><span class="cx"> int edgeDistance = isHorizontal ? size.width() : size.height();
</span><span class="cx"> if (value->isPercentage())
</span><span class="cx"> return value->getFloatValue() / 100.f * edgeDistance;
</span><span class="cx">
</span><span class="cx"> if (value->isCalculatedPercentageWithLength()) {
</span><del>- Ref<CalculationValue> calculationValue { value->cssCalcValue()->createCalculationValue(&style, &rootStyle, style.effectiveZoom()) };
</del><ins>+ Ref<CalculationValue> calculationValue { value->cssCalcValue()->createCalculationValue(conversionData) };
</ins><span class="cx"> return calculationValue->evaluate(edgeDistance);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -425,18 +422,18 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- return value->computeLength<float>(&style, &rootStyle, zoomFactor);
</del><ins>+ return value->computeLength<float>(conversionData);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, const RenderStyle& style, const RenderStyle& rootStyle, const FloatSize& size)
</del><ins>+FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, const CSSToLengthConversionData& conversionData, const FloatSize& size)
</ins><span class="cx"> {
</span><span class="cx"> FloatPoint result;
</span><span class="cx">
</span><span class="cx"> if (horizontal)
</span><del>- result.setX(positionFromValue(horizontal, style, rootStyle, size, true));
</del><ins>+ result.setX(positionFromValue(horizontal, conversionData, size, true));
</ins><span class="cx">
</span><span class="cx"> if (vertical)
</span><del>- result.setY(positionFromValue(vertical, style, rootStyle, size, false));
</del><ins>+ result.setY(positionFromValue(vertical, conversionData, size, false));
</ins><span class="cx">
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="lines">@@ -647,7 +644,7 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(!size.isEmpty());
</span><span class="cx">
</span><del>- RenderStyle& rootStyle = *renderer->document().documentElement()->renderStyle();
</del><ins>+ CSSToLengthConversionData conversionData(&renderer->style(), renderer->document().documentElement()->renderStyle());
</ins><span class="cx">
</span><span class="cx"> FloatPoint firstPoint;
</span><span class="cx"> FloatPoint secondPoint;
</span><span class="lines">@@ -657,9 +654,9 @@
</span><span class="cx"> } else {
</span><span class="cx"> switch (m_gradientType) {
</span><span class="cx"> case CSSDeprecatedLinearGradient:
</span><del>- firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
</del><ins>+ firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
</ins><span class="cx"> if (m_secondX || m_secondY)
</span><del>- secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size);
</del><ins>+ secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), conversionData, size);
</ins><span class="cx"> else {
</span><span class="cx"> if (m_firstX)
</span><span class="cx"> secondPoint.setX(size.width() - firstPoint.x());
</span><span class="lines">@@ -668,7 +665,7 @@
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case CSSPrefixedLinearGradient:
</span><del>- firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
</del><ins>+ firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
</ins><span class="cx"> if (m_firstX)
</span><span class="cx"> secondPoint.setX(size.width() - firstPoint.x());
</span><span class="cx"> if (m_firstY)
</span><span class="lines">@@ -687,7 +684,7 @@
</span><span class="cx"> float angle = 90 - rad2deg(atan2(rise, run));
</span><span class="cx"> endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
</span><span class="cx"> } else if (m_firstX || m_firstY) {
</span><del>- secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
</del><ins>+ secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
</ins><span class="cx"> if (m_firstX)
</span><span class="cx"> firstPoint.setX(size.width() - secondPoint.x());
</span><span class="cx"> if (m_firstY)
</span><span class="lines">@@ -704,7 +701,7 @@
</span><span class="cx"> RefPtr<Gradient> gradient = Gradient::create(firstPoint, secondPoint);
</span><span class="cx">
</span><span class="cx"> // Now add the stops.
</span><del>- addStops(gradient.get(), renderer, rootStyle, 1);
</del><ins>+ addStops(gradient.get(), conversionData, 1);
</ins><span class="cx">
</span><span class="cx"> return gradient.release();
</span><span class="cx"> }
</span><span class="lines">@@ -891,17 +888,15 @@
</span><span class="cx"> return result.toString();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, const RenderStyle& style, const RenderStyle& rootStyle, float* widthOrHeight)
</del><ins>+float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, const CSSToLengthConversionData& conversionData, float* widthOrHeight)
</ins><span class="cx"> {
</span><del>- float zoomFactor = style.effectiveZoom();
-
</del><span class="cx"> float result = 0;
</span><span class="cx"> if (radius->isNumber()) // Can the radius be a percentage?
</span><del>- result = radius->getFloatValue() * zoomFactor;
</del><ins>+ result = radius->getFloatValue() * conversionData.zoom();
</ins><span class="cx"> else if (widthOrHeight && radius->isPercentage())
</span><span class="cx"> result = *widthOrHeight * radius->getFloatValue() / 100;
</span><span class="cx"> else
</span><del>- result = radius->computeLength<float>(&style, &rootStyle, zoomFactor);
</del><ins>+ result = radius->computeLength<float>(conversionData);
</ins><span class="cx">
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="lines">@@ -987,15 +982,15 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(!size.isEmpty());
</span><span class="cx">
</span><del>- RenderStyle& rootStyle = *renderer->document().documentElement()->renderStyle();
</del><ins>+ CSSToLengthConversionData conversionData(&renderer->style(), renderer->document().documentElement()->renderStyle());
</ins><span class="cx">
</span><del>- FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
</del><ins>+ FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
</ins><span class="cx"> if (!m_firstX)
</span><span class="cx"> firstPoint.setX(size.width() / 2);
</span><span class="cx"> if (!m_firstY)
</span><span class="cx"> firstPoint.setY(size.height() / 2);
</span><span class="cx">
</span><del>- FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size);
</del><ins>+ FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), conversionData, size);
</ins><span class="cx"> if (!m_secondX)
</span><span class="cx"> secondPoint.setX(size.width() / 2);
</span><span class="cx"> if (!m_secondY)
</span><span class="lines">@@ -1003,18 +998,18 @@
</span><span class="cx">
</span><span class="cx"> float firstRadius = 0;
</span><span class="cx"> if (m_firstRadius)
</span><del>- firstRadius = resolveRadius(m_firstRadius.get(), renderer->style(), rootStyle);
</del><ins>+ firstRadius = resolveRadius(m_firstRadius.get(), conversionData);
</ins><span class="cx">
</span><span class="cx"> float secondRadius = 0;
</span><span class="cx"> float aspectRatio = 1; // width / height.
</span><span class="cx"> if (m_secondRadius)
</span><del>- secondRadius = resolveRadius(m_secondRadius.get(), renderer->style(), rootStyle);
</del><ins>+ secondRadius = resolveRadius(m_secondRadius.get(), conversionData);
</ins><span class="cx"> else if (m_endHorizontalSize) {
</span><span class="cx"> float width = size.width();
</span><span class="cx"> float height = size.height();
</span><del>- secondRadius = resolveRadius(m_endHorizontalSize.get(), renderer->style(), rootStyle, &width);
</del><ins>+ secondRadius = resolveRadius(m_endHorizontalSize.get(), conversionData, &width);
</ins><span class="cx"> if (m_endVerticalSize)
</span><del>- aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), renderer->style(), rootStyle, &height);
</del><ins>+ aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), conversionData, &height);
</ins><span class="cx"> else
</span><span class="cx"> aspectRatio = 1;
</span><span class="cx"> } else {
</span><span class="lines">@@ -1120,7 +1115,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Now add the stops.
</span><del>- addStops(gradient.get(), renderer, rootStyle, maxExtent);
</del><ins>+ addStops(gradient.get(), conversionData, maxExtent);
</ins><span class="cx">
</span><span class="cx"> return gradient.release();
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGradientValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGradientValue.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGradientValue.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSGradientValue.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -109,10 +109,10 @@
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void addStops(Gradient*, RenderElement*, const RenderStyle& rootStyle, float maxLengthForRepeat = 0);
</del><ins>+ void addStops(Gradient*, const CSSToLengthConversionData&, float maxLengthForRepeat = 0);
</ins><span class="cx">
</span><span class="cx"> // Resolve points/radii to front end values.
</span><del>- FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const RenderStyle&, const RenderStyle& rootStyle, const FloatSize&);
</del><ins>+ FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const CSSToLengthConversionData&, const FloatSize&);
</ins><span class="cx">
</span><span class="cx"> bool isCacheable() const;
</span><span class="cx">
</span><span class="lines">@@ -218,7 +218,7 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> // Resolve points/radii to front end values.
</span><del>- float resolveRadius(CSSPrimitiveValue*, const RenderStyle&, const RenderStyle& rootStyle, float* widthOrHeight = 0);
</del><ins>+ float resolveRadius(CSSPrimitiveValue*, const CSSToLengthConversionData&, float* widthOrHeight = 0);
</ins><span class="cx">
</span><span class="cx"> // These may be null for non-deprecated gradients.
</span><span class="cx"> RefPtr<CSSPrimitiveValue> m_firstRadius;
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSPrimitiveValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSPrimitiveValue.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSPrimitiveValue.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSPrimitiveValue.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -26,6 +26,7 @@
</span><span class="cx"> #include "CSSHelper.h"
</span><span class="cx"> #include "CSSParser.h"
</span><span class="cx"> #include "CSSPropertyNames.h"
</span><ins>+#include "CSSToLengthConversionData.h"
</ins><span class="cx"> #include "CSSValueKeywords.h"
</span><span class="cx"> #include "CalculationValue.h"
</span><span class="cx"> #include "Color.h"
</span><span class="lines">@@ -554,74 +555,77 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-template<> int CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> int CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return roundForImpreciseConversion<int>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));
</del><ins>+ return roundForImpreciseConversion<int>(computeLengthDouble(conversionData));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-template<> unsigned CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> unsigned CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return roundForImpreciseConversion<unsigned>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));
</del><ins>+ return roundForImpreciseConversion<unsigned>(computeLengthDouble(conversionData));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-template<> Length CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> Length CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><span class="cx"> #if ENABLE(SUBPIXEL_LAYOUT)
</span><del>- return Length(clampTo<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize), minValueForCssLength, maxValueForCssLength), Fixed);
</del><ins>+ return Length(clampTo<float>(computeLengthDouble(conversionData), minValueForCssLength, maxValueForCssLength), Fixed);
</ins><span class="cx"> #else
</span><del>- return Length(clampTo<float>(roundForImpreciseConversion<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize)), minValueForCssLength, maxValueForCssLength), Fixed);
</del><ins>+ return Length(clampTo<float>(roundForImpreciseConversion<float>(computeLengthDouble(conversionData)), minValueForCssLength, maxValueForCssLength), Fixed);
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><del>-template<> short CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return roundForImpreciseConversion<short>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));
</del><ins>+ return roundForImpreciseConversion<short>(computeLengthDouble(conversionData));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-template<> unsigned short CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> unsigned short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return roundForImpreciseConversion<unsigned short>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));
</del><ins>+ return roundForImpreciseConversion<unsigned short>(computeLengthDouble(conversionData));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-template<> float CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> float CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return static_cast<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));
</del><ins>+ return static_cast<float>(computeLengthDouble(conversionData));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-template<> double CSSPrimitiveValue::computeLength(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- return computeLengthDouble(style, rootStyle, multiplier, computingFontSize);
</del><ins>+ return computeLengthDouble(conversionData);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-double CSSPrimitiveValue::computeLengthDouble(const RenderStyle* style, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const
</del><ins>+double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><span class="cx"> if (m_primitiveUnitType == CSS_CALC)
</span><span class="cx"> // The multiplier and factor is applied to each value in the calc expression individually
</span><del>- return m_value.calc->computeLengthPx(style, rootStyle, multiplier, computingFontSize);
</del><ins>+ return m_value.calc->computeLengthPx(conversionData);
</ins><span class="cx">
</span><span class="cx"> double factor;
</span><span class="cx">
</span><span class="cx"> switch (primitiveType()) {
</span><span class="cx"> case CSS_EMS:
</span><del>- factor = computingFontSize ? style->fontDescription().specifiedSize() : style->fontDescription().computedSize();
</del><ins>+ ASSERT(conversionData.style());
+ factor = conversionData.computingFontSize() ? conversionData.style()->fontDescription().specifiedSize() : conversionData.style()->fontDescription().computedSize();
</ins><span class="cx"> break;
</span><span class="cx"> case CSS_EXS:
</span><ins>+ ASSERT(conversionData.style());
</ins><span class="cx"> // FIXME: We have a bug right now where the zoom will be applied twice to EX units.
</span><span class="cx"> // We really need to compute EX using fontMetrics for the original specifiedSize and not use
</span><span class="cx"> // our actual constructed rendering font.
</span><del>- if (style->fontMetrics().hasXHeight())
- factor = style->fontMetrics().xHeight();
</del><ins>+ if (conversionData.style()->fontMetrics().hasXHeight())
+ factor = conversionData.style()->fontMetrics().xHeight();
</ins><span class="cx"> else
</span><del>- factor = (computingFontSize ? style->fontDescription().specifiedSize() : style->fontDescription().computedSize()) / 2.0;
</del><ins>+ factor = (conversionData.computingFontSize() ? conversionData.style()->fontDescription().specifiedSize() : conversionData.style()->fontDescription().computedSize()) / 2.0;
</ins><span class="cx"> break;
</span><span class="cx"> case CSS_REMS:
</span><del>- if (rootStyle)
- factor = computingFontSize ? rootStyle->fontDescription().specifiedSize() : rootStyle->fontDescription().computedSize();
</del><ins>+ if (conversionData.rootStyle())
+ factor = conversionData.computingFontSize() ? conversionData.rootStyle()->fontDescription().specifiedSize() : conversionData.rootStyle()->fontDescription().computedSize();
</ins><span class="cx"> else
</span><span class="cx"> factor = 1.0;
</span><span class="cx"> break;
</span><span class="cx"> case CSS_CHS:
</span><del>- factor = style->fontMetrics().zeroWidth();
</del><ins>+ ASSERT(conversionData.style());
+ factor = conversionData.style()->fontMetrics().zeroWidth();
</ins><span class="cx"> break;
</span><span class="cx"> case CSS_PX:
</span><span class="cx"> factor = 1.0;
</span><span class="lines">@@ -661,10 +665,10 @@
</span><span class="cx"> // for font sizes is much more complicated, since we have to worry about enforcing the minimum font size preference
</span><span class="cx"> // as well as enforcing the implicit "smart minimum."
</span><span class="cx"> double result = getDoubleValue() * factor;
</span><del>- if (computingFontSize || isFontRelativeLength())
</del><ins>+ if (conversionData.computingFontSize() || isFontRelativeLength())
</ins><span class="cx"> return result;
</span><span class="cx">
</span><del>- return result * multiplier;
</del><ins>+ return result * conversionData.zoom();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void CSSPrimitiveValue::setFloatValue(unsigned short, double, ExceptionCode& ec)
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSPrimitiveValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSPrimitiveValue.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSPrimitiveValue.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSPrimitiveValue.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -33,6 +33,7 @@
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="cx"> class CSSCalcValue;
</span><ins>+class CSSToLengthConversionData;
</ins><span class="cx"> class Counter;
</span><span class="cx"> class DashboardRegion;
</span><span class="cx"> class Pair;
</span><span class="lines">@@ -265,10 +266,10 @@
</span><span class="cx"> * this is screen/printer dependent, so we probably need a config option for this,
</span><span class="cx"> * and some tool to calibrate.
</span><span class="cx"> */
</span><del>- template<typename T> T computeLength(const RenderStyle* currStyle, const RenderStyle* rootStyle, float multiplier = 1.0f, bool computingFontSize = false) const;
</del><ins>+ template<typename T> T computeLength(const CSSToLengthConversionData&) const;
</ins><span class="cx">
</span><span class="cx"> // Converts to a Length, mapping various unit types appropriately.
</span><del>- template<int> Length convertToLength(const RenderStyle* currStyle, const RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false) const;
</del><ins>+ template<int> Length convertToLength(const CSSToLengthConversionData&) const;
</ins><span class="cx">
</span><span class="cx"> // use with care!!!
</span><span class="cx"> void setPrimitiveType(unsigned short type) { m_primitiveUnitType = type; }
</span><span class="lines">@@ -378,7 +379,7 @@
</span><span class="cx"> void init(PassRefPtr<CSSCalcValue>);
</span><span class="cx"> bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;
</span><span class="cx">
</span><del>- double computeLengthDouble(const RenderStyle* currentStyle, const RenderStyle* rootStyle, float multiplier, bool computingFontSize) const;
</del><ins>+ double computeLengthDouble(const CSSToLengthConversionData&) const;
</ins><span class="cx">
</span><span class="cx"> union {
</span><span class="cx"> CSSPropertyID propertyID;
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSPrimitiveValueMappingsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -33,6 +33,7 @@
</span><span class="cx"> #include "CSSCalculationValue.h"
</span><span class="cx"> #include "CSSPrimitiveValue.h"
</span><span class="cx"> #include "CSSReflectionDirection.h"
</span><ins>+#include "CSSToLengthConversionData.h"
</ins><span class="cx"> #include "ColorSpace.h"
</span><span class="cx"> #include "CSSValueKeywords.h"
</span><span class="cx"> #include "FontDescription.h"
</span><span class="lines">@@ -4631,14 +4632,14 @@
</span><span class="cx"> ViewportPercentageConversion = 1 << 6
</span><span class="cx"> };
</span><span class="cx">
</span><del>-template<int supported> Length CSSPrimitiveValue::convertToLength(const RenderStyle* style, const RenderStyle* rootStyle, double multiplier, bool computingFontSize) const
</del><ins>+template<int supported> Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData) const
</ins><span class="cx"> {
</span><del>- if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isFontRelativeLength() && (!style || !rootStyle))
</del><ins>+ if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isFontRelativeLength() && (!conversionData.style() || !conversionData.rootStyle()))
</ins><span class="cx"> return Length(Undefined);
</span><span class="cx"> if ((supported & FixedIntegerConversion) && isLength())
</span><del>- return computeLength<Length>(style, rootStyle, multiplier, computingFontSize);
</del><ins>+ return computeLength<Length>(conversionData);
</ins><span class="cx"> if ((supported & FixedFloatConversion) && isLength())
</span><del>- return Length(computeLength<double>(style, rootStyle, multiplier), Fixed);
</del><ins>+ return Length(computeLength<double>(conversionData), Fixed);
</ins><span class="cx"> if ((supported & PercentConversion) && isPercentage())
</span><span class="cx"> return Length(getDoubleValue(), Percent);
</span><span class="cx"> if ((supported & FractionConversion) && isNumber())
</span><span class="lines">@@ -4646,7 +4647,7 @@
</span><span class="cx"> if ((supported & AutoConversion) && getValueID() == CSSValueAuto)
</span><span class="cx"> return Length(Auto);
</span><span class="cx"> if ((supported & CalculatedConversion) && isCalculated())
</span><del>- return Length(cssCalcValue()->createCalculationValue(style, rootStyle, multiplier));
</del><ins>+ return Length(cssCalcValue()->createCalculationValue(conversionData));
</ins><span class="cx"> if ((supported & ViewportPercentageConversion) && isViewportPercentageLength())
</span><span class="cx"> return viewportPercentageLength();
</span><span class="cx"> return Length(Undefined);
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSToLengthConversionDatacpp"></a>
<div class="addfile"><h4>Added: trunk/Source/WebCore/css/CSSToLengthConversionData.cpp (0 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSToLengthConversionData.cpp (rev 0)
+++ trunk/Source/WebCore/css/CSSToLengthConversionData.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -0,0 +1,45 @@
</span><ins>+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "CSSToLengthConversionData.h"
+
+#include "RenderStyle.h"
+
+namespace WebCore {
+
+float CSSToLengthConversionData::zoom() const
+{
+ if (m_useEffectiveZoom)
+ return m_style ? m_style->effectiveZoom() : 1;
+ return m_zoom;
+}
+
+} // namespace WebCore
</ins></span></pre></div>
<a id="trunkSourceWebCorecssCSSToLengthConversionDatah"></a>
<div class="addfile"><h4>Added: trunk/Source/WebCore/css/CSSToLengthConversionData.h (0 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSToLengthConversionData.h (rev 0)
+++ trunk/Source/WebCore/css/CSSToLengthConversionData.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -0,0 +1,80 @@
</span><ins>+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CSSToLengthConversionData_h
+#define CSSToLengthConversionData_h
+
+#include <wtf/Assertions.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebCore {
+
+class RenderStyle;
+
+class CSSToLengthConversionData {
+public:
+ CSSToLengthConversionData(const RenderStyle* style, const RenderStyle* rootStyle, float zoom, bool computingFontSize = false)
+ : m_style(style)
+ , m_rootStyle(rootStyle)
+ , m_zoom(zoom)
+ , m_useEffectiveZoom(false)
+ , m_computingFontSize(computingFontSize)
+ {
+ ASSERT(zoom > 0);
+ }
+ CSSToLengthConversionData(const RenderStyle* style = nullptr, const RenderStyle* rootStyle = nullptr, bool computingFontSize = false)
+ : m_style(style)
+ , m_rootStyle(rootStyle)
+ , m_useEffectiveZoom(true)
+ , m_computingFontSize(computingFontSize)
+ {
+ }
+
+ const RenderStyle* style() const { return m_style; }
+ const RenderStyle* rootStyle() const { return m_rootStyle; }
+ float zoom() const;
+ bool computingFontSize() const { return m_computingFontSize; }
+
+ CSSToLengthConversionData copyWithAdjustedZoom(float newZoom) const
+ {
+ return CSSToLengthConversionData(m_style, m_rootStyle, newZoom, m_computingFontSize);
+ }
+
+private:
+ const RenderStyle* m_style;
+ const RenderStyle* m_rootStyle;
+ float m_zoom;
+ bool m_useEffectiveZoom;
+ bool m_computingFontSize;
+};
+
+} // namespace WebCore
+
+#endif
</ins></span></pre></div>
<a id="trunkSourceWebCorecssCSSToStyleMapcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSToStyleMap.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSToStyleMap.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSToStyleMap.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -41,6 +41,11 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><ins>+CSSToStyleMap::CSSToStyleMap(StyleResolver* resolver)
+ : m_resolver(resolver)
+{
+}
+
</ins><span class="cx"> RenderStyle* CSSToStyleMap::style() const
</span><span class="cx"> {
</span><span class="cx"> return m_resolver->style();
</span><span class="lines">@@ -203,18 +208,16 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- float zoomFactor = style()->effectiveZoom();
-
</del><span class="cx"> Length firstLength;
</span><span class="cx"> Length secondLength;
</span><span class="cx">
</span><span class="cx"> if (Pair* pair = primitiveValue->getPairValue()) {
</span><span class="cx"> CSSPrimitiveValue* first = static_cast<CSSPrimitiveValue*>(pair->first());
</span><span class="cx"> CSSPrimitiveValue* second = static_cast<CSSPrimitiveValue*>(pair->second());
</span><del>- firstLength = first->convertToLength<AnyConversion>(style(), rootElementStyle(), zoomFactor);
- secondLength = second->convertToLength<AnyConversion>(style(), rootElementStyle(), zoomFactor);
</del><ins>+ firstLength = first->convertToLength<AnyConversion>(m_resolver->state().cssToLengthConversionData());
+ secondLength = second->convertToLength<AnyConversion>(m_resolver->state().cssToLengthConversionData());
</ins><span class="cx"> } else {
</span><del>- firstLength = primitiveValue->convertToLength<AnyConversion>(style(), rootElementStyle(), zoomFactor);
</del><ins>+ firstLength = primitiveValue->convertToLength<AnyConversion>(m_resolver->state().cssToLengthConversionData());
</ins><span class="cx"> secondLength = Length();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -236,8 +239,6 @@
</span><span class="cx"> if (!value->isPrimitiveValue())
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- float zoomFactor = style()->effectiveZoom();
-
</del><span class="cx"> CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
</span><span class="cx"> Pair* pair = primitiveValue->getPairValue();
</span><span class="cx"> if (pair) {
</span><span class="lines">@@ -247,11 +248,11 @@
</span><span class="cx">
</span><span class="cx"> Length length;
</span><span class="cx"> if (primitiveValue->isLength())
</span><del>- length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), zoomFactor);
</del><ins>+ length = primitiveValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
</ins><span class="cx"> else if (primitiveValue->isPercentage())
</span><span class="cx"> length = Length(primitiveValue->getDoubleValue(), Percent);
</span><span class="cx"> else if (primitiveValue->isCalculatedPercentageWithLength())
</span><del>- length = Length(primitiveValue->cssCalcValue()->createCalculationValue(style(), rootElementStyle(), zoomFactor));
</del><ins>+ length = Length(primitiveValue->cssCalcValue()->createCalculationValue(m_resolver->state().cssToLengthConversionData()));
</ins><span class="cx"> else if (primitiveValue->isViewportPercentageLength())
</span><span class="cx"> length = primitiveValue->viewportPercentageLength();
</span><span class="cx"> else
</span><span class="lines">@@ -272,8 +273,6 @@
</span><span class="cx"> if (!value->isPrimitiveValue())
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- float zoomFactor = style()->effectiveZoom();
-
</del><span class="cx"> CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
</span><span class="cx"> Pair* pair = primitiveValue->getPairValue();
</span><span class="cx"> if (pair) {
</span><span class="lines">@@ -283,11 +282,11 @@
</span><span class="cx">
</span><span class="cx"> Length length;
</span><span class="cx"> if (primitiveValue->isLength())
</span><del>- length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), zoomFactor);
</del><ins>+ length = primitiveValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
</ins><span class="cx"> else if (primitiveValue->isPercentage())
</span><span class="cx"> length = Length(primitiveValue->getDoubleValue(), Percent);
</span><span class="cx"> else if (primitiveValue->isCalculatedPercentageWithLength())
</span><del>- length = Length(primitiveValue->cssCalcValue()->createCalculationValue(style(), rootElementStyle(), zoomFactor));
</del><ins>+ length = Length(primitiveValue->cssCalcValue()->createCalculationValue(m_resolver->state().cssToLengthConversionData()));
</ins><span class="cx"> else if (primitiveValue->isViewportPercentageLength())
</span><span class="cx"> length = primitiveValue->viewportPercentageLength();
</span><span class="cx"> else
</span><span class="lines">@@ -633,7 +632,7 @@
</span><span class="cx"> return LengthBox();
</span><span class="cx">
</span><span class="cx"> // Get our zoom value.
</span><del>- float zoom = useSVGZoomRules() ? 1.0f : style()->effectiveZoom();
</del><ins>+ CSSToLengthConversionData conversionData = useSVGZoomRules() ? m_resolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f) : m_resolver->state().cssToLengthConversionData();
</ins><span class="cx">
</span><span class="cx"> // Retrieve the primitive value.
</span><span class="cx"> CSSPrimitiveValue* borderWidths = toCSSPrimitiveValue(value);
</span><span class="lines">@@ -646,28 +645,28 @@
</span><span class="cx"> else if (slices->top()->isPercentage())
</span><span class="cx"> box.m_top = Length(slices->top()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
</span><span class="cx"> else if (slices->top()->getValueID() != CSSValueAuto)
</span><del>- box.m_top = slices->top()->computeLength<Length>(style(), rootElementStyle(), zoom);
</del><ins>+ box.m_top = slices->top()->computeLength<Length>(conversionData);
</ins><span class="cx">
</span><span class="cx"> if (slices->right()->isNumber())
</span><span class="cx"> box.m_right = Length(slices->right()->getIntValue(), Relative);
</span><span class="cx"> else if (slices->right()->isPercentage())
</span><span class="cx"> box.m_right = Length(slices->right()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
</span><span class="cx"> else if (slices->right()->getValueID() != CSSValueAuto)
</span><del>- box.m_right = slices->right()->computeLength<Length>(style(), rootElementStyle(), zoom);
</del><ins>+ box.m_right = slices->right()->computeLength<Length>(conversionData);
</ins><span class="cx">
</span><span class="cx"> if (slices->bottom()->isNumber())
</span><span class="cx"> box.m_bottom = Length(slices->bottom()->getIntValue(), Relative);
</span><span class="cx"> else if (slices->bottom()->isPercentage())
</span><span class="cx"> box.m_bottom = Length(slices->bottom()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
</span><span class="cx"> else if (slices->bottom()->getValueID() != CSSValueAuto)
</span><del>- box.m_bottom = slices->bottom()->computeLength<Length>(style(), rootElementStyle(), zoom);
</del><ins>+ box.m_bottom = slices->bottom()->computeLength<Length>(conversionData);
</ins><span class="cx">
</span><span class="cx"> if (slices->left()->isNumber())
</span><span class="cx"> box.m_left = Length(slices->left()->getIntValue(), Relative);
</span><span class="cx"> else if (slices->left()->isPercentage())
</span><span class="cx"> box.m_left = Length(slices->left()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
</span><span class="cx"> else if (slices->left()->getValueID() != CSSValueAuto)
</span><del>- box.m_left = slices->left()->computeLength<Length>(style(), rootElementStyle(), zoom);
</del><ins>+ box.m_left = slices->left()->computeLength<Length>(conversionData);
</ins><span class="cx">
</span><span class="cx"> return box;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSToStyleMaph"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSToStyleMap.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSToStyleMap.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/CSSToStyleMap.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -43,7 +43,7 @@
</span><span class="cx"> WTF_MAKE_FAST_ALLOCATED;
</span><span class="cx">
</span><span class="cx"> public:
</span><del>- CSSToStyleMap(StyleResolver* resolver) : m_resolver(resolver) { }
</del><ins>+ CSSToStyleMap(StyleResolver*);
</ins><span class="cx">
</span><span class="cx"> void mapFillAttachment(CSSPropertyID, FillLayer*, CSSValue*);
</span><span class="cx"> void mapFillClip(CSSPropertyID, FillLayer*, CSSValue*);
</span></span></pre></div>
<a id="trunkSourceWebCorecssDeprecatedStyleBuildercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/DeprecatedStyleBuilder.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/DeprecatedStyleBuilder.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/DeprecatedStyleBuilder.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -220,7 +220,7 @@
</span><span class="cx"> else if (valueType == Number)
</span><span class="cx"> setValue(styleResolver->style(), *primitiveValue);
</span><span class="cx"> else if (valueType == ComputeLength)
</span><del>- setValue(styleResolver->style(), primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom()));
</del><ins>+ setValue(styleResolver->style(), primitiveValue->computeLength<T>(styleResolver->state().cssToLengthConversionData()));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static PropertyHandler createHandler() { return PropertyHandler(&applyInheritValue, &applyInitialValue, &applyValue); }
</span><span class="lines">@@ -230,7 +230,7 @@
</span><span class="cx"> private:
</span><span class="cx"> static Length convertToLength(StyleResolver* styleResolver, CSSPrimitiveValue* value)
</span><span class="cx"> {
</span><del>- return value->convertToLength<FixedIntegerConversion | PercentConversion | FractionConversion | AutoConversion>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());
</del><ins>+ return value->convertToLength<FixedIntegerConversion | PercentConversion | FractionConversion | AutoConversion>(styleResolver->state().cssToLengthConversionData());
</ins><span class="cx"> }
</span><span class="cx"> public:
</span><span class="cx"> static void applyInheritValue(CSSPropertyID propertyID, StyleResolver* styleResolver)
</span><span class="lines">@@ -387,13 +387,13 @@
</span><span class="cx"> if (autoEnabled && primitiveValue->getValueID() == CSSValueAuto)
</span><span class="cx"> setValue(styleResolver->style(), Length());
</span><span class="cx"> else if (primitiveValue->isLength()) {
</span><del>- Length length = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());
</del><ins>+ Length length = primitiveValue->computeLength<Length>(styleResolver->state().cssToLengthConversionData());
</ins><span class="cx"> length.setHasQuirk(primitiveValue->isQuirkValue());
</span><span class="cx"> setValue(styleResolver->style(), length);
</span><span class="cx"> } else if (primitiveValue->isPercentage())
</span><span class="cx"> setValue(styleResolver->style(), Length(primitiveValue->getDoubleValue(), Percent));
</span><span class="cx"> else if (primitiveValue->isCalculatedPercentageWithLength())
</span><del>- setValue(styleResolver->style(), Length(primitiveValue->cssCalcValue()->createCalculationValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));
</del><ins>+ setValue(styleResolver->style(), Length(primitiveValue->cssCalcValue()->createCalculationValue(styleResolver->state().cssToLengthConversionData())));
</ins><span class="cx"> else if (primitiveValue->isViewportPercentageLength())
</span><span class="cx"> setValue(styleResolver->style(), primitiveValue->viewportPercentageLength());
</span><span class="cx"> }
</span><span class="lines">@@ -442,15 +442,16 @@
</span><span class="cx"> if (!pair || !pair->first() || !pair->second())
</span><span class="cx"> return;
</span><span class="cx">
</span><ins>+ CSSToLengthConversionData conversionData = styleResolver->state().cssToLengthConversionData();
</ins><span class="cx"> Length radiusWidth;
</span><span class="cx"> if (pair->first()->isPercentage())
</span><span class="cx"> radiusWidth = Length(pair->first()->getDoubleValue(), Percent);
</span><span class="cx"> else if (pair->first()->isViewportPercentageLength())
</span><span class="cx"> radiusWidth = Length(styleResolver->viewportPercentageValue(*pair->first(), pair->first()->getIntValue()), Fixed);
</span><span class="cx"> else if (pair->first()->isCalculatedPercentageWithLength())
</span><del>- radiusWidth = Length(pair->first()->cssCalcValue()->createCalculationValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom()));
</del><ins>+ radiusWidth = Length(pair->first()->cssCalcValue()->createCalculationValue(conversionData));
</ins><span class="cx"> else
</span><del>- radiusWidth = pair->first()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());
</del><ins>+ radiusWidth = pair->first()->computeLength<Length>(conversionData);
</ins><span class="cx">
</span><span class="cx"> Length radiusHeight;
</span><span class="cx"> if (pair->second()->isPercentage())
</span><span class="lines">@@ -458,9 +459,9 @@
</span><span class="cx"> else if (pair->second()->isViewportPercentageLength())
</span><span class="cx"> radiusHeight = Length(styleResolver->viewportPercentageValue(*pair->second(), pair->second()->getIntValue()), Fixed);
</span><span class="cx"> else if (pair->second()->isCalculatedPercentageWithLength())
</span><del>- radiusHeight = Length(pair->second()->cssCalcValue()->createCalculationValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom()));
</del><ins>+ radiusHeight = Length(pair->second()->cssCalcValue()->createCalculationValue(conversionData));
</ins><span class="cx"> else
</span><del>- radiusHeight = pair->second()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());
</del><ins>+ radiusHeight = pair->second()->computeLength<Length>(conversionData);
</ins><span class="cx">
</span><span class="cx"> if (radiusWidth.isNegative() || radiusHeight.isNegative())
</span><span class="cx"> return;
</span><span class="lines">@@ -611,13 +612,13 @@
</span><span class="cx"> } else if (thicknessEnabled && ident == CSSValueThick) {
</span><span class="cx"> length = 5;
</span><span class="cx"> } else if (ident == CSSValueInvalid) {
</span><del>- float zoom = (svgZoomEnabled && styleResolver->useSVGZoomRules()) ? 1.0f : styleResolver->style()->effectiveZoom();
</del><ins>+ CSSToLengthConversionData conversionData = (svgZoomEnabled && styleResolver->useSVGZoomRules()) ? styleResolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f) : styleResolver->state().cssToLengthConversionData();
</ins><span class="cx">
</span><span class="cx"> // Any original result that was >= 1 should not be allowed to fall below 1.
</span><span class="cx"> // This keeps border lines from vanishing.
</span><del>- length = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), zoom);
- if (zoom < 1.0f && length < 1.0) {
- T originalLength = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), 1.0);
</del><ins>+ length = primitiveValue->computeLength<T>(conversionData);
+ if (conversionData.zoom() < 1.0f && length < 1.0) {
+ T originalLength = primitiveValue->computeLength<T>(conversionData.copyWithAdjustedZoom(1.0f));
</ins><span class="cx"> if (originalLength >= 1.0)
</span><span class="cx"> length = 1.0;
</span><span class="cx"> }
</span><span class="lines">@@ -868,11 +869,11 @@
</span><span class="cx"> fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize
</span><span class="cx"> || !(primitiveValue->isPercentage() || primitiveValue->isFontRelativeLength()));
</span><span class="cx"> if (primitiveValue->isLength())
</span><del>- size = primitiveValue->computeLength<float>(styleResolver->parentStyle(), styleResolver->rootElementStyle(), 1.0, true);
</del><ins>+ size = primitiveValue->computeLength<float>(CSSToLengthConversionData(styleResolver->parentStyle(), styleResolver->rootElementStyle(), 1.0f, true));
</ins><span class="cx"> else if (primitiveValue->isPercentage())
</span><span class="cx"> size = (primitiveValue->getFloatValue() * parentSize) / 100.0f;
</span><span class="cx"> else if (primitiveValue->isCalculatedPercentageWithLength()) {
</span><del>- Ref<CalculationValue> calculationValue { primitiveValue->cssCalcValue()->createCalculationValue(styleResolver->parentStyle(), styleResolver->rootElementStyle()) };
</del><ins>+ Ref<CalculationValue> calculationValue { primitiveValue->cssCalcValue()->createCalculationValue(styleResolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f)) };
</ins><span class="cx"> size = calculationValue->evaluate(parentSize);
</span><span class="cx"> } else if (primitiveValue->isViewportPercentageLength())
</span><span class="cx"> size = valueForLength(primitiveValue->viewportPercentageLength(), 0, styleResolver->document().renderView());
</span><span class="lines">@@ -1292,6 +1293,14 @@
</span><span class="cx"> return TextDecorationSkipNone;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+static inline CSSToLengthConversionData csstoLengthConversionDataWithTextZoomFactor(StyleResolver& styleResolver)
+{
+ if (Frame* frame = styleResolver.document().frame())
+ return styleResolver.state().cssToLengthConversionData().copyWithAdjustedZoom(styleResolver.style()->effectiveZoom() * frame->textZoomFactor());
+
+ return styleResolver.state().cssToLengthConversionData();
+}
+
</ins><span class="cx"> class ApplyPropertyTextDecorationSkip {
</span><span class="cx"> public:
</span><span class="cx"> static void applyValue(CSSPropertyID, StyleResolver* styleResolver, CSSValue* value)
</span><span class="lines">@@ -1336,7 +1345,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> } else {
</span><del>- Length marqueeLength = styleResolver->convertToIntLength(primitiveValue, styleResolver->style(), styleResolver->rootElementStyle());
</del><ins>+ Length marqueeLength = styleResolver->convertToIntLength(primitiveValue, styleResolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
</ins><span class="cx"> if (!marqueeLength.isUndefined())
</span><span class="cx"> styleResolver->style()->setMarqueeIncrement(marqueeLength);
</span><span class="cx"> }
</span><span class="lines">@@ -1442,10 +1451,7 @@
</span><span class="cx"> if (primitiveValue->getValueID() == CSSValueNormal)
</span><span class="cx"> lineHeight = RenderStyle::initialLineHeight();
</span><span class="cx"> else if (primitiveValue->isLength()) {
</span><del>- double multiplier = styleResolver->style()->effectiveZoom();
- if (Frame* frame = styleResolver->document().frame())
- multiplier *= frame->textZoomFactor();
- lineHeight = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), multiplier);
</del><ins>+ lineHeight = primitiveValue->computeLength<Length>(csstoLengthConversionDataWithTextZoomFactor(*styleResolver));
</ins><span class="cx"> } else if (primitiveValue->isPercentage()) {
</span><span class="cx"> // FIXME: percentage should not be restricted to an integer here.
</span><span class="cx"> lineHeight = Length((styleResolver->style()->computedFontSize() * primitiveValue->getIntValue()) / 100, Fixed);
</span><span class="lines">@@ -1480,12 +1486,7 @@
</span><span class="cx"> if (primitiveValue->getValueID() == CSSValueNormal)
</span><span class="cx"> lineHeight = RenderStyle::initialLineHeight();
</span><span class="cx"> else if (primitiveValue->isLength()) {
</span><del>- double multiplier = styleResolver->style()->effectiveZoom();
- if (styleResolver->style()->textSizeAdjust().isNone()) {
- if (Frame* frame = styleResolver->document().frame())
- multiplier *= frame->textZoomFactor();
- }
- lineHeight = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), multiplier);
</del><ins>+ lineHeight = primitiveValue->computeLength<Length>(csstoLengthConversionDataWithTextZoomFactor(*styleResolver));
</ins><span class="cx"> if (styleResolver->style()->textSizeAdjust().isPercentage())
</span><span class="cx"> lineHeight = Length(lineHeight.value() * styleResolver->style()->textSizeAdjust().multiplier(), Fixed);
</span><span class="cx"> } else if (primitiveValue->isPercentage()) {
</span><span class="lines">@@ -1537,10 +1538,7 @@
</span><span class="cx"> if (primitiveValue->getValueID() == CSSValueNormal)
</span><span class="cx"> wordSpacing = RenderStyle::initialWordSpacing();
</span><span class="cx"> else if (primitiveValue->isLength()) {
</span><del>- double multiplier = styleResolver->style()->effectiveZoom();
- if (Frame* frame = styleResolver->document().frame())
- multiplier *= frame->textZoomFactor();
- wordSpacing = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), multiplier);
</del><ins>+ wordSpacing = primitiveValue->computeLength<Length>(csstoLengthConversionDataWithTextZoomFactor(*styleResolver));
</ins><span class="cx"> } else if (primitiveValue->isPercentage())
</span><span class="cx"> wordSpacing = Length(primitiveValue->getDoubleValue(), Percent);
</span><span class="cx"> else if (primitiveValue->isNumber())
</span><span class="lines">@@ -1563,12 +1561,12 @@
</span><span class="cx"> static Length mmLength(double mm)
</span><span class="cx"> {
</span><span class="cx"> Ref<CSSPrimitiveValue> value(CSSPrimitiveValue::create(mm, CSSPrimitiveValue::CSS_MM));
</span><del>- return value.get().computeLength<Length>(0, 0);
</del><ins>+ return value.get().computeLength<Length>(CSSToLengthConversionData());
</ins><span class="cx"> }
</span><span class="cx"> static Length inchLength(double inch)
</span><span class="cx"> {
</span><span class="cx"> Ref<CSSPrimitiveValue> value(CSSPrimitiveValue::create(inch, CSSPrimitiveValue::CSS_IN));
</span><del>- return value.get().computeLength<Length>(0, 0);
</del><ins>+ return value.get().computeLength<Length>(CSSToLengthConversionData());
</ins><span class="cx"> }
</span><span class="cx"> static bool getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CSSPrimitiveValue* pageOrientation, Length& width, Length& height)
</span><span class="cx"> {
</span><span class="lines">@@ -1664,8 +1662,9 @@
</span><span class="cx"> // <length>{2}
</span><span class="cx"> if (!second->isLength())
</span><span class="cx"> return;
</span><del>- width = first->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle());
- height = second->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle());
</del><ins>+ CSSToLengthConversionData conversionData = styleResolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f);
+ width = first->computeLength<Length>(conversionData);
+ height = second->computeLength<Length>(conversionData);
</ins><span class="cx"> } else {
</span><span class="cx"> // <page-size> <orientation>
</span><span class="cx"> // The value order is guaranteed. See CSSParser::parseSizeParameter.
</span><span class="lines">@@ -1683,7 +1682,7 @@
</span><span class="cx"> if (primitiveValue->isLength()) {
</span><span class="cx"> // <length>
</span><span class="cx"> pageSizeType = PAGE_SIZE_RESOLVED;
</span><del>- width = height = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle());
</del><ins>+ width = height = primitiveValue->computeLength<Length>(styleResolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
</ins><span class="cx"> } else {
</span><span class="cx"> switch (primitiveValue->getValueID()) {
</span><span class="cx"> case 0:
</span><span class="lines">@@ -1961,7 +1960,7 @@
</span><span class="cx"> if (primitiveValue->getValueID())
</span><span class="cx"> return styleResolver->style()->setVerticalAlign(*primitiveValue);
</span><span class="cx">
</span><del>- styleResolver->style()->setVerticalAlignLength(primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | ViewportPercentageConversion>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom()));
</del><ins>+ styleResolver->style()->setVerticalAlignLength(primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | ViewportPercentageConversion>(styleResolver->state().cssToLengthConversionData()));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static PropertyHandler createHandler()
</span><span class="lines">@@ -2139,7 +2138,7 @@
</span><span class="cx"> for (unsigned i = 0; i < valueList.length(); ++i) {
</span><span class="cx"> auto& primitiveValue = toCSSPrimitiveValue(*valueList.itemWithoutBoundsCheck(i));
</span><span class="cx"> if (primitiveValue.isShape() && !operation)
</span><del>- operation = ShapeClipPathOperation::create(basicShapeForValue(styleResolver->style(), styleResolver->rootElementStyle(), primitiveValue.getShapeValue()));
</del><ins>+ operation = ShapeClipPathOperation::create(basicShapeForValue(styleResolver->state().cssToLengthConversionData(), primitiveValue.getShapeValue()));
</ins><span class="cx"> else if ((primitiveValue.getValueID() == CSSValueContentBox
</span><span class="cx"> || primitiveValue.getValueID() == CSSValueBorderBox
</span><span class="cx"> || primitiveValue.getValueID() == CSSValuePaddingBox
</span><span class="lines">@@ -2188,7 +2187,7 @@
</span><span class="cx"> for (unsigned i = 0; i < valueList->length(); ++i) {
</span><span class="cx"> CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(valueList->itemWithoutBoundsCheck(i));
</span><span class="cx"> if (primitiveValue->isShape())
</span><del>- shape = basicShapeForValue(styleResolver->style(), styleResolver->rootElementStyle(), primitiveValue->getShapeValue());
</del><ins>+ shape = basicShapeForValue(styleResolver->state().cssToLengthConversionData(), primitiveValue->getShapeValue());
</ins><span class="cx"> else if (primitiveValue->getValueID() == CSSValueContentBox
</span><span class="cx"> || primitiveValue->getValueID() == CSSValueBorderBox
</span><span class="cx"> || primitiveValue->getValueID() == CSSValuePaddingBox
</span><span class="lines">@@ -2301,7 +2300,7 @@
</span><span class="cx">
</span><span class="cx"> CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(item);
</span><span class="cx"> if (!primitiveValue->getValueID())
</span><del>- lengthOrPercentageValue = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | ViewportPercentageConversion>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());
</del><ins>+ lengthOrPercentageValue = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | ViewportPercentageConversion>(styleResolver->state().cssToLengthConversionData());
</ins><span class="cx"> #if ENABLE(CSS3_TEXT)
</span><span class="cx"> else if (primitiveValue->getValueID() == CSSValueWebkitEachLine)
</span><span class="cx"> textIndentLineValue = TextIndentEachLine;
</span></span></pre></div>
<a id="trunkSourceWebCorecssMediaQueryEvaluatorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/MediaQueryEvaluator.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/MediaQueryEvaluator.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/MediaQueryEvaluator.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -31,6 +31,7 @@
</span><span class="cx">
</span><span class="cx"> #include "CSSAspectRatioValue.h"
</span><span class="cx"> #include "CSSPrimitiveValue.h"
</span><ins>+#include "CSSToLengthConversionData.h"
</ins><span class="cx"> #include "CSSValueKeywords.h"
</span><span class="cx"> #include "CSSValueList.h"
</span><span class="cx"> #include "Chrome.h"
</span><span class="lines">@@ -69,7 +70,7 @@
</span><span class="cx">
</span><span class="cx"> enum MediaFeaturePrefix { MinPrefix, MaxPrefix, NoPrefix };
</span><span class="cx">
</span><del>-typedef bool (*EvalFunc)(CSSValue*, RenderStyle*, Frame*, MediaFeaturePrefix);
</del><ins>+typedef bool (*EvalFunc)(CSSValue*, const CSSToLengthConversionData&, Frame*, MediaFeaturePrefix);
</ins><span class="cx"> typedef HashMap<AtomicStringImpl*, EvalFunc> FunctionMap;
</span><span class="cx"> static FunctionMap* gFunctionMap;
</span><span class="cx">
</span><span class="lines">@@ -203,7 +204,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool colorMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool colorMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> int bitsPerComponent = screenDepthPerComponent(frame->page()->mainFrame().view());
</span><span class="cx"> float number;
</span><span class="lines">@@ -213,7 +214,7 @@
</span><span class="cx"> return bitsPerComponent != 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool color_indexMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
</del><ins>+static bool color_indexMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame*, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> // FIXME: It's unknown how to retrieve the information if the display mode is indexed
</span><span class="cx"> // Assume we don't support indexed display.
</span><span class="lines">@@ -224,7 +225,7 @@
</span><span class="cx"> return numberValue(value, number) && compareValue(0, static_cast<int>(number), op);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool monochromeMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (!screenIsMonochrome(frame->page()->mainFrame().view())) {
</span><span class="cx"> if (value) {
</span><span class="lines">@@ -234,10 +235,10 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- return colorMediaFeatureEval(value, style, frame, op);
</del><ins>+ return colorMediaFeatureEval(value, conversionData, frame, op);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool orientationMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool orientationMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><span class="cx"> FrameView* view = frame->view();
</span><span class="cx"> if (!view)
</span><span class="lines">@@ -256,7 +257,7 @@
</span><span class="cx"> return height >= 0 && width >= 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool aspect_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> FrameView* view = frame->view();
</span><span class="cx"> if (!view)
</span><span class="lines">@@ -270,7 +271,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool device_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool device_aspect_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (value) {
</span><span class="cx"> FloatRect sg = screenRect(frame->page()->mainFrame().view());
</span><span class="lines">@@ -314,12 +315,12 @@
</span><span class="cx"> return compareValue(deviceScaleFactor, resolution->isNumber() ? resolution->getFloatValue() : resolution->getFloatValue(CSSPrimitiveValue::CSS_DPPX), op);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool device_pixel_ratioMediaFeatureEval(CSSValue *value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool device_pixel_ratioMediaFeatureEval(CSSValue *value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> return (!value || toCSSPrimitiveValue(value)->isNumber()) && evalResolution(value, frame, op);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool resolutionMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool resolutionMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> #if ENABLE(RESOLUTION_MEDIA_QUERY)
</span><span class="cx"> return (!value || toCSSPrimitiveValue(value)->isResolution()) && evalResolution(value, frame, op);
</span><span class="lines">@@ -331,7 +332,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool gridMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
</del><ins>+static bool gridMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame*, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> // if output device is bitmap, grid: 0 == true
</span><span class="cx"> // assume we have bitmap device
</span><span class="lines">@@ -341,7 +342,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool computeLength(CSSValue* value, bool strict, RenderStyle* style, RenderStyle* rootStyle, int& result)
</del><ins>+static bool computeLength(CSSValue* value, bool strict, const CSSToLengthConversionData& conversionData, int& result)
</ins><span class="cx"> {
</span><span class="cx"> if (!value->isPrimitiveValue())
</span><span class="cx"> return false;
</span><span class="lines">@@ -354,42 +355,40 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (primitiveValue->isLength()) {
</span><del>- result = primitiveValue->computeLength<int>(style, rootStyle);
</del><ins>+ result = primitiveValue->computeLength<int>(conversionData);
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool device_heightMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (value) {
</span><span class="cx"> FloatRect sg = screenRect(frame->page()->mainFrame().view());
</span><del>- RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
</del><span class="cx"> int length;
</span><span class="cx"> long height = sg.height();
</span><del>- return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(static_cast<int>(height), length, op);
</del><ins>+ return computeLength(value, !frame->document()->inQuirksMode(), conversionData, length) && compareValue(static_cast<int>(height), length, op);
</ins><span class="cx"> }
</span><span class="cx"> // ({,min-,max-}device-height)
</span><span class="cx"> // assume if we have a device, assume non-zero
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool device_widthMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (value) {
</span><span class="cx"> FloatRect sg = screenRect(frame->page()->mainFrame().view());
</span><del>- RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
</del><span class="cx"> int length;
</span><span class="cx"> long width = sg.width();
</span><del>- return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(static_cast<int>(width), length, op);
</del><ins>+ return computeLength(value, !frame->document()->inQuirksMode(), conversionData, length) && compareValue(static_cast<int>(width), length, op);
</ins><span class="cx"> }
</span><span class="cx"> // ({,min-,max-}device-width)
</span><span class="cx"> // assume if we have a device, assume non-zero
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool heightMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> FrameView* view = frame->view();
</span><span class="cx"> if (!view)
</span><span class="lines">@@ -399,15 +398,14 @@
</span><span class="cx"> int height = view->layoutHeight();
</span><span class="cx"> if (RenderView* renderView = frame->document()->renderView())
</span><span class="cx"> height = adjustForAbsoluteZoom(height, *renderView);
</span><del>- RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
</del><span class="cx"> int length;
</span><del>- return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(height, length, op);
</del><ins>+ return computeLength(value, !frame->document()->inQuirksMode(), conversionData, length) && compareValue(height, length, op);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return view->layoutHeight() != 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool widthMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> FrameView* view = frame->view();
</span><span class="cx"> if (!view)
</span><span class="lines">@@ -417,9 +415,8 @@
</span><span class="cx"> int width = view->layoutWidth();
</span><span class="cx"> if (RenderView* renderView = frame->document()->renderView())
</span><span class="cx"> width = adjustForAbsoluteZoom(width, *renderView);
</span><del>- RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
</del><span class="cx"> int length;
</span><del>- return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(width, length, op);
</del><ins>+ return computeLength(value, !frame->document()->inQuirksMode(), conversionData, length) && compareValue(width, length, op);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return view->layoutWidth() != 0;
</span><span class="lines">@@ -427,117 +424,117 @@
</span><span class="cx">
</span><span class="cx"> // rest of the functions are trampolines which set the prefix according to the media feature expression used
</span><span class="cx">
</span><del>-static bool min_colorMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_colorMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return colorMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return colorMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_colorMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_colorMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return colorMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return colorMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_color_indexMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_color_indexMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return color_indexMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return color_indexMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_color_indexMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_color_indexMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return color_indexMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return color_indexMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_monochromeMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return monochromeMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return monochromeMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_monochromeMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return monochromeMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return monochromeMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_aspect_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return aspect_ratioMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return aspect_ratioMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_aspect_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return aspect_ratioMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return aspect_ratioMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_device_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_device_aspect_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_aspect_ratioMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return device_aspect_ratioMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_device_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_device_aspect_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_aspect_ratioMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return device_aspect_ratioMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_device_pixel_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_device_pixel_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_pixel_ratioMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return device_pixel_ratioMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_device_pixel_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_device_pixel_ratioMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_pixel_ratioMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return device_pixel_ratioMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_heightMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return heightMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return heightMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_heightMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return heightMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return heightMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_widthMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return widthMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return widthMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_widthMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return widthMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return widthMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_device_heightMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_heightMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return device_heightMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_device_heightMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_heightMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return device_heightMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_device_widthMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_widthMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return device_widthMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_device_widthMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return device_widthMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return device_widthMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool min_resolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool min_resolutionMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return resolutionMediaFeatureEval(value, style, frame, MinPrefix);
</del><ins>+ return resolutionMediaFeatureEval(value, conversionData, frame, MinPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool max_resolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool max_resolutionMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData& conversionData, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><del>- return resolutionMediaFeatureEval(value, style, frame, MaxPrefix);
</del><ins>+ return resolutionMediaFeatureEval(value, conversionData, frame, MaxPrefix);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static bool animationMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
</del><ins>+static bool animationMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame*, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (value) {
</span><span class="cx"> float number;
</span><span class="lines">@@ -546,7 +543,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool transitionMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
</del><ins>+static bool transitionMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame*, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (value) {
</span><span class="cx"> float number;
</span><span class="lines">@@ -555,7 +552,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool transform_2dMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
</del><ins>+static bool transform_2dMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame*, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> if (value) {
</span><span class="cx"> float number;
</span><span class="lines">@@ -564,7 +561,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool transform_3dMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool transform_3dMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> bool returnValueIfNoParameter;
</span><span class="cx"> int have3dRendering;
</span><span class="lines">@@ -590,7 +587,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(VIEW_MODE_CSS_MEDIA)
</span><del>-static bool view_modeMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
</del><ins>+static bool view_modeMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix op)
</ins><span class="cx"> {
</span><span class="cx"> UNUSED_PARAM(op);
</span><span class="cx"> if (!value)
</span><span class="lines">@@ -635,7 +632,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool video_playable_inlineMediaFeatureEval(CSSValue*, RenderStyle*, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool video_playable_inlineMediaFeatureEval(CSSValue*, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><span class="cx"> return !isRunningOnIPhoneOrIPod() || frame->settings().mediaPlaybackAllowsInline();
</span><span class="cx"> }
</span><span class="lines">@@ -657,7 +654,7 @@
</span><span class="cx"> return UnknownPointer;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool hoverMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool hoverMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><span class="cx"> PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame);
</span><span class="cx">
</span><span class="lines">@@ -678,7 +675,7 @@
</span><span class="cx"> || (pointer == MousePointer && number == 1);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool pointerMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix)
</del><ins>+static bool pointerMediaFeatureEval(CSSValue* value, const CSSToLengthConversionData&, Frame* frame, MediaFeaturePrefix)
</ins><span class="cx"> {
</span><span class="cx"> PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame);
</span><span class="cx">
</span><span class="lines">@@ -727,8 +724,10 @@
</span><span class="cx"> // and let trampoline functions override the prefix if prefix is
</span><span class="cx"> // used
</span><span class="cx"> EvalFunc func = gFunctionMap->get(expr->mediaFeature().impl());
</span><del>- if (func)
- return func(expr->value(), m_style.get(), m_frame, NoPrefix);
</del><ins>+ if (func) {
+ CSSToLengthConversionData conversionData(m_style.get(), m_frame->document()->documentElement()->renderStyle());
+ return func(expr->value(), conversionData, m_frame, NoPrefix);
+ }
</ins><span class="cx">
</span><span class="cx"> return false;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssSVGCSSStyleSelectorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SVGCSSStyleSelector.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SVGCSSStyleSelector.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/SVGCSSStyleSelector.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -593,9 +593,9 @@
</span><span class="cx"> if (!firstValue->isShadowValue())
</span><span class="cx"> return;
</span><span class="cx"> CSSShadowValue* item = toCSSShadowValue(firstValue);
</span><del>- IntPoint location(item->x->computeLength<int>(state.style(), state.rootElementStyle()),
- item->y->computeLength<int>(state.style(), state.rootElementStyle()));
- int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle()) : 0;
</del><ins>+ IntPoint location(item->x->computeLength<int>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f)),
+ item->y->computeLength<int>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f)));
+ int blur = item->blur ? item->blur->computeLength<int>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f)) : 0;
</ins><span class="cx"> Color color;
</span><span class="cx"> if (item->color)
</span><span class="cx"> color = colorFromPrimitiveValue(item->color.get());
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleResolvercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleResolver.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleResolver.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/StyleResolver.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -243,6 +243,7 @@
</span><span class="cx"> #if ENABLE(CSS_FILTERS)
</span><span class="cx"> m_filtersWithPendingSVGDocuments.clear();
</span><span class="cx"> #endif
</span><ins>+ m_cssToLengthConversionData = CSSToLengthConversionData(nullptr, nullptr);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void StyleResolver::MatchResult::addMatchedProperties(const StyleProperties& properties, StyleRule* rule, unsigned linkMatchType, PropertyWhitelistType propertyWhitelistType)
</span><span class="lines">@@ -422,6 +423,8 @@
</span><span class="cx"> m_style = nullptr;
</span><span class="cx"> m_pendingImageProperties.clear();
</span><span class="cx"> m_fontDirty = false;
</span><ins>+
+ m_cssToLengthConversionData = CSSToLengthConversionData(m_style.get(), m_rootElementStyle);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static const unsigned cStyleSearchThreshold = 10;
</span><span class="lines">@@ -1448,14 +1451,14 @@
</span><span class="cx"> // -------------------------------------------------------------------------------------
</span><span class="cx"> // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
</span><span class="cx">
</span><del>-Length StyleResolver::convertToIntLength(const CSSPrimitiveValue* primitiveValue, const RenderStyle* style, const RenderStyle* rootStyle, double multiplier)
</del><ins>+Length StyleResolver::convertToIntLength(const CSSPrimitiveValue* primitiveValue, const CSSToLengthConversionData& conversionData)
</ins><span class="cx"> {
</span><del>- return primitiveValue ? primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
</del><ins>+ return primitiveValue ? primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(conversionData) : Length(Undefined);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-Length StyleResolver::convertToFloatLength(const CSSPrimitiveValue* primitiveValue, const RenderStyle* style, const RenderStyle* rootStyle, double multiplier)
</del><ins>+Length StyleResolver::convertToFloatLength(const CSSPrimitiveValue* primitiveValue, const CSSToLengthConversionData& conversionData)
</ins><span class="cx"> {
</span><del>- return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
</del><ins>+ return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(conversionData) : Length(Undefined);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static bool shouldApplyPropertyInParseOrder(CSSPropertyID propertyID)
</span><span class="lines">@@ -1856,7 +1859,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- workingLength = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | ViewportPercentageConversion | CalculatedConversion | AutoConversion>(state.style(), state.rootElementStyle(), state.style()->effectiveZoom());
</del><ins>+ workingLength = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | ViewportPercentageConversion | CalculatedConversion | AutoConversion>(state.cssToLengthConversionData());
</ins><span class="cx"> if (workingLength.length().isUndefined())
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -2022,8 +2025,6 @@
</span><span class="cx">
</span><span class="cx"> CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? toCSSPrimitiveValue(value) : 0;
</span><span class="cx">
</span><del>- float zoomFactor = state.style()->effectiveZoom();
-
</del><span class="cx"> // What follows is a list that maps the CSS properties into their corresponding front-end
</span><span class="cx"> // RenderStyle values.
</span><span class="cx"> switch (id) {
</span><span class="lines">@@ -2301,16 +2302,16 @@
</span><span class="cx"> if (!currValue->isShadowValue())
</span><span class="cx"> continue;
</span><span class="cx"> CSSShadowValue* item = toCSSShadowValue(currValue);
</span><del>- int x = item->x->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);
</del><ins>+ int x = item->x->computeLength<int>(state.cssToLengthConversionData());
</ins><span class="cx"> if (item->x->isViewportPercentageLength())
</span><span class="cx"> x = viewportPercentageValue(*item->x, x);
</span><del>- int y = item->y->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);
</del><ins>+ int y = item->y->computeLength<int>(state.cssToLengthConversionData());
</ins><span class="cx"> if (item->y->isViewportPercentageLength())
</span><span class="cx"> y = viewportPercentageValue(*item->y, y);
</span><del>- int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;
</del><ins>+ int blur = item->blur ? item->blur->computeLength<int>(state.cssToLengthConversionData()) : 0;
</ins><span class="cx"> if (item->blur && item->blur->isViewportPercentageLength())
</span><span class="cx"> blur = viewportPercentageValue(*item->blur, blur);
</span><del>- int spread = item->spread ? item->spread->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;
</del><ins>+ int spread = item->spread ? item->spread->computeLength<int>(state.cssToLengthConversionData()) : 0;
</ins><span class="cx"> if (item->spread && item->spread->isViewportPercentageLength())
</span><span class="cx"> spread = viewportPercentageValue(*item->spread, spread);
</span><span class="cx"> ShadowStyle shadowStyle = item->style && item->style->getValueID() == CSSValueInset ? Inset : Normal;
</span><span class="lines">@@ -2342,7 +2343,7 @@
</span><span class="cx"> RefPtr<StyleReflection> reflection = StyleReflection::create();
</span><span class="cx"> reflection->setDirection(*reflectValue->direction());
</span><span class="cx"> if (reflectValue->offset())
</span><del>- reflection->setOffset(reflectValue->offset()->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(state.style(), state.rootElementStyle(), zoomFactor));
</del><ins>+ reflection->setOffset(reflectValue->offset()->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(state.cssToLengthConversionData()));
</ins><span class="cx"> NinePieceImage mask;
</span><span class="cx"> mask.setMaskDefaults();
</span><span class="cx"> m_styleMap.mapNinePieceImage(id, reflectValue->mask(), mask);
</span><span class="lines">@@ -2403,10 +2404,10 @@
</span><span class="cx">
</span><span class="cx"> DashboardRegion* first = region;
</span><span class="cx"> while (region) {
</span><del>- Length top = convertToIntLength(region->top(), state.style(), state.rootElementStyle());
- Length right = convertToIntLength(region->right(), state.style(), state.rootElementStyle());
- Length bottom = convertToIntLength(region->bottom(), state.style(), state.rootElementStyle());
- Length left = convertToIntLength(region->left(), state.style(), state.rootElementStyle());
</del><ins>+ Length top = convertToIntLength(region->top(), state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
+ Length right = convertToIntLength(region->right(), state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
+ Length bottom = convertToIntLength(region->bottom(), state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
+ Length left = convertToIntLength(region->left(), state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
</ins><span class="cx">
</span><span class="cx"> if (top.isUndefined())
</span><span class="cx"> top = Length();
</span><span class="lines">@@ -2442,11 +2443,11 @@
</span><span class="cx"> else if (primitiveValue->getValueID() == CSSValueThick)
</span><span class="cx"> result *= 5;
</span><span class="cx"> Ref<CSSPrimitiveValue> value(CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS));
</span><del>- width = value.get().computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
</del><ins>+ width = value.get().computeLength<float>(state.cssToLengthConversionData());
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> default:
</span><del>- width = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
</del><ins>+ width = primitiveValue->computeLength<float>(state.cssToLengthConversionData());
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> state.style()->setTextStrokeWidth(width);
</span><span class="lines">@@ -2455,7 +2456,7 @@
</span><span class="cx"> case CSSPropertyWebkitTransform: {
</span><span class="cx"> HANDLE_INHERIT_AND_INITIAL(transform, Transform);
</span><span class="cx"> TransformOperations operations;
</span><del>- transformsForValue(state.style(), state.rootElementStyle(), value, operations);
</del><ins>+ transformsForValue(value, state.cssToLengthConversionData(), operations);
</ins><span class="cx"> state.style()->setTransform(operations);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2472,11 +2473,11 @@
</span><span class="cx">
</span><span class="cx"> float perspectiveValue;
</span><span class="cx"> if (primitiveValue->isLength())
</span><del>- perspectiveValue = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
</del><ins>+ perspectiveValue = primitiveValue->computeLength<float>(state.cssToLengthConversionData());
</ins><span class="cx"> else if (primitiveValue->isNumber()) {
</span><span class="cx"> // For backward compatibility, treat valueless numbers as px.
</span><span class="cx"> Ref<CSSPrimitiveValue> value(CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX));
</span><del>- perspectiveValue = value.get().computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
</del><ins>+ perspectiveValue = value.get().computeLength<float>(state.cssToLengthConversionData());
</ins><span class="cx"> } else
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="lines">@@ -3314,8 +3315,6 @@
</span><span class="cx"> bool StyleResolver::createFilterOperations(CSSValue* inValue, FilterOperations& outOperations)
</span><span class="cx"> {
</span><span class="cx"> State& state = m_state;
</span><del>- RenderStyle* style = state.style();
- RenderStyle* rootStyle = state.rootElementStyle();
</del><span class="cx"> ASSERT(outOperations.isEmpty());
</span><span class="cx">
</span><span class="cx"> if (!inValue)
</span><span class="lines">@@ -3330,7 +3329,6 @@
</span><span class="cx"> if (!inValue->isValueList())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- float zoomFactor = style ? style->effectiveZoom() : 1;
</del><span class="cx"> FilterOperations operations;
</span><span class="cx"> for (CSSValueListIterator i = inValue; i.hasMore(); i.advance()) {
</span><span class="cx"> CSSValue* currValue = i.value();
</span><span class="lines">@@ -3416,7 +3414,7 @@
</span><span class="cx"> case WebKitCSSFilterValue::BlurFilterOperation: {
</span><span class="cx"> Length stdDeviation = Length(0, Fixed);
</span><span class="cx"> if (filterValue->length() >= 1)
</span><del>- stdDeviation = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ stdDeviation = convertToFloatLength(firstValue, state.cssToLengthConversionData());
</ins><span class="cx"> if (stdDeviation.isUndefined())
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -3432,14 +3430,14 @@
</span><span class="cx"> continue;
</span><span class="cx">
</span><span class="cx"> CSSShadowValue* item = toCSSShadowValue(cssValue);
</span><del>- int x = item->x->computeLength<int>(style, rootStyle, zoomFactor);
</del><ins>+ int x = item->x->computeLength<int>(state.cssToLengthConversionData());
</ins><span class="cx"> if (item->x->isViewportPercentageLength())
</span><span class="cx"> x = viewportPercentageValue(*item->x, x);
</span><del>- int y = item->y->computeLength<int>(style, rootStyle, zoomFactor);
</del><ins>+ int y = item->y->computeLength<int>(state.cssToLengthConversionData());
</ins><span class="cx"> if (item->y->isViewportPercentageLength())
</span><span class="cx"> y = viewportPercentageValue(*item->y, y);
</span><span class="cx"> IntPoint location(x, y);
</span><del>- int blur = item->blur ? item->blur->computeLength<int>(style, rootStyle, zoomFactor) : 0;
</del><ins>+ int blur = item->blur ? item->blur->computeLength<int>(state.cssToLengthConversionData()) : 0;
</ins><span class="cx"> if (item->blur && item->blur->isViewportPercentageLength())
</span><span class="cx"> blur = viewportPercentageValue(*item->blur, blur);
</span><span class="cx"> Color color;
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleResolverh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleResolver.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleResolver.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/StyleResolver.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -22,6 +22,7 @@
</span><span class="cx"> #ifndef StyleResolver_h
</span><span class="cx"> #define StyleResolver_h
</span><span class="cx">
</span><ins>+#include "CSSToLengthConversionData.h"
</ins><span class="cx"> #include "CSSToStyleMap.h"
</span><span class="cx"> #include "CSSValueList.h"
</span><span class="cx"> #include "DocumentRuleSets.h"
</span><span class="lines">@@ -354,7 +355,11 @@
</span><span class="cx"> Document& document() const { return m_element->document(); }
</span><span class="cx"> Element* element() const { return m_element; }
</span><span class="cx"> StyledElement* styledElement() const { return m_styledElement; }
</span><del>- void setStyle(PassRef<RenderStyle> style) { m_style = std::move(style); }
</del><ins>+ void setStyle(PassRef<RenderStyle> style)
+ {
+ m_style = std::move(style);
+ m_cssToLengthConversionData = CSSToLengthConversionData(m_style.get(), m_rootElementStyle);
+ }
</ins><span class="cx"> RenderStyle* style() const { return m_style.get(); }
</span><span class="cx"> PassRef<RenderStyle> takeStyle() { return m_style.releaseNonNull(); }
</span><span class="cx">
</span><span class="lines">@@ -397,6 +402,8 @@
</span><span class="cx">
</span><span class="cx"> bool useSVGZoomRules() const { return m_element && m_element->isSVGElement(); }
</span><span class="cx">
</span><ins>+ CSSToLengthConversionData cssToLengthConversionData() const { return m_cssToLengthConversionData; }
+
</ins><span class="cx"> private:
</span><span class="cx"> // FIXME(bug 108563): to make it easier to review, these member
</span><span class="cx"> // variables are public. However we should add methods to access
</span><span class="lines">@@ -428,6 +435,8 @@
</span><span class="cx"> BorderData m_borderData;
</span><span class="cx"> FillLayer m_backgroundData;
</span><span class="cx"> Color m_backgroundColor;
</span><ins>+
+ CSSToLengthConversionData m_cssToLengthConversionData;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> State& state() { return m_state; }
</span><span class="lines">@@ -445,8 +454,8 @@
</span><span class="cx"> bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }
</span><span class="cx"> bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle(); }
</span><span class="cx">
</span><del>- static Length convertToIntLength(const CSSPrimitiveValue*, const RenderStyle*, const RenderStyle* rootStyle, double multiplier = 1);
- static Length convertToFloatLength(const CSSPrimitiveValue*, const RenderStyle*, const RenderStyle* rootStyle, double multiplier = 1);
</del><ins>+ static Length convertToIntLength(const CSSPrimitiveValue*, const CSSToLengthConversionData&);
+ static Length convertToFloatLength(const CSSPrimitiveValue*, const CSSToLengthConversionData&);
</ins><span class="cx">
</span><span class="cx"> CSSToStyleMap* styleMap() { return &m_styleMap; }
</span><span class="cx"> InspectorCSSOMWrappers& inspectorCSSOMWrappers() { return m_inspectorCSSOMWrappers; }
</span></span></pre></div>
<a id="trunkSourceWebCorecssTransformFunctionscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/TransformFunctions.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/TransformFunctions.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/TransformFunctions.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -76,19 +76,18 @@
</span><span class="cx"> return TransformOperation::NONE;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static Length convertToFloatLength(const CSSPrimitiveValue* primitiveValue, const RenderStyle* style, const RenderStyle* rootStyle, double multiplier)
</del><ins>+static Length convertToFloatLength(const CSSPrimitiveValue* primitiveValue, const CSSToLengthConversionData& conversionData)
</ins><span class="cx"> {
</span><del>- return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
</del><ins>+ return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(conversionData) : Length(Undefined);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool transformsForValue(const RenderStyle* style, const RenderStyle* rootStyle, CSSValue* value, TransformOperations& outOperations)
</del><ins>+bool transformsForValue(CSSValue* value, const CSSToLengthConversionData& conversionData, TransformOperations& outOperations)
</ins><span class="cx"> {
</span><span class="cx"> if (!value || !value->isValueList()) {
</span><span class="cx"> outOperations.clear();
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- float zoomFactor = style ? style->effectiveZoom() : 1;
</del><span class="cx"> TransformOperations operations;
</span><span class="cx"> for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
</span><span class="cx"> CSSValue* currValue = i.value();
</span><span class="lines">@@ -165,13 +164,13 @@
</span><span class="cx"> Length tx = Length(0, Fixed);
</span><span class="cx"> Length ty = Length(0, Fixed);
</span><span class="cx"> if (transformValue->operationType() == WebKitCSSTransformValue::TranslateYTransformOperation)
</span><del>- ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ ty = convertToFloatLength(firstValue, conversionData);
</ins><span class="cx"> else {
</span><del>- tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ tx = convertToFloatLength(firstValue, conversionData);
</ins><span class="cx"> if (transformValue->operationType() != WebKitCSSTransformValue::TranslateXTransformOperation) {
</span><span class="cx"> if (transformValue->length() > 1) {
</span><span class="cx"> CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
</span><del>- ty = convertToFloatLength(secondValue, style, rootStyle, zoomFactor);
</del><ins>+ ty = convertToFloatLength(secondValue, conversionData);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -188,19 +187,19 @@
</span><span class="cx"> Length ty = Length(0, Fixed);
</span><span class="cx"> Length tz = Length(0, Fixed);
</span><span class="cx"> if (transformValue->operationType() == WebKitCSSTransformValue::TranslateZTransformOperation)
</span><del>- tz = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ tz = convertToFloatLength(firstValue, conversionData);
</ins><span class="cx"> else if (transformValue->operationType() == WebKitCSSTransformValue::TranslateYTransformOperation)
</span><del>- ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ ty = convertToFloatLength(firstValue, conversionData);
</ins><span class="cx"> else {
</span><del>- tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ tx = convertToFloatLength(firstValue, conversionData);
</ins><span class="cx"> if (transformValue->operationType() != WebKitCSSTransformValue::TranslateXTransformOperation) {
</span><span class="cx"> if (transformValue->length() > 2) {
</span><span class="cx"> CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
</span><del>- tz = convertToFloatLength(thirdValue, style, rootStyle, zoomFactor);
</del><ins>+ tz = convertToFloatLength(thirdValue, conversionData);
</ins><span class="cx"> }
</span><span class="cx"> if (transformValue->length() > 1) {
</span><span class="cx"> CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
</span><del>- ty = convertToFloatLength(secondValue, style, rootStyle, zoomFactor);
</del><ins>+ ty = convertToFloatLength(secondValue, conversionData);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -273,8 +272,8 @@
</span><span class="cx"> double b = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1))->getDoubleValue();
</span><span class="cx"> double c = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2))->getDoubleValue();
</span><span class="cx"> double d = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3))->getDoubleValue();
</span><del>- double e = zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(4))->getDoubleValue();
- double f = zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(5))->getDoubleValue();
</del><ins>+ double e = conversionData.zoom() * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(4))->getDoubleValue();
+ double f = conversionData.zoom() * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(5))->getDoubleValue();
</ins><span class="cx"> operations.operations().append(MatrixTransformOperation::create(a, b, c, d, e, f));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -293,8 +292,8 @@
</span><span class="cx"> toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(9))->getDoubleValue(),
</span><span class="cx"> toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(10))->getDoubleValue(),
</span><span class="cx"> toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(11))->getDoubleValue(),
</span><del>- zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(12))->getDoubleValue(),
- zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(13))->getDoubleValue(),
</del><ins>+ conversionData.zoom() * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(12))->getDoubleValue(),
+ conversionData.zoom() * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(13))->getDoubleValue(),
</ins><span class="cx"> toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(14))->getDoubleValue(),
</span><span class="cx"> toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(15))->getDoubleValue());
</span><span class="cx"> operations.operations().append(Matrix3DTransformOperation::create(matrix));
</span><span class="lines">@@ -303,7 +302,7 @@
</span><span class="cx"> case WebKitCSSTransformValue::PerspectiveTransformOperation: {
</span><span class="cx"> Length p = Length(0, Fixed);
</span><span class="cx"> if (firstValue->isLength())
</span><del>- p = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
</del><ins>+ p = convertToFloatLength(firstValue, conversionData);
</ins><span class="cx"> else {
</span><span class="cx"> // This is a quirk that should go away when 3d transforms are finalized.
</span><span class="cx"> double val = firstValue->getDoubleValue();
</span></span></pre></div>
<a id="trunkSourceWebCorecssTransformFunctionsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/TransformFunctions.h (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/TransformFunctions.h 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/TransformFunctions.h 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -34,11 +34,12 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><ins>+class CSSToLengthConversionData;
</ins><span class="cx"> class CSSValue;
</span><span class="cx"> class RenderStyle;
</span><span class="cx"> class WebKitCSSTransformValue;
</span><span class="cx">
</span><del>-bool transformsForValue(const RenderStyle*, const RenderStyle* rootStyle, CSSValue*, TransformOperations&);
</del><ins>+bool transformsForValue(CSSValue*, const CSSToLengthConversionData&, TransformOperations&);
</ins><span class="cx">
</span><span class="cx"> }
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkSourceWebCorecssWebKitCSSMatrixcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/WebKitCSSMatrix.cpp (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/WebKitCSSMatrix.cpp 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/css/WebKitCSSMatrix.cpp 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #include "CSSParser.h"
</span><span class="cx"> #include "CSSPropertyNames.h"
</span><ins>+#include "CSSToLengthConversionData.h"
</ins><span class="cx"> #include "CSSValueKeywords.h"
</span><span class="cx"> #include "ExceptionCode.h"
</span><span class="cx"> #include "StyleProperties.h"
</span><span class="lines">@@ -66,7 +67,7 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> TransformOperations operations;
</span><del>- if (!transformsForValue(0, 0, value.get(), operations)) {
</del><ins>+ if (!transformsForValue(value.get(), CSSToLengthConversionData(), operations)) {
</ins><span class="cx"> ec = SYNTAX_ERR;
</span><span class="cx"> return;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderThemeIOSmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderThemeIOS.mm (167936 => 167937)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderThemeIOS.mm 2014-04-29 16:17:09 UTC (rev 167936)
+++ trunk/Source/WebCore/rendering/RenderThemeIOS.mm 2014-04-29 16:36:43 UTC (rev 167937)
</span><span class="lines">@@ -526,7 +526,7 @@
</span><span class="cx"> {
</span><span class="cx"> Document& document = element->document();
</span><span class="cx"> RefPtr<CSSPrimitiveValue> emSize = CSSPrimitiveValue::create(0.5, CSSPrimitiveValue::CSS_EMS);
</span><del>- int pixels = emSize->computeLength<int>(style, document.renderStyle(), document.frame()->pageZoomFactor());
</del><ins>+ int pixels = emSize->computeLength<int>(CSSToLengthConversionData(style, document.renderStyle(), document.frame()->pageZoomFactor()));
</ins><span class="cx"> style->setPaddingBox(LengthBox(0, pixels, 0, pixels));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -934,7 +934,7 @@
</span><span class="cx"> // CSSPrimitiveValue::computeLengthInt only needs the element's style to calculate em lengths.
</span><span class="cx"> // Since the element might not be in a document, just pass nullptr for the root element style.
</span><span class="cx"> RefPtr<CSSPrimitiveValue> emSize = CSSPrimitiveValue::create(1.0, CSSPrimitiveValue::CSS_EMS);
</span><del>- int pixels = emSize->computeLength<int>(style, nullptr);
</del><ins>+ int pixels = emSize->computeLength<int>(CSSToLengthConversionData(style, nullptr, 1.0));
</ins><span class="cx"> style->setPaddingBox(LengthBox(0, pixels, 0, pixels));
</span><span class="cx">
</span><span class="cx"> if (!element)
</span></span></pre>
</div>
</div>
</body>
</html>