<!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>[177623] 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/177623">177623</a></dd>
<dt>Author</dt> <dd>cdumez@apple.com</dd>
<dt>Date</dt> <dd>2014-12-20 18:56:23 -0800 (Sat, 20 Dec 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Get rid of error-prone ReleaseParsedCalcValueCondition argument in CSSParser
https://bugs.webkit.org/show_bug.cgi?id=139334
Reviewed by Darin Adler.
Get rid of error-prone ReleaseParsedCalcValueCondition argument in
CSSParser that determines the the m_parsedCalculation member should
be released.
Instead, introduce a new ValueWithCalculation type which wraps a
CSSParserValue and an optional parsed calculation value. This way,
the parsed calculation value is now associated with its CSSParserValue.
This makes it very difficult to use a parsed calculation value for the
wrong CSSParserValue. The API is also easier to use as developers no
longer need to explicitly indicate if the calculation value should be
released or not.
No new tests, no web-behavior change.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssCSSParsercpp">trunk/Source/WebCore/css/CSSParser.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSParserh">trunk/Source/WebCore/css/CSSParser.h</a></li>
<li><a href="#trunkSourceWebCorecssSVGCSSParsercpp">trunk/Source/WebCore/css/SVGCSSParser.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (177622 => 177623)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-12-20 18:28:37 UTC (rev 177622)
+++ trunk/Source/WebCore/ChangeLog 2014-12-21 02:56:23 UTC (rev 177623)
</span><span class="lines">@@ -1,3 +1,24 @@
</span><ins>+2014-12-20 Chris Dumez <cdumez@apple.com>
+
+ Get rid of error-prone ReleaseParsedCalcValueCondition argument in CSSParser
+ https://bugs.webkit.org/show_bug.cgi?id=139334
+
+ Reviewed by Darin Adler.
+
+ Get rid of error-prone ReleaseParsedCalcValueCondition argument in
+ CSSParser that determines the the m_parsedCalculation member should
+ be released.
+
+ Instead, introduce a new ValueWithCalculation type which wraps a
+ CSSParserValue and an optional parsed calculation value. This way,
+ the parsed calculation value is now associated with its CSSParserValue.
+ This makes it very difficult to use a parsed calculation value for the
+ wrong CSSParserValue. The API is also easier to use as developers no
+ longer need to explicitly indicate if the calculation value should be
+ released or not.
+
+ No new tests, no web-behavior change.
+
</ins><span class="cx"> 2014-12-20 Eric Carlson <eric.carlson@apple.com>
</span><span class="cx">
</span><span class="cx"> [iOS] add optimized fullscreen API
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.cpp (177622 => 177623)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.cpp 2014-12-20 18:28:37 UTC (rev 177622)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2014-12-21 02:56:23 UTC (rev 177623)
</span><span class="lines">@@ -1582,80 +1582,82 @@
</span><span class="cx"> return completeURL(m_context, url);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::validCalculationUnit(CSSParserValue& value, Units unitflags, ReleaseParsedCalcValueCondition releaseCalc)
</del><ins>+bool CSSParser::validateCalculationUnit(ValueWithCalculation& valueWithCalculation, Units unitFlags)
</ins><span class="cx"> {
</span><del>- bool mustBeNonNegative = unitflags & FNonNeg;
</del><ins>+ bool mustBeNonNegative = unitFlags & FNonNeg;
</ins><span class="cx">
</span><del>- if (!parseCalculation(value, mustBeNonNegative ? CalculationRangeNonNegative : CalculationRangeAll))
</del><ins>+ ASSERT(!valueWithCalculation.calculation());
+ RefPtr<CSSCalcValue> calculation = parseCalculation(valueWithCalculation, mustBeNonNegative ? CalculationRangeNonNegative : CalculationRangeAll);
+ if (!calculation)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- bool b = false;
- switch (m_parsedCalculation->category()) {
</del><ins>+ bool isValid = false;
+ switch (calculation->category()) {
</ins><span class="cx"> case CalcNumber:
</span><del>- b = (unitflags & FNumber);
- if (!b && (unitflags & FInteger) && m_parsedCalculation->isInt())
- b = true;
- if (b && mustBeNonNegative && m_parsedCalculation->isNegative())
- b = false;
</del><ins>+ isValid = (unitFlags & FNumber);
+ if (!isValid && (unitFlags & FInteger) && calculation->isInt())
+ isValid = true;
+ if (isValid && mustBeNonNegative && calculation->isNegative())
+ isValid = false;
</ins><span class="cx"> break;
</span><span class="cx"> case CalcLength:
</span><del>- b = (unitflags & FLength);
</del><ins>+ isValid = (unitFlags & FLength);
</ins><span class="cx"> break;
</span><span class="cx"> case CalcPercent:
</span><del>- b = (unitflags & FPercent);
- if (b && mustBeNonNegative && m_parsedCalculation->isNegative())
- b = false;
</del><ins>+ isValid = (unitFlags & FPercent);
+ if (isValid && mustBeNonNegative && calculation->isNegative())
+ isValid = false;
</ins><span class="cx"> break;
</span><span class="cx"> case CalcPercentLength:
</span><del>- b = (unitflags & FPercent) && (unitflags & FLength);
</del><ins>+ isValid = (unitFlags & FPercent) && (unitFlags & FLength);
</ins><span class="cx"> break;
</span><span class="cx"> case CalcPercentNumber:
</span><del>- b = (unitflags & FPercent) && (unitflags & FNumber);
</del><ins>+ isValid = (unitFlags & FPercent) && (unitFlags & FNumber);
</ins><span class="cx"> break;
</span><span class="cx"> case CalcAngle:
</span><del>- b = (unitflags & FAngle);
</del><ins>+ isValid = (unitFlags & FAngle);
</ins><span class="cx"> break;
</span><span class="cx"> case CalcTime:
</span><del>- b = (unitflags & FTime);
</del><ins>+ isValid = (unitFlags & FTime);
</ins><span class="cx"> break;
</span><span class="cx"> case CalcFrequency:
</span><del>- b = (unitflags & FFrequency);
</del><ins>+ isValid = (unitFlags & FFrequency);
</ins><span class="cx"> break;
</span><span class="cx"> case CalcOther:
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- if (!b || releaseCalc == ReleaseParsedCalcValue)
- m_parsedCalculation = nullptr;
- return b;
</del><ins>+ if (isValid)
+ valueWithCalculation.setCalculation(WTF::move(calculation));
+ return isValid;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool CSSParser::shouldAcceptUnitLessValues(CSSParserValue& value, Units unitflags, CSSParserMode cssParserMode)
</del><ins>+inline bool CSSParser::shouldAcceptUnitLessValues(CSSParserValue& value, Units unitFlags, CSSParserMode cssParserMode)
</ins><span class="cx"> {
</span><span class="cx"> // Qirks mode and svg presentation attributes accept unit less values.
</span><del>- return (unitflags & (FLength | FAngle | FTime)) && (!value.fValue || cssParserMode == CSSQuirksMode || cssParserMode == SVGAttributeMode);
</del><ins>+ return (unitFlags & (FLength | FAngle | FTime)) && (!value.fValue || cssParserMode == CSSQuirksMode || cssParserMode == SVGAttributeMode);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::validUnit(CSSParserValue& value, Units unitflags, CSSParserMode cssParserMode, ReleaseParsedCalcValueCondition releaseCalc)
</del><ins>+bool CSSParser::validateUnit(ValueWithCalculation& valueWithCalculation, Units unitFlags, CSSParserMode cssParserMode)
</ins><span class="cx"> {
</span><del>- if (isCalculation(value))
- return validCalculationUnit(value, unitflags, releaseCalc);
</del><ins>+ if (isCalculation(valueWithCalculation))
+ return validateCalculationUnit(valueWithCalculation, unitFlags);
</ins><span class="cx">
</span><span class="cx"> bool b = false;
</span><del>- switch (value.unit) {
</del><ins>+ switch (valueWithCalculation.value().unit) {
</ins><span class="cx"> case CSSPrimitiveValue::CSS_NUMBER:
</span><del>- b = (unitflags & FNumber);
- if (!b && shouldAcceptUnitLessValues(value, unitflags, cssParserMode)) {
- value.unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX :
- ((unitflags & FAngle) ? CSSPrimitiveValue::CSS_DEG : CSSPrimitiveValue::CSS_MS);
</del><ins>+ b = (unitFlags & FNumber);
+ if (!b && shouldAcceptUnitLessValues(valueWithCalculation, unitFlags, cssParserMode)) {
+ valueWithCalculation.value().unit = (unitFlags & FLength) ? CSSPrimitiveValue::CSS_PX :
+ ((unitFlags & FAngle) ? CSSPrimitiveValue::CSS_DEG : CSSPrimitiveValue::CSS_MS);
</ins><span class="cx"> b = true;
</span><span class="cx"> }
</span><del>- if (!b && (unitflags & FInteger) && value.isInt)
</del><ins>+ if (!b && (unitFlags & FInteger) && valueWithCalculation.value().isInt)
</ins><span class="cx"> b = true;
</span><del>- if (!b && (unitflags & FPositiveInteger) && value.isInt && value.fValue > 0)
</del><ins>+ if (!b && (unitFlags & FPositiveInteger) && valueWithCalculation.value().isInt && valueWithCalculation.value().fValue > 0)
</ins><span class="cx"> b = true;
</span><span class="cx"> break;
</span><span class="cx"> case CSSPrimitiveValue::CSS_PERCENTAGE:
</span><del>- b = (unitflags & FPercent);
</del><ins>+ b = (unitFlags & FPercent);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSParserValue::Q_EMS:
</span><span class="cx"> case CSSPrimitiveValue::CSS_EMS:
</span><span class="lines">@@ -1672,23 +1674,23 @@
</span><span class="cx"> case CSSPrimitiveValue::CSS_VH:
</span><span class="cx"> case CSSPrimitiveValue::CSS_VMIN:
</span><span class="cx"> case CSSPrimitiveValue::CSS_VMAX:
</span><del>- b = (unitflags & FLength);
</del><ins>+ b = (unitFlags & FLength);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPrimitiveValue::CSS_MS:
</span><span class="cx"> case CSSPrimitiveValue::CSS_S:
</span><del>- b = (unitflags & FTime);
</del><ins>+ b = (unitFlags & FTime);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPrimitiveValue::CSS_DEG:
</span><span class="cx"> case CSSPrimitiveValue::CSS_RAD:
</span><span class="cx"> case CSSPrimitiveValue::CSS_GRAD:
</span><span class="cx"> case CSSPrimitiveValue::CSS_TURN:
</span><del>- b = (unitflags & FAngle);
</del><ins>+ b = (unitFlags & FAngle);
</ins><span class="cx"> break;
</span><span class="cx"> #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
</span><span class="cx"> case CSSPrimitiveValue::CSS_DPPX:
</span><span class="cx"> case CSSPrimitiveValue::CSS_DPI:
</span><span class="cx"> case CSSPrimitiveValue::CSS_DPCM:
</span><del>- b = (unitflags & FResolution);
</del><ins>+ b = (unitFlags & FResolution);
</ins><span class="cx"> break;
</span><span class="cx"> #endif
</span><span class="cx"> case CSSPrimitiveValue::CSS_HZ:
</span><span class="lines">@@ -1697,20 +1699,19 @@
</span><span class="cx"> default:
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- if (b && unitflags & FNonNeg && value.fValue < 0)
</del><ins>+ if (b && unitFlags & FNonNeg && valueWithCalculation.value().fValue < 0)
</ins><span class="cx"> b = false;
</span><del>- if (b && std::isinf(value.fValue))
</del><ins>+ if (b && std::isinf(valueWithCalculation.value().fValue))
</ins><span class="cx"> b = false;
</span><span class="cx"> return b;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline Ref<CSSPrimitiveValue> CSSParser::createPrimitiveNumericValue(CSSParserValue& value)
</del><ins>+inline Ref<CSSPrimitiveValue> CSSParser::createPrimitiveNumericValue(ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><del>- if (m_parsedCalculation) {
- ASSERT(isCalculation(value));
- return CSSPrimitiveValue::create(m_parsedCalculation.release());
- }
</del><ins>+ if (valueWithCalculation.calculation())
+ return CSSPrimitiveValue::create(valueWithCalculation.calculation());
</ins><span class="cx">
</span><ins>+ CSSParserValue& value = valueWithCalculation;
</ins><span class="cx"> #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
</span><span class="cx"> ASSERT((value.unit >= CSSPrimitiveValue::CSS_NUMBER && value.unit <= CSSPrimitiveValue::CSS_KHZ)
</span><span class="cx"> || (value.unit >= CSSPrimitiveValue::CSS_TURN && value.unit <= CSSPrimitiveValue::CSS_CHS)
</span><span class="lines">@@ -1740,43 +1741,44 @@
</span><span class="cx"> return value.unit == CSSParserValue::Operator && value.iValue == '/';
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::validWidth(CSSParserValue& value)
</del><ins>+bool CSSParser::validateWidth(ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><del>- int id = value.id;
</del><ins>+ int id = valueWithCalculation.value().id;
</ins><span class="cx"> if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic || id == CSSValueWebkitMinContent || id == CSSValueWebkitMaxContent || id == CSSValueWebkitFillAvailable || id == CSSValueWebkitFitContent)
</span><span class="cx"> return true;
</span><del>- return !id && validUnit(value, FLength | FPercent | FNonNeg);
</del><ins>+ return !id && validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // FIXME: Combine this with validWidth when we support fit-content, et al, for heights.
</span><del>-bool CSSParser::validHeight(CSSParserValue& value)
</del><ins>+bool CSSParser::validateHeight(ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><del>- int id = value.id;
</del><ins>+ int id = valueWithCalculation.value().id;
</ins><span class="cx"> if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic)
</span><span class="cx"> return true;
</span><del>- return !id && validUnit(value, FLength | FPercent | FNonNeg);
</del><ins>+ return !id && validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline PassRefPtr<CSSPrimitiveValue> CSSParser::parseValidPrimitive(CSSValueID identifier, CSSParserValue& value)
</del><ins>+inline PassRefPtr<CSSPrimitiveValue> CSSParser::parseValidPrimitive(CSSValueID identifier, ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><span class="cx"> if (identifier)
</span><span class="cx"> return cssValuePool().createIdentifierValue(identifier);
</span><del>- if (value.unit == CSSPrimitiveValue::CSS_STRING)
- return createPrimitiveStringValue(value);
- if (value.unit >= CSSPrimitiveValue::CSS_NUMBER && value.unit <= CSSPrimitiveValue::CSS_KHZ)
- return createPrimitiveNumericValue(value);
- if (value.unit >= CSSPrimitiveValue::CSS_TURN && value.unit <= CSSPrimitiveValue::CSS_CHS)
- return createPrimitiveNumericValue(value);
- if (value.unit >= CSSPrimitiveValue::CSS_VW && value.unit <= CSSPrimitiveValue::CSS_VMAX)
- return createPrimitiveNumericValue(value);
</del><ins>+
+ if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_STRING)
+ return createPrimitiveStringValue(valueWithCalculation);
+ if (valueWithCalculation.value().unit >= CSSPrimitiveValue::CSS_NUMBER && valueWithCalculation.value().unit <= CSSPrimitiveValue::CSS_KHZ)
+ return createPrimitiveNumericValue(valueWithCalculation);
+ if (valueWithCalculation.value().unit >= CSSPrimitiveValue::CSS_TURN && valueWithCalculation.value().unit <= CSSPrimitiveValue::CSS_CHS)
+ return createPrimitiveNumericValue(valueWithCalculation);
+ if (valueWithCalculation.value().unit >= CSSPrimitiveValue::CSS_VW && valueWithCalculation.value().unit <= CSSPrimitiveValue::CSS_VMAX)
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
</span><del>- if (value.unit >= CSSPrimitiveValue::CSS_DPPX && value.unit <= CSSPrimitiveValue::CSS_DPCM)
- return createPrimitiveNumericValue(value);
</del><ins>+ if (valueWithCalculation.value().unit >= CSSPrimitiveValue::CSS_DPPX && valueWithCalculation.value().unit <= CSSPrimitiveValue::CSS_DPCM)
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> #endif
</span><del>- if (value.unit >= CSSParserValue::Q_EMS)
- return CSSPrimitiveValue::createAllowingMarginQuirk(value.fValue, CSSPrimitiveValue::CSS_EMS);
- if (isCalculation(value))
- return CSSPrimitiveValue::create(m_parsedCalculation.release());
</del><ins>+ if (valueWithCalculation.value().unit >= CSSParserValue::Q_EMS)
+ return CSSPrimitiveValue::createAllowingMarginQuirk(valueWithCalculation.value().fValue, CSSPrimitiveValue::CSS_EMS);
+ if (valueWithCalculation.calculation())
+ return CSSPrimitiveValue::create(valueWithCalculation.calculation());
</ins><span class="cx">
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="lines">@@ -1799,20 +1801,12 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseValue(CSSPropertyID propId, bool important)
</span><span class="cx"> {
</span><del>- if (!m_valueList)
</del><ins>+ if (!m_valueList || !m_valueList->current())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue* value = m_valueList->current();
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ CSSValueID id = valueWithCalculation.value().id;
</ins><span class="cx">
</span><del>- if (!value)
- return false;
-
- // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.
- // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.
- ASSERT(!m_parsedCalculation);
-
- CSSValueID id = value->id;
-
</del><span class="cx"> unsigned num = inShorthand() ? 1 : m_valueList->size();
</span><span class="cx">
</span><span class="cx"> if (id == CSSValueInherit) {
</span><span class="lines">@@ -1875,7 +1869,7 @@
</span><span class="cx"> case CSSPropertyClip: // <shape> | auto | inherit
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><del>- else if (value->unit == CSSParserValue::Function)
</del><ins>+ else if (valueWithCalculation.value().unit == CSSParserValue::Function)
</ins><span class="cx"> return parseClipShape(propId, important);
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="lines">@@ -1933,7 +1927,7 @@
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyWebkitBorderHorizontalSpacing:
</span><span class="cx"> case CSSPropertyWebkitBorderVerticalSpacing:
</span><del>- validPrimitive = validUnit(*value, FLength | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyOutlineColor: // <color> | invert | inherit
</span><span class="cx"> // Outline color has "invert" as additional keyword.
</span><span class="lines">@@ -1986,6 +1980,7 @@
</span><span class="cx"> // zoom-in | zoom-out | all-scroll | -webkit-grab | -webkit-grabbing | -webkit-zoom-in |
</span><span class="cx"> // -webkit-zoom-out ] ] | inherit
</span><span class="cx"> RefPtr<CSSValueList> list;
</span><ins>+ CSSParserValue* value = &valueWithCalculation.value();
</ins><span class="cx"> while (value) {
</span><span class="cx"> RefPtr<CSSValue> image;
</span><span class="cx"> if (value->unit == CSSPrimitiveValue::CSS_URI) {
</span><span class="lines">@@ -2028,7 +2023,8 @@
</span><span class="cx"> value = m_valueList->next(); // comma
</span><span class="cx"> }
</span><span class="cx"> if (list) {
</span><del>- if (!value) { // no value after url list (MSIE 5 compatibility)
</del><ins>+ if (!value) {
+ // no value after url list (MSIE 5 compatibility)
</ins><span class="cx"> if (list->length() != 1)
</span><span class="cx"> return false;
</span><span class="cx"> } else if (inQuirksMode() && value->id == CSSValueHand) // MSIE 5 compatibility :/
</span><span class="lines">@@ -2040,7 +2036,8 @@
</span><span class="cx"> break;
</span><span class="cx"> } else if (value) {
</span><span class="cx"> id = value->id;
</span><del>- if (inQuirksMode() && value->id == CSSValueHand) { // MSIE 5 compatibility :/
</del><ins>+ if (inQuirksMode() && value->id == CSSValueHand) {
+ // MSIE 5 compatibility :/
</ins><span class="cx"> id = CSSValuePointer;
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> } else if ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitZoomOut) || value->id == CSSValueCopy || value->id == CSSValueNone)
</span><span class="lines">@@ -2114,17 +2111,17 @@
</span><span class="cx"> if (id == CSSValueNone) {
</span><span class="cx"> parsedValue = cssValuePool().createIdentifierValue(CSSValueNone);
</span><span class="cx"> m_valueList->next();
</span><del>- } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
- parsedValue = CSSImageValue::create(completeURL(value->string));
</del><ins>+ } else if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_URI) {
+ parsedValue = CSSImageValue::create(completeURL(valueWithCalculation.value().string));
</ins><span class="cx"> m_valueList->next();
</span><del>- } else if (isGeneratedImageValue(*value)) {
</del><ins>+ } else if (isGeneratedImageValue(valueWithCalculation)) {
</ins><span class="cx"> if (parseGeneratedImage(*m_valueList, parsedValue))
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(CSS_IMAGE_SET)
</span><del>- else if (value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "-webkit-image-set(")) {
</del><ins>+ else if (valueWithCalculation.value().unit == CSSParserValue::Function && equalIgnoringCase(valueWithCalculation.value().function->name, "-webkit-image-set(")) {
</ins><span class="cx"> parsedValue = parseImageSet();
</span><span class="cx"> if (!parsedValue)
</span><span class="cx"> return false;
</span><span class="lines">@@ -2147,21 +2144,21 @@
</span><span class="cx"> if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FLength | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyLetterSpacing: // normal | <length> | inherit
</span><span class="cx"> if (id == CSSValueNormal)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FLength);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWordSpacing: // normal | <length> | <percentage> | inherit
</span><span class="cx"> if (id == CSSValueNormal)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FLength | FPercent);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FPercent);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyTextIndent:
</span><span class="lines">@@ -2176,37 +2173,37 @@
</span><span class="cx"> case CSSPropertyWebkitPaddingEnd:
</span><span class="cx"> case CSSPropertyWebkitPaddingBefore:
</span><span class="cx"> case CSSPropertyWebkitPaddingAfter:
</span><del>- validPrimitive = (!id && validUnit(*value, FLength | FPercent | FNonNeg));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyMaxWidth:
</span><span class="cx"> case CSSPropertyWebkitMaxLogicalWidth:
</span><del>- validPrimitive = (id == CSSValueNone || validWidth(*value));
</del><ins>+ validPrimitive = (id == CSSValueNone || validateWidth(valueWithCalculation));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyMinWidth:
</span><span class="cx"> case CSSPropertyWebkitMinLogicalWidth:
</span><del>- validPrimitive = validWidth(*value);
</del><ins>+ validPrimitive = validateWidth(valueWithCalculation);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWidth:
</span><span class="cx"> case CSSPropertyWebkitLogicalWidth:
</span><del>- validPrimitive = (id == CSSValueAuto || validWidth(*value));
</del><ins>+ validPrimitive = (id == CSSValueAuto || validateWidth(valueWithCalculation));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyMaxHeight:
</span><span class="cx"> case CSSPropertyWebkitMaxLogicalHeight:
</span><del>- validPrimitive = (id == CSSValueNone || validHeight(*value));
</del><ins>+ validPrimitive = (id == CSSValueNone || validateHeight(valueWithCalculation));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyMinHeight:
</span><span class="cx"> case CSSPropertyWebkitMinLogicalHeight:
</span><del>- validPrimitive = validHeight(*value);
</del><ins>+ validPrimitive = validateHeight(valueWithCalculation);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyHeight:
</span><span class="cx"> case CSSPropertyWebkitLogicalHeight:
</span><del>- validPrimitive = (id == CSSValueAuto || validHeight(*value));
</del><ins>+ validPrimitive = (id == CSSValueAuto || validateHeight(valueWithCalculation));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyFontSize:
</span><span class="lines">@@ -2222,7 +2219,7 @@
</span><span class="cx"> if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FLength | FPercent));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FLength | FPercent));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyBottom: // <length> | <percentage> | auto | inherit
</span><span class="lines">@@ -2240,14 +2237,14 @@
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FLength | FPercent));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FLength | FPercent));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyZIndex: // auto | <integer> | inherit
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FInteger, CSSQuirksMode));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FInteger, CSSQuirksMode));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyOrphans: // <integer> | inherit | auto (We've added support for auto for backwards compatibility)
</span><span class="lines">@@ -2255,7 +2252,7 @@
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FPositiveInteger, CSSQuirksMode));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FPositiveInteger, CSSQuirksMode));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyLineHeight:
</span><span class="lines">@@ -2305,7 +2302,7 @@
</span><span class="cx"> if (id == CSSValueNormal || id == CSSValueReset || id == CSSValueDocument)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FNumber | FPercent | FNonNeg, CSSStrictMode));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FNumber | FPercent | FNonNeg, CSSStrictMode));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertySrc: // Only used within @font-face and @-webkit-filter, so cannot use inherit | initial or be !important. This is a list of urls or local references.
</span><span class="lines">@@ -2371,17 +2368,17 @@
</span><span class="cx"> case CSSPropertyBorderBottomRightRadius: {
</span><span class="cx"> if (num != 1 && num != 2)
</span><span class="cx"> return false;
</span><del>- validPrimitive = validUnit(*value, FLength | FPercent | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> return false;
</span><del>- RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(*value);
</del><ins>+ RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> parsedValue2;
</span><span class="cx"> if (num == 2) {
</span><del>- value = m_valueList->next();
- validPrimitive = validUnit(*value, FLength | FPercent | FNonNeg);
</del><ins>+ ValueWithCalculation nextValueWithCalculation(*m_valueList->next());
+ validPrimitive = validateUnit(nextValueWithCalculation, FLength | FPercent | FNonNeg);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> return false;
</span><del>- parsedValue2 = createPrimitiveNumericValue(*value);
</del><ins>+ parsedValue2 = createPrimitiveNumericValue(nextValueWithCalculation);
</ins><span class="cx"> } else
</span><span class="cx"> parsedValue2 = parsedValue1;
</span><span class="cx">
</span><span class="lines">@@ -2389,7 +2386,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyTabSize:
</span><del>- validPrimitive = validUnit(*value, FInteger | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FInteger | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitAspectRatio:
</span><span class="cx"> return parseAspectRatio(important);
</span><span class="lines">@@ -2397,7 +2394,7 @@
</span><span class="cx"> case CSSPropertyWebkitBorderRadius:
</span><span class="cx"> return parseBorderRadius(propId, important);
</span><span class="cx"> case CSSPropertyOutlineOffset:
</span><del>- validPrimitive = validUnit(*value, FLength);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
</span><span class="cx"> case CSSPropertyBoxShadow:
</span><span class="lines">@@ -2420,17 +2417,17 @@
</span><span class="cx"> else {
</span><span class="cx"> if (num != 1 && num != 2)
</span><span class="cx"> return false;
</span><del>- validPrimitive = validUnit(*value, FPositiveInteger);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FPositiveInteger);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> return false;
</span><del>- RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(*value);
</del><ins>+ RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> parsedValue2;
</span><span class="cx"> if (num == 2) {
</span><del>- value = m_valueList->next();
- validPrimitive = validUnit(*value, FPositiveInteger);
</del><ins>+ ValueWithCalculation nextValueWithCalculation(*m_valueList->next());
+ validPrimitive = validateUnit(nextValueWithCalculation, FPositiveInteger);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> return false;
</span><del>- parsedValue2 = createPrimitiveNumericValue(*value);
</del><ins>+ parsedValue2 = createPrimitiveNumericValue(nextValueWithCalculation);
</ins><span class="cx"> } else
</span><span class="cx"> parsedValue2 = parsedValue1;
</span><span class="cx"> addProperty(propId, createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release()), important);
</span><span class="lines">@@ -2445,16 +2442,16 @@
</span><span class="cx"> return parseReflect(propId, important);
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyOpacity:
</span><del>- validPrimitive = validUnit(*value, FNumber);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FNumber);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitBoxFlex:
</span><del>- validPrimitive = validUnit(*value, FNumber);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FNumber);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitBoxFlexGroup:
</span><del>- validPrimitive = validUnit(*value, FInteger | FNonNeg, CSSStrictMode);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FInteger | FNonNeg, CSSStrictMode);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitBoxOrdinalGroup:
</span><del>- validPrimitive = validUnit(*value, FInteger | FNonNeg, CSSStrictMode) && value->fValue;
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FInteger | FNonNeg, CSSStrictMode) && valueWithCalculation.value().fValue;
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitFilter:
</span><span class="cx"> #if ENABLE(FILTERS_LEVEL_2)
</span><span class="lines">@@ -2495,16 +2492,16 @@
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FLength | FPercent | FNonNeg));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg));
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyFlexGrow:
</span><span class="cx"> case CSSPropertyFlexShrink:
</span><del>- validPrimitive = validUnit(*value, FNumber | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FNumber | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyOrder:
</span><del>- if (validUnit(*value, FInteger, CSSStrictMode)) {
</del><ins>+ if (validateUnit(valueWithCalculation, FInteger, CSSStrictMode)) {
</ins><span class="cx"> // We restrict the smallest value to int min + 2 because we use int min and int min + 1 as special values in a hash set.
</span><del>- double result = std::max<double>(std::numeric_limits<int>::min() + 2, parsedDouble(*value, ReleaseParsedCalcValue));
</del><ins>+ double result = std::max<double>(std::numeric_limits<int>::min() + 2, parsedDouble(valueWithCalculation));
</ins><span class="cx"> parsedValue = cssValuePool().createValue(result, CSSPrimitiveValue::CSS_NUMBER);
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="lines">@@ -2515,19 +2512,19 @@
</span><span class="cx"> if (id == CSSValueSmall || id == CSSValueLarge || id == CSSValueMedium)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FLength | FPercent);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FPercent);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitMarqueeRepetition:
</span><span class="cx"> if (id == CSSValueInfinite)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FInteger | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FInteger | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitMarqueeSpeed:
</span><span class="cx"> if (id == CSSValueNormal || id == CSSValueSlow || id == CSSValueFast)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FTime | FInteger | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FTime | FInteger | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> #if ENABLE(CSS_REGIONS)
</span><span class="cx"> case CSSPropertyWebkitFlowInto:
</span><span class="lines">@@ -2574,8 +2571,8 @@
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else {
</span><span class="cx"> // Accepting valueless numbers is a quirk of the -webkit prefixed version of the property.
</span><del>- if (validUnit(*value, FNumber | FLength | FNonNeg)) {
- RefPtr<CSSValue> val = createPrimitiveNumericValue(*value);
</del><ins>+ if (validateUnit(valueWithCalculation, FNumber | FLength | FNonNeg)) {
+ RefPtr<CSSValue> val = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> if (val) {
</span><span class="cx"> addProperty(propId, val.release(), important);
</span><span class="cx"> return true;
</span><span class="lines">@@ -2695,19 +2692,19 @@
</span><span class="cx"> id == CSSValueMedium || id == CSSValueThick)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = !id && validUnit(*value, FNumber | FLength | FPercent);
</del><ins>+ validPrimitive = !id && validateUnit(valueWithCalculation, FNumber | FLength | FPercent);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyColumnCount:
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = !id && validUnit(*value, FPositiveInteger, CSSQuirksMode);
</del><ins>+ validPrimitive = !id && validateUnit(valueWithCalculation, FPositiveInteger, CSSQuirksMode);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyColumnGap: // normal | <length>
</span><span class="cx"> if (id == CSSValueNormal)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(*value, FLength | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitColumnAxis:
</span><span class="cx"> if (id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueAuto)
</span><span class="lines">@@ -2720,7 +2717,7 @@
</span><span class="cx"> case CSSPropertyColumnSpan: // none | all | 1 (will be dropped in the unprefixed property)
</span><span class="cx"> if (id == CSSValueAll || id == CSSValueNone)
</span><span class="cx"> validPrimitive = true;
</span><del>- else if (validUnit(*value, FNumber | FNonNeg) && parsedDouble(*value, ReleaseParsedCalcValue) == 1) {
</del><ins>+ else if (validateUnit(valueWithCalculation, FNumber | FNonNeg) && parsedDouble(valueWithCalculation) == 1) {
</ins><span class="cx"> addProperty(CSSPropertyColumnSpan, cssValuePool().createValue(1, CSSPrimitiveValue::CSS_NUMBER), important);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -2730,9 +2727,7 @@
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else {
</span><span class="cx"> // Always parse this property in strict mode, since it would be ambiguous otherwise when used in the 'columns' shorthand property.
</span><del>- validPrimitive = validUnit(*value, FLength | FNonNeg, CSSStrictMode) && parsedDouble(*value);
- if (!validPrimitive)
- m_parsedCalculation.clear();
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FNonNeg, CSSStrictMode) && parsedDouble(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> // End of CSS3 properties
</span><span class="lines">@@ -2742,7 +2737,7 @@
</span><span class="cx"> case CSSPropertyWebkitLineClamp:
</span><span class="cx"> // When specifying number of lines, don't allow 0 as a valid value
</span><span class="cx"> // When specifying either type of unit, require non-negative integers
</span><del>- validPrimitive = (!id && (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE || value->fValue) && validUnit(*value, FInteger | FPercent | FNonNeg, CSSQuirksMode));
</del><ins>+ validPrimitive = (!id && (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_PERCENTAGE || valueWithCalculation.value().fValue) && validateUnit(valueWithCalculation, FInteger | FPercent | FNonNeg, CSSQuirksMode));
</ins><span class="cx"> break;
</span><span class="cx"> #if ENABLE(IOS_TEXT_AUTOSIZING)
</span><span class="cx"> case CSSPropertyWebkitTextSizeAdjust:
</span><span class="lines">@@ -2750,36 +2745,36 @@
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else {
</span><span class="cx"> // FIXME: Handle multilength case where we allow relative units.
</span><del>- validPrimitive = (!id && validUnit(*value, FPercent | FNonNeg, CSSStrictMode));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FPercent | FNonNeg, CSSStrictMode));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWebkitFontSizeDelta: // <length>
</span><del>- validPrimitive = validUnit(*value, FLength);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWebkitHyphenateCharacter:
</span><del>- if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
</del><ins>+ if (id == CSSValueAuto || valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_STRING)
</ins><span class="cx"> validPrimitive = true;
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWebkitHyphenateLimitBefore:
</span><span class="cx"> case CSSPropertyWebkitHyphenateLimitAfter:
</span><del>- if (id == CSSValueAuto || validUnit(*value, FInteger | FNonNeg, CSSStrictMode))
</del><ins>+ if (id == CSSValueAuto || validateUnit(valueWithCalculation, FInteger | FNonNeg, CSSStrictMode))
</ins><span class="cx"> validPrimitive = true;
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWebkitHyphenateLimitLines:
</span><del>- if (id == CSSValueNoLimit || validUnit(*value, FInteger | FNonNeg, CSSStrictMode))
</del><ins>+ if (id == CSSValueNoLimit || validateUnit(valueWithCalculation, FInteger | FNonNeg, CSSStrictMode))
</ins><span class="cx"> validPrimitive = true;
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWebkitLineGrid:
</span><span class="cx"> if (id == CSSValueNone)
</span><span class="cx"> validPrimitive = true;
</span><del>- else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
- String lineGridValue = String(value->string);
</del><ins>+ else if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_IDENT) {
+ String lineGridValue = String(valueWithCalculation.value().string);
</ins><span class="cx"> if (!lineGridValue.isEmpty()) {
</span><span class="cx"> addProperty(propId, cssValuePool().createValue(lineGridValue, CSSPrimitiveValue::CSS_STRING), important);
</span><span class="cx"> return true;
</span><span class="lines">@@ -2787,13 +2782,13 @@
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitLocale:
</span><del>- if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
</del><ins>+ if (id == CSSValueAuto || valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_STRING)
</ins><span class="cx"> validPrimitive = true;
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> #if ENABLE(DASHBOARD_SUPPORT)
</span><span class="cx"> case CSSPropertyWebkitDashboardRegion: // <dashboard-region> | <dashboard-region>
</span><del>- if (value->unit == CSSParserValue::Function || id == CSSValueNone)
</del><ins>+ if (valueWithCalculation.value().unit == CSSParserValue::Function || id == CSSValueNone)
</ins><span class="cx"> return parseDashboardRegions(propId, important);
</span><span class="cx"> break;
</span><span class="cx"> #endif
</span><span class="lines">@@ -2957,15 +2952,15 @@
</span><span class="cx"> parsedValue = parseShapeProperty(propId);
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitShapeMargin:
</span><del>- validPrimitive = (RuntimeEnabledFeatures::sharedFeatures().cssShapesEnabled() && !id && validUnit(*value, FLength | FPercent | FNonNeg));
</del><ins>+ validPrimitive = (RuntimeEnabledFeatures::sharedFeatures().cssShapesEnabled() && !id && validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg));
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitShapeImageThreshold:
</span><del>- validPrimitive = (RuntimeEnabledFeatures::sharedFeatures().cssShapesEnabled() && !id && validUnit(*value, FNumber));
</del><ins>+ validPrimitive = (RuntimeEnabledFeatures::sharedFeatures().cssShapesEnabled() && !id && validateUnit(valueWithCalculation, FNumber));
</ins><span class="cx"> break;
</span><span class="cx"> #endif
</span><span class="cx"> #if ENABLE(CSS_IMAGE_ORIENTATION)
</span><span class="cx"> case CSSPropertyImageOrientation:
</span><del>- validPrimitive = !id && validUnit(*value, FAngle);
</del><ins>+ validPrimitive = !id && validateUnit(valueWithCalculation, FAngle);
</ins><span class="cx"> break;
</span><span class="cx"> #endif
</span><span class="cx"> #if ENABLE(CSS_IMAGE_RESOLUTION)
</span><span class="lines">@@ -3115,10 +3110,10 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (validPrimitive) {
</span><del>- parsedValue = parseValidPrimitive(id, *value);
</del><ins>+ parsedValue = parseValidPrimitive(id, valueWithCalculation);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><del>- ASSERT(!m_parsedCalculation);
</del><ins>+
</ins><span class="cx"> if (parsedValue) {
</span><span class="cx"> if (!m_valueList->current() || inShorthand()) {
</span><span class="cx"> addProperty(propId, parsedValue.release(), important);
</span><span class="lines">@@ -3221,16 +3216,17 @@
</span><span class="cx"> bool CSSParser::parseNonElementSnapPoints(CSSPropertyID propId, bool important)
</span><span class="cx"> {
</span><span class="cx"> RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
</span><del>- while (CSSParserValue* val = m_valueList->current()) {
- if (validUnit(*val, FPercent | FLength))
- values->append(createPrimitiveNumericValue(*val));
- else if (val->unit == CSSParserValue::Function
- && val->function->args
- && val->function->args->size() == 1
- && equalIgnoringCase(val->function->name, "repeat(")) {
- CSSParserValue& parserVal = *val->function->args.get()->current();
- if (validUnit(parserVal, FLength | FPercent)) {
- values->append(cssValuePool().createValue(LengthRepeat::create(createPrimitiveNumericValue(parserVal))));
</del><ins>+ while (CSSParserValue* value = m_valueList->current()) {
+ ValueWithCalculation valueWithCalculation(*value);
+ if (validateUnit(valueWithCalculation, FPercent | FLength))
+ values->append(createPrimitiveNumericValue(valueWithCalculation));
+ else if (value->unit == CSSParserValue::Function
+ && value->function->args
+ && value->function->args->size() == 1
+ && equalIgnoringCase(value->function->name, "repeat(")) {
+ ValueWithCalculation argumentWithCalculation(*value->function->args.get()->current());
+ if (validateUnit(argumentWithCalculation, FLength | FPercent)) {
+ values->append(cssValuePool().createValue(LengthRepeat::create(createPrimitiveNumericValue(argumentWithCalculation))));
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> if (m_valueList->current())
</span><span class="cx"> return false;
</span><span class="lines">@@ -3253,15 +3249,15 @@
</span><span class="cx"> RefPtr<CSSValueList> position = CSSValueList::createSpaceSeparated();
</span><span class="cx"> if (m_valueList->size() != 2)
</span><span class="cx"> return false;
</span><del>- CSSParserValue* curParserVal = m_valueList->current();
- if (!validUnit(*curParserVal, FPercent | FLength))
</del><ins>+ ValueWithCalculation valueXWithCalculation(*m_valueList->current());
+ if (!validateUnit(valueXWithCalculation, FPercent | FLength))
</ins><span class="cx"> return false;
</span><del>- RefPtr<CSSValue> cssValueX = createPrimitiveNumericValue(*curParserVal);
- m_valueList->next();
- curParserVal = m_valueList->current();
- if (!validUnit(*curParserVal, FPercent | FLength))
</del><ins>+ RefPtr<CSSValue> cssValueX = createPrimitiveNumericValue(valueXWithCalculation);
+
+ ValueWithCalculation valueYWithCalculation(*m_valueList->next());
+ if (!validateUnit(valueYWithCalculation, FPercent | FLength))
</ins><span class="cx"> return false;
</span><del>- RefPtr<CSSValue> cssValueY = createPrimitiveNumericValue(*curParserVal);
</del><ins>+ RefPtr<CSSValue> cssValueY = createPrimitiveNumericValue(valueYWithCalculation);
</ins><span class="cx"> position->append(cssValueX.releaseNonNull());
</span><span class="cx"> position->append(cssValueY.releaseNonNull());
</span><span class="cx"> addProperty(propId, position, important);
</span><span class="lines">@@ -3273,15 +3269,15 @@
</span><span class="cx"> {
</span><span class="cx"> RefPtr<CSSValueList> positions = CSSValueList::createSpaceSeparated();
</span><span class="cx"> while (m_valueList->current()) {
</span><del>- CSSParserValue& parsedValueX = *m_valueList->current();
</del><ins>+ ValueWithCalculation valueXWithCalculation(*m_valueList->current());
</ins><span class="cx"> // Don't accept odd-length lists of coordinates.
</span><span class="cx"> if (!m_valueList->next())
</span><span class="cx"> return false;
</span><del>- CSSParserValue& parsedValueY = *m_valueList->current();
- if (!validUnit(parsedValueX, FPercent | FLength) || !validUnit(parsedValueY, FPercent | FLength))
</del><ins>+ ValueWithCalculation valueYWithCalculation(*m_valueList->current());
+ if (!validateUnit(valueXWithCalculation, FPercent | FLength) || !validateUnit(valueYWithCalculation, FPercent | FLength))
</ins><span class="cx"> return false;
</span><del>- positions->append(createPrimitiveNumericValue(parsedValueX));
- positions->append(createPrimitiveNumericValue(parsedValueY));
</del><ins>+ positions->append(createPrimitiveNumericValue(valueXWithCalculation));
+ positions->append(createPrimitiveNumericValue(valueYWithCalculation));
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> if (positions->length()) {
</span><span class="lines">@@ -3774,12 +3770,14 @@
</span><span class="cx"> return PageSize;
</span><span class="cx"> }
</span><span class="cx"> return None;
</span><del>- case CSSValueInvalid:
- if (validUnit(value, FLength | FNonNeg) && (prevParamType == None || prevParamType == Length)) {
- parsedValues.append(createPrimitiveNumericValue(value));
</del><ins>+ case CSSValueInvalid: {
+ ValueWithCalculation valueWithCalculation(value);
+ if (validateUnit(valueWithCalculation, FLength | FNonNeg) && (prevParamType == None || prevParamType == Length)) {
+ parsedValues.append(createPrimitiveNumericValue(valueWithCalculation));
</ins><span class="cx"> return Length;
</span><span class="cx"> }
</span><span class="cx"> return None;
</span><ins>+ }
</ins><span class="cx"> default:
</span><span class="cx"> return None;
</span><span class="cx"> }
</span><span class="lines">@@ -3975,8 +3973,9 @@
</span><span class="cx"> percent = 50;
</span><span class="cx"> return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
</span><span class="cx"> }
</span><del>- if (validUnit(*valueList.current(), FPercent | FLength))
- return createPrimitiveNumericValue(*valueList.current());
</del><ins>+ ValueWithCalculation valueWithCalculation(*valueList.current());
+ if (validateUnit(valueWithCalculation, FPercent | FLength))
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -3991,8 +3990,9 @@
</span><span class="cx"> percent = 50;
</span><span class="cx"> return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
</span><span class="cx"> }
</span><del>- if (validUnit(*valueList.current(), FPercent | FLength))
- return createPrimitiveNumericValue(*valueList.current());
</del><ins>+ ValueWithCalculation valueWithCalculation(*valueList.current());
+ if (validateUnit(valueWithCalculation, FPercent | FLength))
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4028,19 +4028,17 @@
</span><span class="cx">
</span><span class="cx"> return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
</span><span class="cx"> }
</span><del>- if (validUnit(*valueList.current(), FPercent | FLength)) {
</del><ins>+ ValueWithCalculation valueWithCalculation(*valueList.current());
+ if (validateUnit(valueWithCalculation, FPercent | FLength)) {
</ins><span class="cx"> if (!cumulativeFlags) {
</span><span class="cx"> cumulativeFlags |= XFillPosition;
</span><span class="cx"> individualFlag = XFillPosition;
</span><span class="cx"> } else if (cumulativeFlags & (XFillPosition | AmbiguousFillPosition)) {
</span><span class="cx"> cumulativeFlags |= YFillPosition;
</span><span class="cx"> individualFlag = YFillPosition;
</span><del>- } else {
- if (m_parsedCalculation)
- m_parsedCalculation = nullptr;
</del><ins>+ } else
</ins><span class="cx"> return nullptr;
</span><del>- }
- return createPrimitiveNumericValue(*valueList.current());
</del><ins>+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="lines">@@ -4202,7 +4200,10 @@
</span><span class="cx">
</span><span class="cx"> inline bool CSSParser::isPotentialPositionValue(CSSParserValue& value)
</span><span class="cx"> {
</span><del>- return isFillPositionKeyword(value.id) || validUnit(value, FPercent | FLength, ReleaseParsedCalcValue);
</del><ins>+ if (isFillPositionKeyword(value.id))
+ return true;
+ ValueWithCalculation valueWithCalculation(value);
+ return validateUnit(valueWithCalculation, FPercent | FLength);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void CSSParser::parseFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
</span><span class="lines">@@ -4366,9 +4367,10 @@
</span><span class="cx"> if (value->id == CSSValueAuto)
</span><span class="cx"> parsedValue1 = cssValuePool().createIdentifierValue(CSSValueAuto);
</span><span class="cx"> else {
</span><del>- if (!validUnit(*value, FLength | FPercent))
</del><ins>+ ValueWithCalculation valueWithCalculation(*value);
+ if (!validateUnit(valueWithCalculation, FLength | FPercent))
</ins><span class="cx"> return nullptr;
</span><del>- parsedValue1 = createPrimitiveNumericValue(*value);
</del><ins>+ parsedValue1 = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSPrimitiveValue> parsedValue2;
</span><span class="lines">@@ -4376,13 +4378,14 @@
</span><span class="cx"> if (value->unit == CSSParserValue::Operator && value->iValue == ',')
</span><span class="cx"> allowComma = false;
</span><span class="cx"> else if (value->id != CSSValueAuto) {
</span><del>- if (!validUnit(*value, FLength | FPercent)) {
</del><ins>+ ValueWithCalculation valueWithCalculation(*value);
+ if (!validateUnit(valueWithCalculation, FLength | FPercent)) {
</ins><span class="cx"> if (!inShorthand())
</span><span class="cx"> return nullptr;
</span><span class="cx"> // We need to rewind the value list, so that when it is advanced we'll end up back at this value.
</span><span class="cx"> m_valueList->previous();
</span><span class="cx"> } else
</span><del>- parsedValue2 = createPrimitiveNumericValue(*value);
</del><ins>+ parsedValue2 = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx"> } else if (!parsedValue2 && propId == CSSPropertyWebkitBackgroundSize) {
</span><span class="cx"> // For backwards compatibility we set the second value to the first if it is omitted.
</span><span class="lines">@@ -4586,9 +4589,9 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationDelay()
</span><span class="cx"> {
</span><del>- CSSParserValue& value = *m_valueList->current();
- if (validUnit(value, FTime))
- return createPrimitiveNumericValue(value);
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ if (validateUnit(valueWithCalculation, FTime))
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4602,9 +4605,9 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationDuration()
</span><span class="cx"> {
</span><del>- CSSParserValue& value = *m_valueList->current();
- if (validUnit(value, FTime | FNonNeg))
- return createPrimitiveNumericValue(value);
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ if (validateUnit(valueWithCalculation, FTime | FNonNeg))
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4621,8 +4624,9 @@
</span><span class="cx"> CSSParserValue& value = *m_valueList->current();
</span><span class="cx"> if (value.id == CSSValueInfinite)
</span><span class="cx"> return cssValuePool().createIdentifierValue(value.id);
</span><del>- if (validUnit(value, FNumber | FNonNeg))
- return createPrimitiveNumericValue(value);
</del><ins>+ ValueWithCalculation valueWithCalculation(value);
+ if (validateUnit(valueWithCalculation, FNumber | FNonNeg))
+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4672,8 +4676,9 @@
</span><span class="cx">
</span><span class="cx"> // now get z
</span><span class="cx"> if (m_valueList->current()) {
</span><del>- if (validUnit(*m_valueList->current(), FLength)) {
- value3 = createPrimitiveNumericValue(*m_valueList->current());
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ if (validateUnit(valueWithCalculation, FLength)) {
+ value3 = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -4685,16 +4690,16 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList& args, double& result)
</span><span class="cx"> {
</span><del>- CSSParserValue* value = args.current();
- if (!validUnit(*value, FNumber))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args.current());
+ if (!validateUnit(argumentWithCalculation, FNumber))
</ins><span class="cx"> return false;
</span><del>- result = parsedDouble(*value, ReleaseParsedCalcValue);
- value = args.next();
- if (!value) {
</del><ins>+ result = parsedDouble(argumentWithCalculation);
+ CSSParserValue* nextValue = args.next();
+ if (!nextValue) {
</ins><span class="cx"> // The last number in the function has no comma after it, so we're done.
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (!isComma(value))
</del><ins>+ if (!isComma(nextValue))
</ins><span class="cx"> return false;
</span><span class="cx"> args.next();
</span><span class="cx"> return true;
</span><span class="lines">@@ -4722,22 +4727,24 @@
</span><span class="cx"> int numSteps;
</span><span class="cx"> bool stepAtStart = false;
</span><span class="cx">
</span><del>- CSSParserValue* currentValue = args->current();
- if (!validUnit(*currentValue, FInteger))
</del><ins>+ CSSParserValue* argument = args->current();
+ ValueWithCalculation argumentWithCalculation(*argument);
+ if (!validateUnit(argumentWithCalculation, FInteger))
</ins><span class="cx"> return nullptr;
</span><del>- numSteps = clampToInteger(currentValue->fValue);
</del><ins>+ // FIXME: This doesn't handle calculated values.
+ numSteps = clampToInteger(argument->fValue);
</ins><span class="cx"> if (numSteps < 1)
</span><span class="cx"> return nullptr;
</span><del>- currentValue = args->next();
</del><ins>+ argument = args->next();
</ins><span class="cx">
</span><del>- if (currentValue) {
</del><ins>+ if (argument) {
</ins><span class="cx"> // There is a comma so we need to parse the second value
</span><del>- if (!isComma(currentValue))
</del><ins>+ if (!isComma(argument))
</ins><span class="cx"> return nullptr;
</span><del>- currentValue = args->next();
- if (currentValue->id != CSSValueStart && currentValue->id != CSSValueEnd)
</del><ins>+ argument = args->next();
+ if (argument->id != CSSValueStart && argument->id != CSSValueEnd)
</ins><span class="cx"> return nullptr;
</span><del>- stepAtStart = currentValue->id == CSSValueStart;
</del><ins>+ stepAtStart = argument->id == CSSValueStart;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart);
</span><span class="lines">@@ -4898,23 +4905,25 @@
</span><span class="cx"> // The function parses [ <integer> || <custom-ident> ] in <grid-line> (which can be stand alone or with 'span').
</span><span class="cx"> bool CSSParser::parseIntegerOrCustomIdentFromGridPosition(RefPtr<CSSPrimitiveValue>& numericValue, RefPtr<CSSPrimitiveValue>& gridLineName)
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (validUnit(*value, FInteger) && value->fValue) {
- numericValue = createPrimitiveNumericValue(*value);
- value = m_valueList->next();
- if (value && isValidCustomIdent(*value)) {
- gridLineName = createPrimitiveStringValue(*m_valueList->current());
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ if (validateUnit(valueWithCalculation, FInteger) && valueWithCalculation.value().fValue) {
+ numericValue = createPrimitiveNumericValue(valueWithCalculation);
+ CSSParserValue* nextValue = m_valueList->next();
+ if (nextValue && isValidCustomIdent(*nextValue)) {
+ gridLineName = createPrimitiveStringValue(*nextValue);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (isValidCustomIdent(*value)) {
- gridLineName = createPrimitiveStringValue(*m_valueList->current());
- value = m_valueList->next();
- if (value && validUnit(*value, FInteger) && value->fValue) {
- numericValue = createPrimitiveNumericValue(*value);
- m_valueList->next();
</del><ins>+ if (isValidCustomIdent(valueWithCalculation)) {
+ gridLineName = createPrimitiveStringValue(valueWithCalculation);
+ if (CSSParserValue* nextValue = m_valueList->next()) {
+ ValueWithCalculation nextValueWithCalculation(*nextValue);
+ if (validateUnit(nextValueWithCalculation, FInteger) && nextValueWithCalculation.value().fValue) {
+ numericValue = createPrimitiveNumericValue(nextValueWithCalculation);
+ m_valueList->next();
+ }
</ins><span class="cx"> }
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -5298,13 +5307,18 @@
</span><span class="cx"> bool CSSParser::parseGridTrackRepeatFunction(CSSValueList& list)
</span><span class="cx"> {
</span><span class="cx"> CSSParserValueList* arguments = m_valueList->current()->function->args.get();
</span><del>- if (!arguments || arguments->size() < 3 || !validUnit(*arguments->valueAt(0), FPositiveInteger) || !isComma(arguments->valueAt(1)))
</del><ins>+ if (!arguments || arguments->size() < 3)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- ASSERT(arguments->valueAt(0)->fValue > 0);
</del><ins>+ ValueWithCalculation firstValueWithCalculation(*arguments->valueAt(0));
+ if (!validateUnit(firstValueWithCalculation, FPositiveInteger) || !isComma(arguments->valueAt(1)))
+ return false;
+
+ // FIXME: This doesn't handle calculated values.
+ ASSERT(firstValueWithCalculation.value().fValue > 0);
</ins><span class="cx"> // If arguments->valueAt(0)->fValue > SIZE_MAX then repetitions becomes 0 during the type casting, that's why we
</span><span class="cx"> // clamp it down to kGridMaxTracks before the type casting.
</span><del>- unsigned repetitions = clampTo<unsigned>(arguments->valueAt(0)->fValue, 0, kGridMaxTracks);
</del><ins>+ unsigned repetitions = clampTo<unsigned>(firstValueWithCalculation.value().fValue, 0, kGridMaxTracks);
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSValueList> repeatedValues = CSSValueList::createSpaceSeparated();
</span><span class="cx"> arguments->next(); // Skip the repetition count.
</span><span class="lines">@@ -5378,13 +5392,13 @@
</span><span class="cx"> return parseGridBreadth(currentValue);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSPrimitiveValue> CSSParser::parseGridBreadth(CSSParserValue& currentValue)
</del><ins>+PassRefPtr<CSSPrimitiveValue> CSSParser::parseGridBreadth(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- if (currentValue.id == CSSValueWebkitMinContent || currentValue.id == CSSValueWebkitMaxContent)
- return cssValuePool().createIdentifierValue(currentValue.id);
</del><ins>+ if (value.id == CSSValueWebkitMinContent || value.id == CSSValueWebkitMaxContent)
+ return cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx">
</span><del>- if (currentValue.unit == CSSPrimitiveValue::CSS_FR) {
- double flexValue = currentValue.fValue;
</del><ins>+ if (value.unit == CSSPrimitiveValue::CSS_FR) {
+ double flexValue = value.fValue;
</ins><span class="cx">
</span><span class="cx"> // Fractional unit is a non-negative dimension.
</span><span class="cx"> if (flexValue <= 0)
</span><span class="lines">@@ -5393,10 +5407,11 @@
</span><span class="cx"> return cssValuePool().createValue(flexValue, CSSPrimitiveValue::CSS_FR);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (!validUnit(currentValue, FNonNeg | FLength | FPercent))
</del><ins>+ ValueWithCalculation valueWithCalculation(value);
+ if (!validateUnit(valueWithCalculation, FNonNeg | FLength | FPercent))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- return createPrimitiveNumericValue(currentValue);
</del><ins>+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static inline bool isValidGridAutoFlowId(CSSValueID id)
</span><span class="lines">@@ -5565,11 +5580,12 @@
</span><span class="cx"> arg = args->next();
</span><span class="cx"> arg = skipCommaInDashboardRegion(args);
</span><span class="cx">
</span><del>- valid = arg->id == CSSValueAuto || validUnit(*arg, FLength);
</del><ins>+ ValueWithCalculation argWithCalculation(*arg);
+ valid = arg->id == CSSValueAuto || validateUnit(argWithCalculation, FLength);
</ins><span class="cx"> if (!valid)
</span><span class="cx"> break;
</span><span class="cx">
</span><del>- RefPtr<CSSPrimitiveValue> amount = arg->id == CSSValueAuto ? cssValuePool().createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(*arg);
</del><ins>+ RefPtr<CSSPrimitiveValue> amount = arg->id == CSSValueAuto ? cssValuePool().createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(argWithCalculation);
</ins><span class="cx">
</span><span class="cx"> if (i == 0)
</span><span class="cx"> region->setTop(amount);
</span><span class="lines">@@ -5745,12 +5761,13 @@
</span><span class="cx"> RefPtr<Rect> rect = Rect::create();
</span><span class="cx"> bool valid = true;
</span><span class="cx"> int i = 0;
</span><del>- CSSParserValue* currentValue = args->current();
- while (currentValue) {
- valid = currentValue->id == CSSValueAuto || validUnit(*currentValue, FLength);
</del><ins>+ CSSParserValue* argument = args->current();
+ while (argument) {
+ ValueWithCalculation argumentWithCalculation(*argument);
+ valid = argument->id == CSSValueAuto || validateUnit(argumentWithCalculation, FLength);
</ins><span class="cx"> if (!valid)
</span><span class="cx"> break;
</span><del>- RefPtr<CSSPrimitiveValue> length = currentValue->id == CSSValueAuto ? cssValuePool().createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(*currentValue);
</del><ins>+ RefPtr<CSSPrimitiveValue> length = argument->id == CSSValueAuto ? cssValuePool().createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(argumentWithCalculation);
</ins><span class="cx"> if (i == 0)
</span><span class="cx"> rect->setTop(length);
</span><span class="cx"> else if (i == 1)
</span><span class="lines">@@ -5759,10 +5776,10 @@
</span><span class="cx"> rect->setBottom(length);
</span><span class="cx"> else
</span><span class="cx"> rect->setLeft(length);
</span><del>- currentValue = args->next();
- if (currentValue && args->size() == 7) {
- if (currentValue->unit == CSSParserValue::Operator && currentValue->iValue == ',') {
- currentValue = args->next();
</del><ins>+ argument = args->next();
+ if (argument && args->size() == 7) {
+ if (argument->unit == CSSParserValue::Operator && argument->iValue == ',') {
+ argument = args->next();
</ins><span class="cx"> } else {
</span><span class="cx"> valid = false;
</span><span class="cx"> break;
</span><span class="lines">@@ -5829,10 +5846,11 @@
</span><span class="cx"> if (i - indexAfterSlash >= 4)
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- if (!validUnit(value, FLength | FPercent | FNonNeg))
</del><ins>+ ValueWithCalculation valueWithCalculation(value);
+ if (!validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- RefPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
</del><ins>+ RefPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx">
</span><span class="cx"> if (!indexAfterSlash)
</span><span class="cx"> radii[0][i] = radius;
</span><span class="lines">@@ -5869,10 +5887,11 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Units unitFlags = FLength | FPercent;
</span><del>- if (!validUnit(*argument, unitFlags) || widthArguments.size() > 4)
</del><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
+ if (!validateUnit(argumentWithCalculation, unitFlags) || widthArguments.size() > 4)
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- widthArguments.append(createPrimitiveNumericValue(*argument));
</del><ins>+ widthArguments.append(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx"> argument = args.next();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -5907,10 +5926,11 @@
</span><span class="cx"> if (value.id == CSSValueClosestSide || value.id == CSSValueFarthestSide)
</span><span class="cx"> return cssValuePool().createIdentifierValue(value.id);
</span><span class="cx">
</span><del>- if (!validUnit(value, FLength | FPercent | FNonNeg))
</del><ins>+ ValueWithCalculation valueWithCalculation(value);
+ if (!validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- return createPrimitiveNumericValue(value);
</del><ins>+ return createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeCircle(CSSParserValueList& args)
</span><span class="lines">@@ -6024,14 +6044,18 @@
</span><span class="cx"> CSSParserValue* argumentX = argument;
</span><span class="cx"> while (argumentX) {
</span><span class="cx">
</span><del>- if (!validUnit(*argumentX, FLength | FPercent))
</del><ins>+ ValueWithCalculation argumentXWithCalculation(*argumentX);
+ if (!validateUnit(argumentXWithCalculation, FLength | FPercent))
</ins><span class="cx"> return nullptr;
</span><del>- RefPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(*argumentX);
</del><ins>+ RefPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(argumentXWithCalculation);
</ins><span class="cx">
</span><span class="cx"> CSSParserValue* argumentY = args.next();
</span><del>- if (!argumentY || !validUnit(*argumentY, FLength | FPercent))
</del><ins>+ if (!argumentY)
</ins><span class="cx"> return nullptr;
</span><del>- RefPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(*argumentY);
</del><ins>+ ValueWithCalculation argumentYWithCalculation(*argumentY);
+ if (!validateUnit(argumentYWithCalculation, FLength | FPercent))
+ return nullptr;
+ RefPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(argumentYWithCalculation);
</ins><span class="cx">
</span><span class="cx"> shape->appendPoint(xLength.release(), yLength.release());
</span><span class="cx">
</span><span class="lines">@@ -6086,7 +6110,7 @@
</span><span class="cx"> list->append(shapeValue.releaseNonNull());
</span><span class="cx"> shapeFound = true;
</span><span class="cx"> } else if (isBoxValue(valueId, propId) && !boxFound) {
</span><del>- RefPtr<CSSPrimitiveValue> parsedValue = parseValidPrimitive(valueId, *value);
</del><ins>+ RefPtr<CSSPrimitiveValue> parsedValue = cssValuePool().createIdentifierValue(valueId);
</ins><span class="cx"> list->append(parsedValue.releaseNonNull());
</span><span class="cx"> boxFound = true;
</span><span class="cx"> m_valueList->next();
</span><span class="lines">@@ -6108,13 +6132,10 @@
</span><span class="cx">
</span><span class="cx"> CSSParserValue& value = *m_valueList->current();
</span><span class="cx"> CSSValueID valueId = value.id;
</span><del>- RefPtr<CSSPrimitiveValue> keywordValue;
- RefPtr<CSSPrimitiveValue> shapeValue;
</del><span class="cx">
</span><span class="cx"> if (valueId == CSSValueNone) {
</span><del>- keywordValue = parseValidPrimitive(valueId, value);
</del><span class="cx"> m_valueList->next();
</span><del>- return keywordValue.release();
</del><ins>+ return cssValuePool().createIdentifierValue(valueId);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSValue> imageValue;
</span><span class="lines">@@ -6134,7 +6155,7 @@
</span><span class="cx">
</span><span class="cx"> if (valueId == CSSValueNone) {
</span><span class="cx"> m_valueList->next();
</span><del>- return parseValidPrimitive(valueId, value);
</del><ins>+ return cssValuePool().createIdentifierValue(valueId);
</ins><span class="cx"> }
</span><span class="cx"> if (value.unit == CSSPrimitiveValue::CSS_URI) {
</span><span class="cx"> m_valueList->next();
</span><span class="lines">@@ -6354,31 +6375,31 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseLineHeight(bool important)
</span><span class="cx"> {
</span><del>- CSSParserValue& value = *m_valueList->current();
- CSSValueID id = value.id;
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ CSSValueID id = valueWithCalculation.value().id;
</ins><span class="cx"> bool validPrimitive = false;
</span><span class="cx"> // normal | <number> | <length> | <percentage> | inherit
</span><span class="cx"> if (id == CSSValueNormal)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(value, FNumber | FLength | FPercent | FNonNeg));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FNumber | FLength | FPercent | FNonNeg));
</ins><span class="cx"> if (validPrimitive && (!m_valueList->next() || inShorthand()))
</span><del>- addProperty(CSSPropertyLineHeight, parseValidPrimitive(id, value), important);
</del><ins>+ addProperty(CSSPropertyLineHeight, parseValidPrimitive(id, valueWithCalculation), important);
</ins><span class="cx"> return validPrimitive;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseFontSize(bool important)
</span><span class="cx"> {
</span><del>- CSSParserValue& value = *m_valueList->current();
- CSSValueID id = value.id;
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ CSSValueID id = valueWithCalculation.value().id;
</ins><span class="cx"> bool validPrimitive = false;
</span><span class="cx"> // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
</span><span class="cx"> if (id >= CSSValueXxSmall && id <= CSSValueLarger)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
</del><ins>+ validPrimitive = validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg);
</ins><span class="cx"> if (validPrimitive && (!m_valueList->next() || inShorthand()))
</span><del>- addProperty(CSSPropertyFontSize, parseValidPrimitive(id, value), important);
</del><ins>+ addProperty(CSSPropertyFontSize, parseValidPrimitive(id, valueWithCalculation), important);
</ins><span class="cx"> return validPrimitive;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -6444,8 +6465,9 @@
</span><span class="cx"> addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(value.id), important);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (validUnit(value, FInteger | FNonNeg, CSSQuirksMode)) {
- int weight = static_cast<int>(parsedDouble(value, ReleaseParsedCalcValue));
</del><ins>+ ValueWithCalculation valueWithCalculation(value);
+ if (validateUnit(valueWithCalculation, FInteger | FNonNeg, CSSQuirksMode)) {
+ int weight = static_cast<int>(parsedDouble(valueWithCalculation));
</ins><span class="cx"> if (!(weight % 100) && weight >= 100 && weight <= 900) {
</span><span class="cx"> addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(createFontWeightValueKeyword(weight)), important);
</span><span class="cx"> return true;
</span><span class="lines">@@ -6940,12 +6962,9 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline double CSSParser::parsedDouble(CSSParserValue& value, ReleaseParsedCalcValueCondition releaseCalc)
</del><ins>+inline double CSSParser::parsedDouble(ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><del>- double result = m_parsedCalculation ? m_parsedCalculation->doubleValue() : value.fValue;
- if (releaseCalc == ReleaseParsedCalcValue)
- m_parsedCalculation = nullptr;
- return result;
</del><ins>+ return valueWithCalculation.calculation() ? valueWithCalculation.calculation()->doubleValue() : valueWithCalculation.value().fValue;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSParser::isCalculation(CSSParserValue& value)
</span><span class="lines">@@ -6957,16 +6976,16 @@
</span><span class="cx"> || equalIgnoringCase(value.function->name, "-webkit-max("));
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline int CSSParser::colorIntFromValue(CSSParserValue& value)
</del><ins>+inline int CSSParser::colorIntFromValue(ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><span class="cx"> bool isPercent;
</span><span class="cx">
</span><del>- if (m_parsedCalculation)
- isPercent = m_parsedCalculation->category() == CalcPercent;
</del><ins>+ if (valueWithCalculation.calculation())
+ isPercent = valueWithCalculation.calculation()->category() == CalcPercent;
</ins><span class="cx"> else
</span><del>- isPercent = value.unit == CSSPrimitiveValue::CSS_PERCENTAGE;
</del><ins>+ isPercent = valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_PERCENTAGE;
</ins><span class="cx">
</span><del>- const double doubleValue = parsedDouble(value, ReleaseParsedCalcValue);
</del><ins>+ const double doubleValue = parsedDouble(valueWithCalculation);
</ins><span class="cx">
</span><span class="cx"> if (doubleValue <= 0.0)
</span><span class="cx"> return 0;
</span><span class="lines">@@ -6986,34 +7005,34 @@
</span><span class="cx"> bool CSSParser::parseColorParameters(CSSParserValue& value, int* colorArray, bool parseAlpha)
</span><span class="cx"> {
</span><span class="cx"> CSSParserValueList* args = value.function->args.get();
</span><del>- CSSParserValue* currentValue = args->current();
</del><ins>+ ValueWithCalculation firstArgumentWithCalculation(*args->current());
</ins><span class="cx"> Units unitType = FUnknown;
</span><span class="cx"> // Get the first value and its type
</span><del>- if (validUnit(*currentValue, FInteger, CSSStrictMode))
</del><ins>+ if (validateUnit(firstArgumentWithCalculation, FInteger, CSSStrictMode))
</ins><span class="cx"> unitType = FInteger;
</span><del>- else if (validUnit(*currentValue, FPercent, CSSStrictMode))
</del><ins>+ else if (validateUnit(firstArgumentWithCalculation, FPercent, CSSStrictMode))
</ins><span class="cx"> unitType = FPercent;
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- colorArray[0] = colorIntFromValue(*currentValue);
</del><ins>+ colorArray[0] = colorIntFromValue(firstArgumentWithCalculation);
</ins><span class="cx"> for (int i = 1; i < 3; i++) {
</span><del>- currentValue = args->next();
- if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</del><ins>+ CSSParserValue& operatorArgument = *args->next();
+ if (operatorArgument.unit != CSSParserValue::Operator && operatorArgument.iValue != ',')
</ins><span class="cx"> return false;
</span><del>- currentValue = args->next();
- if (!validUnit(*currentValue, unitType, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args->next());
+ if (!validateUnit(argumentWithCalculation, unitType, CSSStrictMode))
</ins><span class="cx"> return false;
</span><del>- colorArray[i] = colorIntFromValue(*currentValue);
</del><ins>+ colorArray[i] = colorIntFromValue(argumentWithCalculation);
</ins><span class="cx"> }
</span><span class="cx"> if (parseAlpha) {
</span><del>- currentValue = args->next();
- if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</del><ins>+ CSSParserValue& operatorArgument = *args->next();
+ if (operatorArgument.unit != CSSParserValue::Operator && operatorArgument.iValue != ',')
</ins><span class="cx"> return false;
</span><del>- currentValue = args->next();
- if (!validUnit(*currentValue, FNumber, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args->next());
+ if (!validateUnit(argumentWithCalculation, FNumber, CSSStrictMode))
</ins><span class="cx"> return false;
</span><del>- double doubleValue = parsedDouble(*currentValue, ReleaseParsedCalcValue);
</del><ins>+ double doubleValue = parsedDouble(argumentWithCalculation);
</ins><span class="cx"> // Convert the floating pointer number of alpha to an integer in the range [0, 256),
</span><span class="cx"> // with an equal distribution across all 256 values.
</span><span class="cx"> colorArray[3] = static_cast<int>(std::max<double>(0, std::min<double>(1, doubleValue)) * nextafter(256.0, 0.0));
</span><span class="lines">@@ -7029,29 +7048,29 @@
</span><span class="cx"> bool CSSParser::parseHSLParameters(CSSParserValue& value, double* colorArray, bool parseAlpha)
</span><span class="cx"> {
</span><span class="cx"> CSSParserValueList* args = value.function->args.get();
</span><del>- CSSParserValue* currentValue = args->current();
</del><ins>+ ValueWithCalculation firstArgumentWithCalculation(*args->current());
</ins><span class="cx"> // Get the first value
</span><del>- if (!validUnit(*currentValue, FNumber, CSSStrictMode))
</del><ins>+ if (!validateUnit(firstArgumentWithCalculation, FNumber, CSSStrictMode))
</ins><span class="cx"> return false;
</span><span class="cx"> // normalize the Hue value and change it to be between 0 and 1.0
</span><del>- colorArray[0] = (((static_cast<int>(parsedDouble(*currentValue, ReleaseParsedCalcValue)) % 360) + 360) % 360) / 360.0;
</del><ins>+ colorArray[0] = (((static_cast<int>(parsedDouble(firstArgumentWithCalculation)) % 360) + 360) % 360) / 360.0;
</ins><span class="cx"> for (int i = 1; i < 3; ++i) {
</span><del>- currentValue = args->next();
- if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</del><ins>+ CSSParserValue& operatorArgument = *args->next();
+ if (operatorArgument.unit != CSSParserValue::Operator && operatorArgument.iValue != ',')
</ins><span class="cx"> return false;
</span><del>- currentValue = args->next();
- if (!validUnit(*currentValue, FPercent, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args->next());
+ if (!validateUnit(argumentWithCalculation, FPercent, CSSStrictMode))
</ins><span class="cx"> return false;
</span><del>- colorArray[i] = std::max<double>(0, std::min<double>(100, parsedDouble(*currentValue, ReleaseParsedCalcValue))) / 100.0; // needs to be value between 0 and 1.0
</del><ins>+ colorArray[i] = std::max<double>(0, std::min<double>(100, parsedDouble(argumentWithCalculation))) / 100.0; // needs to be value between 0 and 1.0
</ins><span class="cx"> }
</span><span class="cx"> if (parseAlpha) {
</span><del>- currentValue = args->next();
- if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</del><ins>+ CSSParserValue& operatorArgument = *args->next();
+ if (operatorArgument.unit != CSSParserValue::Operator && operatorArgument.iValue != ',')
</ins><span class="cx"> return false;
</span><del>- currentValue = args->next();
- if (!validUnit(*currentValue, FNumber, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args->next());
+ if (!validateUnit(argumentWithCalculation, FNumber, CSSStrictMode))
</ins><span class="cx"> return false;
</span><del>- colorArray[3] = std::max<double>(0, std::min<double>(1, parsedDouble(*currentValue, ReleaseParsedCalcValue)));
</del><ins>+ colorArray[3] = std::max<double>(0, std::min<double>(1, parsedDouble(argumentWithCalculation)));
</ins><span class="cx"> }
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -7163,9 +7182,9 @@
</span><span class="cx"> allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void commitLength(CSSParserValue& value)
</del><ins>+ void commitLength(CSSParser::ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><del>- RefPtr<CSSPrimitiveValue> primitiveValue = m_parser.createPrimitiveNumericValue(value);
</del><ins>+ RefPtr<CSSPrimitiveValue> primitiveValue = m_parser.createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx">
</span><span class="cx"> if (allowX) {
</span><span class="cx"> x = primitiveValue.release();
</span><span class="lines">@@ -7243,6 +7262,7 @@
</span><span class="cx"> ShadowParseContext context(propId, *this);
</span><span class="cx"> CSSParserValue* value;
</span><span class="cx"> while ((value = valueList.current())) {
</span><ins>+ ValueWithCalculation valueWithCalculation(*value);
</ins><span class="cx"> // Check for a comma break first.
</span><span class="cx"> if (value->unit == CSSParserValue::Operator) {
</span><span class="cx"> if (value->iValue != ',' || !context.allowBreak) {
</span><span class="lines">@@ -7255,22 +7275,22 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> // The value is good. Commit it.
</span><span class="cx"> context.commitValue();
</span><del>- } else if (validUnit(*value, FLength, CSSStrictMode)) {
</del><ins>+ } else if (validateUnit(valueWithCalculation, FLength, CSSStrictMode)) {
</ins><span class="cx"> // We required a length and didn't get one. Invalid.
</span><span class="cx"> if (!context.allowLength())
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> // Blur radius must be non-negative.
</span><del>- if (context.allowBlur && !validUnit(*value, FLength | FNonNeg, CSSStrictMode))
</del><ins>+ if (context.allowBlur && !validateUnit(valueWithCalculation, FLength | FNonNeg, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> // A length is allowed here. Construct the value and add it.
</span><del>- context.commitLength(*value);
</del><ins>+ context.commitLength(valueWithCalculation);
</ins><span class="cx"> } else if (value->id == CSSValueInset) {
</span><span class="cx"> if (!context.allowStyle)
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- context.commitStyle(*value);
</del><ins>+ context.commitStyle(valueWithCalculation);
</ins><span class="cx"> } else {
</span><span class="cx"> // The only other type of value that's ok is a color value.
</span><span class="cx"> RefPtr<CSSPrimitiveValue> parsedColor;
</span><span class="lines">@@ -7311,34 +7331,35 @@
</span><span class="cx"> // box-reflect: <direction> <offset> <mask>
</span><span class="cx">
</span><span class="cx"> // Direction comes first.
</span><del>- CSSParserValue* currentValue = m_valueList->current();
</del><ins>+ CSSParserValue* value = m_valueList->current();
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> direction;
</span><del>- switch (currentValue->id) {
</del><ins>+ switch (value->id) {
</ins><span class="cx"> case CSSValueAbove:
</span><span class="cx"> case CSSValueBelow:
</span><span class="cx"> case CSSValueLeft:
</span><span class="cx"> case CSSValueRight:
</span><del>- direction = cssValuePool().createIdentifierValue(currentValue->id);
</del><ins>+ direction = cssValuePool().createIdentifierValue(value->id);
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // The offset comes next.
</span><del>- currentValue = m_valueList->next();
</del><ins>+ value = m_valueList->next();
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> offset;
</span><del>- if (!currentValue)
</del><ins>+ if (!value)
</ins><span class="cx"> offset = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
</span><span class="cx"> else {
</span><del>- if (!validUnit(*currentValue, FLength | FPercent))
</del><ins>+ ValueWithCalculation valueWithCalculation(*value);
+ if (!validateUnit(valueWithCalculation, FLength | FPercent))
</ins><span class="cx"> return false;
</span><del>- offset = createPrimitiveNumericValue(*currentValue);
</del><ins>+ offset = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Now for the mask.
</span><span class="cx"> RefPtr<CSSValue> mask;
</span><del>- currentValue = m_valueList->next();
- if (currentValue) {
</del><ins>+ value = m_valueList->next();
+ if (value) {
</ins><span class="cx"> if (!parseBorderImage(propId, mask))
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="lines">@@ -7358,20 +7379,21 @@
</span><span class="cx"> RefPtr<CSSPrimitiveValue> flexBasis;
</span><span class="cx">
</span><span class="cx"> while (CSSParserValue* argument = args.current()) {
</span><del>- if (validUnit(*argument, FNumber | FNonNeg)) {
</del><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
+ if (validateUnit(argumentWithCalculation, FNumber | FNonNeg)) {
</ins><span class="cx"> if (flexGrow == unsetValue)
</span><del>- flexGrow = parsedDouble(*argument, ReleaseParsedCalcValue);
</del><ins>+ flexGrow = parsedDouble(argumentWithCalculation);
</ins><span class="cx"> else if (flexShrink == unsetValue)
</span><del>- flexShrink = parsedDouble(*argument, ReleaseParsedCalcValue);
- else if (!parsedDouble(*argument, ReleaseParsedCalcValue)) {
</del><ins>+ flexShrink = parsedDouble(argumentWithCalculation);
+ else if (!parsedDouble(argumentWithCalculation)) {
</ins><span class="cx"> // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
</span><span class="cx"> flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
</span><span class="cx"> } else {
</span><span class="cx"> // We only allow 3 numbers without units if the last value is 0. E.g., flex:1 1 1 is invalid.
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- } else if (!flexBasis && (argument->id == CSSValueAuto || validUnit(*argument, FLength | FPercent | FNonNeg)))
- flexBasis = parseValidPrimitive(argument->id, *argument);
</del><ins>+ } else if (!flexBasis && (argumentWithCalculation.value().id == CSSValueAuto || validateUnit(argumentWithCalculation, FLength | FPercent | FNonNeg)))
+ flexBasis = parseValidPrimitive(argumentWithCalculation.value().id, argumentWithCalculation);
</ins><span class="cx"> else {
</span><span class="cx"> // Not a valid arg for flex.
</span><span class="cx"> return false;
</span><span class="lines">@@ -7640,9 +7662,9 @@
</span><span class="cx"> bool allowFinalCommit() const { return m_allowFinalCommit; }
</span><span class="cx"> CSSPrimitiveValue* top() const { return m_top.get(); }
</span><span class="cx">
</span><del>- void commitNumber(CSSParserValue& value)
</del><ins>+ void commitNumber(CSSParser::ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><del>- RefPtr<CSSPrimitiveValue> primitiveValue = m_parser.createPrimitiveNumericValue(value);
</del><ins>+ RefPtr<CSSPrimitiveValue> primitiveValue = m_parser.createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> if (!m_top)
</span><span class="cx"> m_top = primitiveValue.release();
</span><span class="cx"> else if (!m_right)
</span><span class="lines">@@ -7707,9 +7729,10 @@
</span><span class="cx"> BorderImageSliceParseContext context(*this);
</span><span class="cx"> CSSParserValue* value;
</span><span class="cx"> while ((value = m_valueList->current())) {
</span><ins>+ ValueWithCalculation valueWithCalculation(*value);
</ins><span class="cx"> // FIXME calc() http://webkit.org/b/16662 : calc is parsed but values are not created yet.
</span><del>- if (context.allowNumber() && !isCalculation(*value) && validUnit(*value, FInteger | FNonNeg | FPercent, CSSStrictMode)) {
- context.commitNumber(*value);
</del><ins>+ if (context.allowNumber() && !isCalculation(valueWithCalculation) && validateUnit(valueWithCalculation, FInteger | FNonNeg | FPercent, CSSStrictMode)) {
+ context.commitNumber(valueWithCalculation);
</ins><span class="cx"> } else if (context.allowFill() && value->id == CSSValueFill)
</span><span class="cx"> context.commitFill();
</span><span class="cx"> else if (!inShorthand()) {
</span><span class="lines">@@ -7751,13 +7774,13 @@
</span><span class="cx"> bool allowFinalCommit() const { return m_allowFinalCommit; }
</span><span class="cx"> CSSPrimitiveValue* top() const { return m_top.get(); }
</span><span class="cx">
</span><del>- void commitNumber(CSSParserValue& value)
</del><ins>+ void commitNumber(CSSParser::ValueWithCalculation& valueWithCalculation)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSPrimitiveValue> primitiveValue;
</span><del>- if (value.id == CSSValueAuto)
- primitiveValue = cssValuePool().createIdentifierValue(value.id);
</del><ins>+ if (valueWithCalculation.value().id == CSSValueAuto)
+ primitiveValue = cssValuePool().createIdentifierValue(valueWithCalculation.value().id);
</ins><span class="cx"> else
</span><del>- primitiveValue = m_parser.createPrimitiveNumericValue(value);
</del><ins>+ primitiveValue = m_parser.createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx">
</span><span class="cx"> if (!m_top)
</span><span class="cx"> m_top = primitiveValue.release();
</span><span class="lines">@@ -7819,10 +7842,11 @@
</span><span class="cx"> bool CSSParser::parseBorderImageQuad(Units validUnits, RefPtr<CSSPrimitiveValue>& result)
</span><span class="cx"> {
</span><span class="cx"> BorderImageQuadParseContext context(*this);
</span><del>- CSSParserValue* currentValue;
- while ((currentValue = m_valueList->current())) {
- if (context.allowNumber() && (validUnit(*currentValue, validUnits, CSSStrictMode) || currentValue->id == CSSValueAuto)) {
- context.commitNumber(*currentValue);
</del><ins>+ CSSParserValue* value;
+ while ((value = m_valueList->current())) {
+ ValueWithCalculation valueWithCalculation(*value);
+ if (context.allowNumber() && (validateUnit(valueWithCalculation, validUnits, CSSStrictMode) || value->id == CSSValueAuto)) {
+ context.commitNumber(valueWithCalculation);
</ins><span class="cx"> } else if (!inShorthand()) {
</span><span class="cx"> // If we're not parsing a shorthand then we are invalid.
</span><span class="cx"> return false;
</span><span class="lines">@@ -7879,10 +7903,11 @@
</span><span class="cx"> if (i - indexAfterSlash >= 4)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (!validUnit(value, FLength | FPercent | FNonNeg))
</del><ins>+ ValueWithCalculation valueWithCalculation(value);
+ if (!validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- RefPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
</del><ins>+ RefPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx">
</span><span class="cx"> if (!indexAfterSlash) {
</span><span class="cx"> radii[0][i] = radius;
</span><span class="lines">@@ -7925,20 +7950,21 @@
</span><span class="cx"> if (num != 3)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue& lvalue = *m_valueList->valueAt(0);
</del><span class="cx"> CSSParserValue& op = *m_valueList->valueAt(1);
</span><del>- CSSParserValue& rvalue = *m_valueList->valueAt(2);
</del><span class="cx">
</span><span class="cx"> if (!isForwardSlashOperator(op))
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (!validUnit(lvalue, FNumber | FNonNeg) || !validUnit(rvalue, FNumber | FNonNeg))
</del><ins>+ ValueWithCalculation lvalueWithCalculation(*m_valueList->valueAt(0));
+ ValueWithCalculation rvalueWithCalculation(*m_valueList->valueAt(2));
+ if (!validateUnit(lvalueWithCalculation, FNumber | FNonNeg) || !validateUnit(rvalueWithCalculation, FNumber | FNonNeg))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (!lvalue.fValue || !rvalue.fValue)
</del><ins>+ // FIXME: This doesn't handle calculated values.
+ if (!lvalueWithCalculation.value().fValue || !rvalueWithCalculation.value().fValue)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- addProperty(CSSPropertyWebkitAspectRatio, CSSAspectRatioValue::create(narrowPrecisionToFloat(lvalue.fValue), narrowPrecisionToFloat(rvalue.fValue)), important);
</del><ins>+ addProperty(CSSPropertyWebkitAspectRatio, CSSAspectRatioValue::create(narrowPrecisionToFloat(lvalueWithCalculation.value().fValue), narrowPrecisionToFloat(rvalueWithCalculation.value().fValue)), important);
</ins><span class="cx">
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -8132,9 +8158,11 @@
</span><span class="cx"> // For radial gradients only, we now expect a numeric radius.
</span><span class="cx"> if (gradientType == CSSDeprecatedRadialGradient) {
</span><span class="cx"> argument = args->next();
</span><ins>+ // FIXME: This does not handle calculation values.
</ins><span class="cx"> if (!argument || argument->unit != CSSPrimitiveValue::CSS_NUMBER)
</span><span class="cx"> return false;
</span><del>- downcast<CSSRadialGradientValue>(*result).setFirstRadius(createPrimitiveNumericValue(*argument));
</del><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
+ downcast<CSSRadialGradientValue>(*result).setFirstRadius(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx">
</span><span class="cx"> // Comma after the first radius.
</span><span class="cx"> argument = args->next();
</span><span class="lines">@@ -8169,9 +8197,11 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> argument = args->next();
</span><ins>+ // FIXME: This does not handle calculation values.
</ins><span class="cx"> if (!argument || argument->unit != CSSPrimitiveValue::CSS_NUMBER)
</span><span class="cx"> return false;
</span><del>- downcast<CSSRadialGradientValue>(*result).setSecondRadius(createPrimitiveNumericValue(*argument));
</del><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
+ downcast<CSSRadialGradientValue>(*result).setSecondRadius(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // We now will accept any number of stops (0 or more).
</span><span class="lines">@@ -8241,11 +8271,12 @@
</span><span class="cx"> CSSParserValue* argument = args->current();
</span><span class="cx"> if (!argument)
</span><span class="cx"> return false;
</span><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
</ins><span class="cx">
</span><span class="cx"> bool expectComma = false;
</span><span class="cx"> // Look for angle.
</span><del>- if (validUnit(*argument, FAngle, CSSStrictMode)) {
- result->setAngle(createPrimitiveNumericValue(*argument));
</del><ins>+ if (validateUnit(argumentWithCalculation, FAngle, CSSStrictMode)) {
+ result->setAngle(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx">
</span><span class="cx"> args->next();
</span><span class="cx"> expectComma = true;
</span><span class="lines">@@ -8382,8 +8413,9 @@
</span><span class="cx"> RefPtr<CSSPrimitiveValue> verticalSize;
</span><span class="cx">
</span><span class="cx"> if (!shapeValue && !sizeValue) {
</span><del>- if (validUnit(*argument, FLength | FPercent)) {
- horizontalSize = createPrimitiveNumericValue(*argument);
</del><ins>+ ValueWithCalculation hSizeWithCalculation(*argument);
+ if (validateUnit(hSizeWithCalculation, FLength | FPercent)) {
+ horizontalSize = createPrimitiveNumericValue(hSizeWithCalculation);
</ins><span class="cx"> argument = args->next();
</span><span class="cx"> if (!argument)
</span><span class="cx"> return false;
</span><span class="lines">@@ -8391,8 +8423,9 @@
</span><span class="cx"> expectComma = true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (validUnit(*argument, FLength | FPercent)) {
- verticalSize = createPrimitiveNumericValue(*argument);
</del><ins>+ ValueWithCalculation vSizeWithCalculation(*argument);
+ if (validateUnit(vSizeWithCalculation, FLength | FPercent)) {
+ verticalSize = createPrimitiveNumericValue(vSizeWithCalculation);
</ins><span class="cx">
</span><span class="cx"> argument = args->next();
</span><span class="cx"> if (!argument)
</span><span class="lines">@@ -8423,28 +8456,29 @@
</span><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue* argument = args->current();
- if (!argument)
</del><ins>+ if (!args->current())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><ins>+ ValueWithCalculation firstArgumentWithCalculation(*args->current());
+
</ins><span class="cx"> bool expectComma = false;
</span><span class="cx"> // Look for angle.
</span><del>- if (validUnit(*argument, FAngle, CSSStrictMode)) {
- result->setAngle(createPrimitiveNumericValue(*argument));
</del><ins>+ if (validateUnit(firstArgumentWithCalculation, FAngle, CSSStrictMode)) {
+ result->setAngle(createPrimitiveNumericValue(firstArgumentWithCalculation));
</ins><span class="cx">
</span><span class="cx"> args->next();
</span><span class="cx"> expectComma = true;
</span><del>- } else if (argument->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(*argument, "to")) {
</del><ins>+ } else if (firstArgumentWithCalculation.value().unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(firstArgumentWithCalculation, "to")) {
</ins><span class="cx"> // to [ [left | right] || [top | bottom] ]
</span><del>- argument = args->next();
- if (!argument)
</del><ins>+ CSSParserValue* nextArgument = args->next();
+ if (!nextArgument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSPrimitiveValue> endX, endY;
</span><span class="cx"> RefPtr<CSSPrimitiveValue> location;
</span><span class="cx"> bool isHorizontal = false;
</span><span class="cx">
</span><del>- location = valueFromSideKeyword(*argument, isHorizontal);
</del><ins>+ location = valueFromSideKeyword(*nextArgument, isHorizontal);
</ins><span class="cx"> if (!location)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -8453,11 +8487,11 @@
</span><span class="cx"> else
</span><span class="cx"> endY = location;
</span><span class="cx">
</span><del>- argument = args->next();
- if (!argument)
</del><ins>+ nextArgument = args->next();
+ if (!nextArgument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- location = valueFromSideKeyword(*argument, isHorizontal);
</del><ins>+ location = valueFromSideKeyword(*nextArgument, isHorizontal);
</ins><span class="cx"> if (location) {
</span><span class="cx"> if (isHorizontal) {
</span><span class="cx"> if (endX)
</span><span class="lines">@@ -8511,6 +8545,7 @@
</span><span class="cx"> // [ ellipse || [ <length> | <percentage> ]{2} ] |
</span><span class="cx"> // [ [ circle | ellipse] || <size-keyword> ]
</span><span class="cx"> for (int i = 0; i < 3; ++i) {
</span><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
</ins><span class="cx"> if (argument->unit == CSSPrimitiveValue::CSS_IDENT) {
</span><span class="cx"> bool badIdent = false;
</span><span class="cx"> switch (argument->id) {
</span><span class="lines">@@ -8538,18 +8573,19 @@
</span><span class="cx"> argument = args->next();
</span><span class="cx"> if (!argument)
</span><span class="cx"> return false;
</span><del>- } else if (validUnit(*argument, FLength | FPercent)) {
</del><ins>+ } else if (validateUnit(argumentWithCalculation, FLength | FPercent)) {
</ins><span class="cx">
</span><span class="cx"> if (sizeValue || horizontalSize)
</span><span class="cx"> return false;
</span><del>- horizontalSize = createPrimitiveNumericValue(*argument);
</del><ins>+ horizontalSize = createPrimitiveNumericValue(argumentWithCalculation);
</ins><span class="cx">
</span><span class="cx"> argument = args->next();
</span><span class="cx"> if (!argument)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (validUnit(*argument, FLength | FPercent)) {
- verticalSize = createPrimitiveNumericValue(*argument);
</del><ins>+ ValueWithCalculation vSizeWithCalculation(*argument);
+ if (validateUnit(vSizeWithCalculation, FLength | FPercent)) {
+ verticalSize = createPrimitiveNumericValue(vSizeWithCalculation);
</ins><span class="cx"> ++i;
</span><span class="cx"> argument = args->next();
</span><span class="cx"> if (!argument)
</span><span class="lines">@@ -8613,38 +8649,39 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseGradientColorStops(CSSParserValueList& valueList, CSSGradientValue& gradient, bool expectComma)
</span><span class="cx"> {
</span><del>- CSSParserValue* currentValue = valueList.current();
</del><ins>+ CSSParserValue* value = valueList.current();
</ins><span class="cx"> bool previousStopWasMidpoint = true;
</span><span class="cx">
</span><span class="cx"> // Now look for color stops.
</span><del>- while (currentValue) {
</del><ins>+ while (value) {
</ins><span class="cx"> // Look for the comma before the next stop.
</span><span class="cx"> if (expectComma) {
</span><del>- if (!isComma(currentValue))
</del><ins>+ if (!isComma(value))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- currentValue = valueList.next();
- if (!currentValue)
</del><ins>+ value = valueList.next();
+ if (!value)
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // <color-stop> = <color> [ <percentage> | <length> ]?
</span><span class="cx"> CSSGradientColorStop stop;
</span><del>- stop.m_color = parseGradientColorOrKeyword(*this, *currentValue);
</del><ins>+ stop.m_color = parseGradientColorOrKeyword(*this, *value);
</ins><span class="cx"> if (!stop.m_color) {
</span><span class="cx"> if (previousStopWasMidpoint) // 2 midpoints in a row is not allowed. This also catches starting with a midpoint.
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> stop.isMidpoint = true;
</span><span class="cx"> } else
</span><del>- currentValue = valueList.next();
</del><ins>+ value = valueList.next();
</ins><span class="cx">
</span><span class="cx"> previousStopWasMidpoint = stop.isMidpoint;
</span><span class="cx">
</span><del>- if (currentValue) {
- if (validUnit(*currentValue, FLength | FPercent)) {
- stop.m_position = createPrimitiveNumericValue(*currentValue);
- currentValue = valueList.next();
</del><ins>+ if (value) {
+ ValueWithCalculation valueWithCalculation(*value);
+ if (validateUnit(valueWithCalculation, FLength | FPercent)) {
+ stop.m_position = createPrimitiveNumericValue(valueWithCalculation);
+ value = valueList.next();
</ins><span class="cx"> } else if (stop.isMidpoint)
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="lines">@@ -8845,14 +8882,15 @@
</span><span class="cx">
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><span class="cx"> while (value) {
</span><ins>+ ValueWithCalculation valueWithCalculation(*value);
</ins><span class="cx"> if (!haveFromImage && value->id == CSSValueFromImage) {
</span><span class="cx"> list->append(cssValuePool().createIdentifierValue(value->id));
</span><span class="cx"> haveFromImage = true;
</span><span class="cx"> } else if (!haveSnap && value->id == CSSValueSnap) {
</span><span class="cx"> list->append(cssValuePool().createIdentifierValue(value->id));
</span><span class="cx"> haveSnap = true;
</span><del>- } else if (!haveResolution && validUnit(*value, FResolution | FNonNeg) && value->fValue > 0) {
- list->append(createPrimitiveNumericValue(*value));
</del><ins>+ } else if (!haveResolution && validateUnit(valueWithCalculation, FResolution | FNonNeg) && value->fValue > 0) {
+ list->append(createPrimitiveNumericValue(valueWithCalculation));
</ins><span class="cx"> haveResolution = true;
</span><span class="cx"> } else
</span><span class="cx"> return nullptr;
</span><span class="lines">@@ -9224,29 +9262,30 @@
</span><span class="cx"> CSSParserValue* argument = args->current();
</span><span class="cx"> unsigned argNumber = 0;
</span><span class="cx"> while (argument) {
</span><ins>+ ValueWithCalculation argumentWithCalculation(*argument);
</ins><span class="cx"> CSSParser::Units unit = info.unit();
</span><span class="cx">
</span><span class="cx"> if (info.type() == WebKitCSSTransformValue::Rotate3DTransformOperation && argNumber == 3) {
</span><span class="cx"> // 4th param of rotate3d() is an angle rather than a bare number, validate it as such
</span><del>- if (!validUnit(*argument, FAngle, CSSStrictMode))
</del><ins>+ if (!validateUnit(argumentWithCalculation, FAngle, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx"> } else if (info.type() == WebKitCSSTransformValue::Translate3DTransformOperation && argNumber == 2) {
</span><span class="cx"> // 3rd param of translate3d() cannot be a percentage
</span><del>- if (!validUnit(*argument, FLength, CSSStrictMode))
</del><ins>+ if (!validateUnit(argumentWithCalculation, FLength, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx"> } else if (info.type() == WebKitCSSTransformValue::TranslateZTransformOperation && !argNumber) {
</span><span class="cx"> // 1st param of translateZ() cannot be a percentage
</span><del>- if (!validUnit(*argument, FLength, CSSStrictMode))
</del><ins>+ if (!validateUnit(argumentWithCalculation, FLength, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx"> } else if (info.type() == WebKitCSSTransformValue::PerspectiveTransformOperation && !argNumber) {
</span><span class="cx"> // 1st param of perspective() must be a non-negative number (deprecated) or length.
</span><del>- if (!validUnit(*argument, FNumber | FLength | FNonNeg, CSSStrictMode))
</del><ins>+ if (!validateUnit(argumentWithCalculation, FNumber | FLength | FNonNeg, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><del>- } else if (!validUnit(*argument, unit, CSSStrictMode))
</del><ins>+ } else if (!validateUnit(argumentWithCalculation, unit, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> // Add the value to the current transform operation.
</span><del>- transformValue->append(createPrimitiveNumericValue(*argument));
</del><ins>+ transformValue->append(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx">
</span><span class="cx"> argument = args->next();
</span><span class="cx"> if (!argument)
</span><span class="lines">@@ -9316,21 +9355,22 @@
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> if (args.size()) {
</span><del>- CSSParserValue& value = *args.current();
- if (!validUnit(value, FNumber | FPercent | FNonNeg, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args.current());
+ if (!validateUnit(argumentWithCalculation, FNumber | FPercent | FNonNeg, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- double amount = value.fValue;
</del><ins>+ // FIXME: This does not handle calculated values.
+ double amount = argumentWithCalculation.value().fValue;
</ins><span class="cx">
</span><span class="cx"> // Saturate and Contrast allow values over 100%.
</span><span class="cx"> if (filterType != WebKitCSSFilterValue::SaturateFilterOperation
</span><span class="cx"> && filterType != WebKitCSSFilterValue::ContrastFilterOperation) {
</span><del>- double maxAllowed = value.unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0;
</del><ins>+ double maxAllowed = argumentWithCalculation.value().unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0;
</ins><span class="cx"> if (amount > maxAllowed)
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- filterValue->append(cssValuePool().createValue(amount, static_cast<CSSPrimitiveValue::UnitTypes>(value.unit)));
</del><ins>+ filterValue->append(cssValuePool().createValue(amount, static_cast<CSSPrimitiveValue::UnitTypes>(argumentWithCalculation.value().unit)));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -9340,11 +9380,12 @@
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> if (args.size()) {
</span><del>- CSSParserValue& value = *args.current();
- if (!validUnit(value, FNumber | FPercent, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args.current());
+ if (!validateUnit(argumentWithCalculation, FNumber | FPercent, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- filterValue->append(cssValuePool().createValue(value.fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value.unit)));
</del><ins>+ // FIXME: This doesn't handle calculated values.
+ filterValue->append(cssValuePool().createValue(argumentWithCalculation.value().fValue, static_cast<CSSPrimitiveValue::UnitTypes>(argumentWithCalculation.value().unit)));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -9354,11 +9395,11 @@
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> if (args.size()) {
</span><del>- CSSParserValue& argument = *args.current();
- if (!validUnit(argument, FAngle, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args.current());
+ if (!validateUnit(argumentWithCalculation, FAngle, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- filterValue->append(createPrimitiveNumericValue(argument));
</del><ins>+ filterValue->append(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -9368,11 +9409,11 @@
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> if (args.size()) {
</span><del>- CSSParserValue& argument = *args.current();
- if (!validUnit(argument, FLength | FNonNeg, CSSStrictMode))
</del><ins>+ ValueWithCalculation argumentWithCalculation(*args.current());
+ if (!validateUnit(argumentWithCalculation, FLength | FNonNeg, CSSStrictMode))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- filterValue->append(createPrimitiveNumericValue(argument));
</del><ins>+ filterValue->append(createPrimitiveNumericValue(argumentWithCalculation));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -9566,8 +9607,9 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyWebkitTransformOriginZ: {
</span><del>- if (validUnit(*m_valueList->current(), FLength))
- value = createPrimitiveNumericValue(*m_valueList->current());
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+ if (validateUnit(valueWithCalculation, FLength))
+ value = createPrimitiveNumericValue(valueWithCalculation);
</ins><span class="cx"> if (value)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="lines">@@ -9823,8 +9865,9 @@
</span><span class="cx">
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><span class="cx"> while (value) {
</span><del>- if (!hasLengthOrPercentage && validUnit(*value, FLength | FPercent)) {
- list->append(createPrimitiveNumericValue(*value));
</del><ins>+ ValueWithCalculation valueWithCalculation(*value);
+ if (!hasLengthOrPercentage && validateUnit(valueWithCalculation, FLength | FPercent)) {
+ list->append(createPrimitiveNumericValue(valueWithCalculation));
</ins><span class="cx"> hasLengthOrPercentage = true;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(CSS3_TEXT)
</span><span class="lines">@@ -10000,21 +10043,15 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseCalculation(CSSParserValue& value, CalculationPermittedValueRange range)
</del><ins>+RefPtr<CSSCalcValue> CSSParser::parseCalculation(CSSParserValue& value, CalculationPermittedValueRange range)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(isCalculation(value));
</span><span class="cx">
</span><span class="cx"> CSSParserValueList* args = value.function->args.get();
</span><span class="cx"> if (!args || !args->size())
</span><del>- return false;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- ASSERT(!m_parsedCalculation);
- m_parsedCalculation = CSSCalcValue::create(value.function->name, *args, range);
-
- if (!m_parsedCalculation)
- return false;
-
- return true;
</del><ins>+ return CSSCalcValue::create(value.function->name, *args, range);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #define END_TOKEN 0
</span><span class="lines">@@ -12208,11 +12245,12 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseViewportProperty(CSSPropertyID propId, bool important)
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (!value)
</del><ins>+ if (!m_valueList->current())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSValueID id = value->id;
</del><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
+
+ CSSValueID id = valueWithCalculation.value().id;
</ins><span class="cx"> bool validPrimitive = false;
</span><span class="cx">
</span><span class="cx"> switch (propId) {
</span><span class="lines">@@ -12223,7 +12261,7 @@
</span><span class="cx"> if (id == CSSValueAuto || id == CSSValueDeviceWidth || id == CSSValueDeviceHeight)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FLength | FPercent | FNonNeg));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg));
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWidth: // shorthand
</span><span class="cx"> return parseViewportShorthand(propId, CSSPropertyMinWidth, CSSPropertyMaxWidth, important);
</span><span class="lines">@@ -12235,7 +12273,7 @@
</span><span class="cx"> if (id == CSSValueAuto)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else
</span><del>- validPrimitive = (!id && validUnit(*value, FNumber | FPercent | FNonNeg));
</del><ins>+ validPrimitive = (!id && validateUnit(valueWithCalculation, FNumber | FPercent | FNonNeg));
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyUserZoom: // zoom | fixed
</span><span class="cx"> if (id == CSSValueZoom || id == CSSValueFixed)
</span><span class="lines">@@ -12250,7 +12288,7 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSValue> parsedValue;
</span><span class="cx"> if (validPrimitive) {
</span><del>- parsedValue = parseValidPrimitive(id, *value);
</del><ins>+ parsedValue = parseValidPrimitive(id, valueWithCalculation);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParserh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.h (177622 => 177623)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.h 2014-12-20 18:28:37 UTC (rev 177622)
+++ trunk/Source/WebCore/css/CSSParser.h 2014-12-21 02:56:23 UTC (rev 177623)
</span><span class="lines">@@ -80,6 +80,27 @@
</span><span class="cx"> GeneralSyntaxError
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+ class ValueWithCalculation {
+ public:
+ explicit ValueWithCalculation(CSSParserValue& value)
+ : m_value(value)
+ { }
+
+ CSSParserValue& value() const { return m_value; }
+ operator CSSParserValue&() { return m_value; }
+
+ CSSCalcValue* calculation() const { return m_calculation.get(); }
+ void setCalculation(RefPtr<CSSCalcValue>&& calculation)
+ {
+ isCalculation(m_value);
+ m_calculation = calculation;
+ }
+
+ private:
+ CSSParserValue& m_value;
+ RefPtr<CSSCalcValue> m_calculation;
+ };
+
</ins><span class="cx"> CSSParser(const CSSParserContext&);
</span><span class="cx">
</span><span class="cx"> ~CSSParser();
</span><span class="lines">@@ -92,7 +113,7 @@
</span><span class="cx"> static bool parseColor(RGBA32& color, const String&, bool strict = false);
</span><span class="cx"> static bool parseSystemColor(RGBA32& color, const String&, Document*);
</span><span class="cx"> static PassRefPtr<CSSValueList> parseFontFaceValue(const AtomicString&);
</span><del>- PassRefPtr<CSSPrimitiveValue> parseValidPrimitive(CSSValueID ident, CSSParserValue&);
</del><ins>+ PassRefPtr<CSSPrimitiveValue> parseValidPrimitive(CSSValueID ident, ValueWithCalculation&);
</ins><span class="cx"> bool parseDeclaration(MutableStyleProperties*, const String&, PassRefPtr<CSSRuleSourceData>, StyleSheetContents* contextStyleSheet);
</span><span class="cx"> static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, Element*);
</span><span class="cx"> std::unique_ptr<MediaQuery> parseMediaQuery(const String&);
</span><span class="lines">@@ -282,7 +303,7 @@
</span><span class="cx"> PassRefPtr<CSSValue> parseTextIndent();
</span><span class="cx">
</span><span class="cx"> bool parseLineBoxContain(bool important);
</span><del>- bool parseCalculation(CSSParserValue&, CalculationPermittedValueRange);
</del><ins>+ RefPtr<CSSCalcValue> parseCalculation(CSSParserValue&, CalculationPermittedValueRange);
</ins><span class="cx">
</span><span class="cx"> bool parseFontFeatureTag(CSSValueList&);
</span><span class="cx"> bool parseFontFeatureSettings(bool important);
</span><span class="lines">@@ -404,7 +425,7 @@
</span><span class="cx"> PassRefPtr<StyleRuleBase> createViewportRule();
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- Ref<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue&);
</del><ins>+ Ref<CSSPrimitiveValue> createPrimitiveNumericValue(ValueWithCalculation&);
</ins><span class="cx"> Ref<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue&);
</span><span class="cx">
</span><span class="cx"> static URL completeURL(const CSSParserContext&, const String& url);
</span><span class="lines">@@ -498,8 +519,8 @@
</span><span class="cx"> void setupParser(const char* prefix, unsigned prefixLength, const String&, const char* suffix, unsigned suffixLength);
</span><span class="cx"> bool inShorthand() const { return m_inParseShorthand; }
</span><span class="cx">
</span><del>- bool validWidth(CSSParserValue&);
- bool validHeight(CSSParserValue&);
</del><ins>+ bool validateWidth(ValueWithCalculation&);
+ bool validateHeight(ValueWithCalculation&);
</ins><span class="cx">
</span><span class="cx"> void deleteFontFaceOnlyValues();
</span><span class="cx">
</span><span class="lines">@@ -578,8 +599,6 @@
</span><span class="cx">
</span><span class="cx"> std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> m_recycledSelectorVector;
</span><span class="cx">
</span><del>- RefPtr<CSSCalcValue> m_parsedCalculation;
-
</del><span class="cx"> std::unique_ptr<RuleSourceDataList> m_supportsRuleDataStack;
</span><span class="cx">
</span><span class="cx"> // defines units allowed for a certain property, used in parseUnit
</span><span class="lines">@@ -613,16 +632,16 @@
</span><span class="cx"> bool isLoggingErrors();
</span><span class="cx"> void logError(const String& message, int lineNumber);
</span><span class="cx">
</span><del>- bool validCalculationUnit(CSSParserValue&, Units, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
</del><ins>+ bool validateCalculationUnit(ValueWithCalculation&, Units);
</ins><span class="cx">
</span><span class="cx"> bool shouldAcceptUnitLessValues(CSSParserValue&, Units, CSSParserMode);
</span><span class="cx">
</span><del>- inline bool validUnit(CSSParserValue& value, Units unitflags, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue) { return validUnit(value, unitflags, m_context.mode, releaseCalc); }
- bool validUnit(CSSParserValue&, Units, CSSParserMode, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
</del><ins>+ inline bool validateUnit(ValueWithCalculation& value, Units unitFlags) { return validateUnit(value, unitFlags, m_context.mode); }
+ bool validateUnit(ValueWithCalculation&, Units, CSSParserMode);
</ins><span class="cx">
</span><span class="cx"> bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
</span><del>- int colorIntFromValue(CSSParserValue&);
- double parsedDouble(CSSParserValue&, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
</del><ins>+ int colorIntFromValue(ValueWithCalculation&);
+ double parsedDouble(ValueWithCalculation&);
</ins><span class="cx">
</span><span class="cx"> friend class TransformOperationInfo;
</span><span class="cx"> friend class FilterOperationInfo;
</span></span></pre></div>
<a id="trunkSourceWebCorecssSVGCSSParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SVGCSSParser.cpp (177622 => 177623)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SVGCSSParser.cpp 2014-12-20 18:28:37 UTC (rev 177622)
+++ trunk/Source/WebCore/css/SVGCSSParser.cpp 2014-12-21 02:56:23 UTC (rev 177623)
</span><span class="lines">@@ -35,11 +35,11 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseSVGValue(CSSPropertyID propId, bool important)
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (!value)
</del><ins>+ if (!m_valueList->current())
</ins><span class="cx"> return false;
</span><ins>+ ValueWithCalculation valueWithCalculation(*m_valueList->current());
</ins><span class="cx">
</span><del>- CSSValueID id = value->id;
</del><ins>+ CSSValueID id = valueWithCalculation.value().id;
</ins><span class="cx">
</span><span class="cx"> bool valid_primitive = false;
</span><span class="cx"> RefPtr<CSSValue> parsedValue;
</span><span class="lines">@@ -62,7 +62,7 @@
</span><span class="cx"> id >= CSSValueSuper)
</span><span class="cx"> valid_primitive = true;
</span><span class="cx"> else
</span><del>- valid_primitive = validUnit(*value, FLength | FPercent, SVGAttributeMode);
</del><ins>+ valid_primitive = validateUnit(valueWithCalculation, FLength | FPercent, SVGAttributeMode);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyDominantBaseline:
</span><span class="lines">@@ -87,8 +87,8 @@
</span><span class="cx"> case CSSPropertyMask:
</span><span class="cx"> if (id == CSSValueNone)
</span><span class="cx"> valid_primitive = true;
</span><del>- else if (value->unit == CSSPrimitiveValue::CSS_URI) {
- parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
</del><ins>+ else if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_URI) {
+ parsedValue = CSSPrimitiveValue::create(valueWithCalculation.value().string, CSSPrimitiveValue::CSS_URI);
</ins><span class="cx"> if (parsedValue)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="lines">@@ -101,7 +101,7 @@
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyStrokeMiterlimit: // <miterlimit> | inherit
</span><del>- valid_primitive = validUnit(*value, FNumber | FNonNeg, SVGAttributeMode);
</del><ins>+ valid_primitive = validateUnit(valueWithCalculation, FNumber | FNonNeg, SVGAttributeMode);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyStrokeLinejoin: // miter | round | bevel | inherit
</span><span class="lines">@@ -118,7 +118,7 @@
</span><span class="cx"> case CSSPropertyFillOpacity:
</span><span class="cx"> case CSSPropertyStopOpacity:
</span><span class="cx"> case CSSPropertyFloodOpacity:
</span><del>- valid_primitive = (!id && validUnit(*value, FNumber | FPercent, SVGAttributeMode));
</del><ins>+ valid_primitive = (!id && validateUnit(valueWithCalculation, FNumber | FPercent, SVGAttributeMode));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyShapeRendering:
</span><span class="lines">@@ -167,8 +167,8 @@
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyGlyphOrientationHorizontal: // <angle> (restricted to _deg_ per SVG 1.1 spec) | inherit
</span><del>- if (value->unit == CSSPrimitiveValue::CSS_DEG || value->unit == CSSPrimitiveValue::CSS_NUMBER) {
- parsedValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_DEG);
</del><ins>+ if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_DEG || valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_NUMBER) {
+ parsedValue = CSSPrimitiveValue::create(valueWithCalculation.value().fValue, CSSPrimitiveValue::CSS_DEG);
</ins><span class="cx">
</span><span class="cx"> if (parsedValue)
</span><span class="cx"> m_valueList->next();
</span><span class="lines">@@ -189,16 +189,16 @@
</span><span class="cx"> parsedValue = SVGPaint::createCurrentColor();
</span><span class="cx"> else if ((id >= CSSValueActiveborder && id <= CSSValueWindowtext) || id == CSSValueMenu)
</span><span class="cx"> parsedValue = SVGPaint::createColor(RenderTheme::defaultTheme()->systemColor(id));
</span><del>- else if (value->unit == CSSPrimitiveValue::CSS_URI) {
</del><ins>+ else if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_URI) {
</ins><span class="cx"> RGBA32 c = Color::transparent;
</span><span class="cx"> if (m_valueList->next()) {
</span><span class="cx"> if (parseColorFromValue(*m_valueList->current(), c))
</span><del>- parsedValue = SVGPaint::createURIAndColor(value->string, c);
</del><ins>+ parsedValue = SVGPaint::createURIAndColor(valueWithCalculation.value().string, c);
</ins><span class="cx"> else if (m_valueList->current()->id == CSSValueNone)
</span><del>- parsedValue = SVGPaint::createURIAndNone(value->string);
</del><ins>+ parsedValue = SVGPaint::createURIAndNone(valueWithCalculation.value().string);
</ins><span class="cx"> }
</span><span class="cx"> if (!parsedValue)
</span><del>- parsedValue = SVGPaint::createURI(value->string);
</del><ins>+ parsedValue = SVGPaint::createURI(valueWithCalculation.value().string);
</ins><span class="cx"> } else
</span><span class="cx"> parsedValue = parseSVGPaint();
</span><span class="cx">
</span><span class="lines">@@ -212,7 +212,7 @@
</span><span class="cx"> case CSSPropertyLightingColor:
</span><span class="cx"> if ((id >= CSSValueAqua && id <= CSSValueWindowtext) ||
</span><span class="cx"> (id >= CSSValueAliceblue && id <= CSSValueYellowgreen))
</span><del>- parsedValue = SVGColor::createFromString(value->string);
</del><ins>+ parsedValue = SVGColor::createFromString(valueWithCalculation.value().string);
</ins><span class="cx"> else if (id == CSSValueCurrentcolor)
</span><span class="cx"> parsedValue = SVGColor::createCurrentColor();
</span><span class="cx"> else // TODO : svgcolor (iccColor)
</span><span class="lines">@@ -236,7 +236,7 @@
</span><span class="cx">
</span><span class="cx"> case CSSPropertyStrokeWidth: // <length> | inherit
</span><span class="cx"> case CSSPropertyStrokeDashoffset:
</span><del>- valid_primitive = validUnit(*value, FLength | FPercent, SVGAttributeMode);
</del><ins>+ valid_primitive = validateUnit(valueWithCalculation, FLength | FPercent, SVGAttributeMode);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyStrokeDasharray: // none | <dasharray> | inherit
</span><span class="cx"> if (id == CSSValueNone)
</span><span class="lines">@@ -250,15 +250,15 @@
</span><span class="cx"> if (id == CSSValueAuto || id == CSSValueNormal)
</span><span class="cx"> valid_primitive = true;
</span><span class="cx"> else
</span><del>- valid_primitive = validUnit(*value, FLength, SVGAttributeMode);
</del><ins>+ valid_primitive = validateUnit(valueWithCalculation, FLength, SVGAttributeMode);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyClipPath: // <uri> | none | inherit
</span><span class="cx"> case CSSPropertyFilter:
</span><span class="cx"> if (id == CSSValueNone)
</span><span class="cx"> valid_primitive = true;
</span><del>- else if (value->unit == CSSPrimitiveValue::CSS_URI) {
- parsedValue = CSSPrimitiveValue::create(value->string, (CSSPrimitiveValue::UnitTypes) value->unit);
</del><ins>+ else if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_URI) {
+ parsedValue = CSSPrimitiveValue::create(valueWithCalculation.value().string, (CSSPrimitiveValue::UnitTypes) valueWithCalculation.value().unit);
</ins><span class="cx"> if (parsedValue)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="lines">@@ -306,7 +306,7 @@
</span><span class="cx"> case CSSPropertyRy:
</span><span class="cx"> case CSSPropertyX:
</span><span class="cx"> case CSSPropertyY:
</span><del>- valid_primitive = (!id && validUnit(*value, FLength | FPercent));
</del><ins>+ valid_primitive = (!id && validateUnit(valueWithCalculation, FLength | FPercent));
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> // If you crash here, it's because you added a css property and are not handling it
</span><span class="lines">@@ -318,14 +318,14 @@
</span><span class="cx"> if (valid_primitive) {
</span><span class="cx"> if (id != 0)
</span><span class="cx"> parsedValue = CSSPrimitiveValue::createIdentifier(id);
</span><del>- else if (value->unit == CSSPrimitiveValue::CSS_STRING)
- parsedValue = CSSPrimitiveValue::create(value->string, (CSSPrimitiveValue::UnitTypes) value->unit);
- else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
- parsedValue = CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
- else if (value->unit >= CSSParserValue::Q_EMS)
- parsedValue = CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
- if (isCalculation(*value))
- parsedValue = CSSPrimitiveValue::create(m_parsedCalculation.release());
</del><ins>+ else if (valueWithCalculation.value().unit == CSSPrimitiveValue::CSS_STRING)
+ parsedValue = CSSPrimitiveValue::create(valueWithCalculation.value().string, (CSSPrimitiveValue::UnitTypes) valueWithCalculation.value().unit);
+ else if (valueWithCalculation.value().unit >= CSSPrimitiveValue::CSS_NUMBER && valueWithCalculation.value().unit <= CSSPrimitiveValue::CSS_KHZ)
+ parsedValue = CSSPrimitiveValue::create(valueWithCalculation.value().fValue, (CSSPrimitiveValue::UnitTypes) valueWithCalculation.value().unit);
+ else if (valueWithCalculation.value().unit >= CSSParserValue::Q_EMS)
+ parsedValue = CSSPrimitiveValue::createAllowingMarginQuirk(valueWithCalculation.value().fValue, CSSPrimitiveValue::CSS_EMS);
+ if (isCalculation(valueWithCalculation))
+ parsedValue = CSSPrimitiveValue::create(valueWithCalculation.calculation());
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> if (!parsedValue || (m_valueList->current() && !inShorthand()))
</span><span class="lines">@@ -341,9 +341,11 @@
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><span class="cx"> bool valid_primitive = true;
</span><span class="cx"> while (value) {
</span><del>- valid_primitive = validUnit(*value, FLength | FPercent | FNonNeg, SVGAttributeMode);
</del><ins>+ ValueWithCalculation valueWithCalculation(*value);
+ valid_primitive = validateUnit(valueWithCalculation, FLength | FPercent | FNonNeg, SVGAttributeMode);
</ins><span class="cx"> if (!valid_primitive)
</span><span class="cx"> break;
</span><ins>+ // FIXME: This code doesn't handle calculated values.
</ins><span class="cx"> if (value->id != 0)
</span><span class="cx"> ret->append(CSSPrimitiveValue::createIdentifier(value->id));
</span><span class="cx"> else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
</span><span class="lines">@@ -353,7 +355,7 @@
</span><span class="cx"> value = m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> if (!valid_primitive)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> return ret.release();
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>