<!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>[176719] 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/176719">176719</a></dd>
<dt>Author</dt> <dd>cdumez@apple.com</dd>
<dt>Date</dt> <dd>2014-12-03 06:21:24 -0800 (Wed, 03 Dec 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Modernize the CSSParser code
https://bugs.webkit.org/show_bug.cgi?id=139209
Reviewed by Antti Koivisto.
Modernize the CSSParser code by:
- Using more references instead of pointers
- Using nullptr instead of 0
No new tests, no 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>
<li><a href="#trunkSourceWebCorecssSourceSizeListcpp">trunk/Source/WebCore/css/SourceSizeList.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (176718 => 176719)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-12-03 13:32:01 UTC (rev 176718)
+++ trunk/Source/WebCore/ChangeLog 2014-12-03 14:21:24 UTC (rev 176719)
</span><span class="lines">@@ -1,3 +1,16 @@
</span><ins>+2014-12-03 Chris Dumez <cdumez@apple.com>
+
+ Modernize the CSSParser code
+ https://bugs.webkit.org/show_bug.cgi?id=139209
+
+ Reviewed by Antti Koivisto.
+
+ Modernize the CSSParser code by:
+ - Using more references instead of pointers
+ - Using nullptr instead of 0
+
+ No new tests, no behavior change.
+
</ins><span class="cx"> 2014-12-03 David Kilzer <ddkilzer@apple.com>
</span><span class="cx">
</span><span class="cx"> [iOS] REGRESSION (r176622): WebCore fails to link
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.cpp (176718 => 176719)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.cpp 2014-12-03 13:32:01 UTC (rev 176718)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2014-12-03 14:21:24 UTC (rev 176719)
</span><span class="lines">@@ -130,19 +130,19 @@
</span><span class="cx"> class ImplicitScope {
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(ImplicitScope);
</span><span class="cx"> public:
</span><del>- ImplicitScope(WebCore::CSSParser* parser, PropertyType propertyType)
</del><ins>+ ImplicitScope(WebCore::CSSParser& parser, PropertyType propertyType)
</ins><span class="cx"> : m_parser(parser)
</span><span class="cx"> {
</span><del>- m_parser->m_implicitShorthand = propertyType == PropertyImplicit;
</del><ins>+ m_parser.m_implicitShorthand = propertyType == PropertyImplicit;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ~ImplicitScope()
</span><span class="cx"> {
</span><del>- m_parser->m_implicitShorthand = false;
</del><ins>+ m_parser.m_implicitShorthand = false;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- WebCore::CSSParser* m_parser;
</del><ins>+ WebCore::CSSParser& m_parser;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace
</span><span class="lines">@@ -173,10 +173,10 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template <unsigned N>
</span><del>-static bool equalIgnoringCase(CSSParserValue* value, const char (&b)[N])
</del><ins>+static bool equalIgnoringCase(CSSParserValue& value, const char (&b)[N])
</ins><span class="cx"> {
</span><del>- ASSERT(value->unit == CSSPrimitiveValue::CSS_IDENT || value->unit == CSSPrimitiveValue::CSS_STRING);
- return equalIgnoringCase(value->string, b);
</del><ins>+ ASSERT(value.unit == CSSPrimitiveValue::CSS_IDENT || value.unit == CSSPrimitiveValue::CSS_STRING);
+ return equalIgnoringCase(value.string, b);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static bool hasPrefix(const char* string, unsigned length, const char* prefix)
</span><span class="lines">@@ -300,9 +300,9 @@
</span><span class="cx"> : m_context(context)
</span><span class="cx"> , m_important(false)
</span><span class="cx"> , m_id(CSSPropertyInvalid)
</span><del>- , m_styleSheet(0)
</del><ins>+ , m_styleSheet(nullptr)
</ins><span class="cx"> , m_supportsCondition(false)
</span><del>- , m_selectorListForParseSelector(0)
</del><ins>+ , m_selectorListForParseSelector(nullptr)
</ins><span class="cx"> , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES)
</span><span class="cx"> , m_inParseShorthand(0)
</span><span class="cx"> , m_currentShorthand(CSSPropertyInvalid)
</span><span class="lines">@@ -315,11 +315,11 @@
</span><span class="cx"> , m_parsedTextPrefixLength(0)
</span><span class="cx"> , m_nestedSelectorLevel(0)
</span><span class="cx"> , m_propertyRange(UINT_MAX, UINT_MAX)
</span><del>- , m_ruleSourceDataResult(0)
</del><ins>+ , m_ruleSourceDataResult(nullptr)
</ins><span class="cx"> , m_parsingMode(NormalMode)
</span><span class="cx"> , m_is8BitSource(false)
</span><del>- , m_currentCharacter8(0)
- , m_currentCharacter16(0)
</del><ins>+ , m_currentCharacter8(nullptr)
+ , m_currentCharacter16(nullptr)
</ins><span class="cx"> , m_length(0)
</span><span class="cx"> , m_token(0)
</span><span class="cx"> , m_lineNumber(0)
</span><span class="lines">@@ -334,7 +334,7 @@
</span><span class="cx"> #if YYDEBUG > 0
</span><span class="cx"> cssyydebug = 1;
</span><span class="cx"> #endif
</span><del>- m_tokenStart.ptr8 = 0;
</del><ins>+ m_tokenStart.ptr8 = nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> CSSParser::~CSSParser()
</span><span class="lines">@@ -352,10 +352,10 @@
</span><span class="cx">
</span><span class="cx"> if (charactersAreAllASCII(input, length)) {
</span><span class="cx"> // Fast case for all-ASCII.
</span><del>- for (unsigned i = 0; i < length; i++)
</del><ins>+ for (unsigned i = 0; i < length; ++i)
</ins><span class="cx"> output[i] = toASCIILower(input[i]);
</span><span class="cx"> } else {
</span><del>- for (unsigned i = 0; i < length; i++) {
</del><ins>+ for (unsigned i = 0; i < length; ++i) {
</ins><span class="cx"> ASSERT(u_tolower(input[i]) <= 0xFFFF);
</span><span class="cx"> output[i] = u_tolower(input[i]);
</span><span class="cx"> }
</span><span class="lines">@@ -381,7 +381,7 @@
</span><span class="cx">
</span><span class="cx"> if (!stringLength || string.is8Bit()) {
</span><span class="cx"> m_dataStart8 = std::make_unique<LChar[]>(length);
</span><del>- for (unsigned i = 0; i < m_parsedTextPrefixLength; i++)
</del><ins>+ for (unsigned i = 0; i < m_parsedTextPrefixLength; ++i)
</ins><span class="cx"> m_dataStart8[i] = prefix[i];
</span><span class="cx">
</span><span class="cx"> if (stringLength)
</span><span class="lines">@@ -392,18 +392,18 @@
</span><span class="cx"> for (unsigned i = start; i < end; i++)
</span><span class="cx"> m_dataStart8[i] = suffix[i - start];
</span><span class="cx">
</span><del>- m_dataStart8[length - 1] = 0;
</del><ins>+ m_dataStart8[length - 1] = '\0';
</ins><span class="cx">
</span><span class="cx"> m_is8BitSource = true;
</span><span class="cx"> m_currentCharacter8 = m_dataStart8.get();
</span><del>- m_currentCharacter16 = 0;
</del><ins>+ m_currentCharacter16 = nullptr;
</ins><span class="cx"> setTokenStart<LChar>(m_currentCharacter8);
</span><span class="cx"> m_lexFunc = &CSSParser::realLex<LChar>;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_dataStart16 = std::make_unique<UChar[]>(length);
</span><del>- for (unsigned i = 0; i < m_parsedTextPrefixLength; i++)
</del><ins>+ for (unsigned i = 0; i < m_parsedTextPrefixLength; ++i)
</ins><span class="cx"> m_dataStart16[i] = prefix[i];
</span><span class="cx">
</span><span class="cx"> ASSERT(stringLength);
</span><span class="lines">@@ -414,10 +414,10 @@
</span><span class="cx"> for (unsigned i = start; i < end; i++)
</span><span class="cx"> m_dataStart16[i] = suffix[i - start];
</span><span class="cx">
</span><del>- m_dataStart16[length - 1] = 0;
</del><ins>+ m_dataStart16[length - 1] = '\0';
</ins><span class="cx">
</span><span class="cx"> m_is8BitSource = false;
</span><del>- m_currentCharacter8 = 0;
</del><ins>+ m_currentCharacter8 = nullptr;
</ins><span class="cx"> m_currentCharacter16 = m_dataStart16.get();
</span><span class="cx"> setTokenStart<UChar>(m_currentCharacter16);
</span><span class="cx"> m_lexFunc = &CSSParser::realLex<UChar>;
</span><span class="lines">@@ -438,8 +438,8 @@
</span><span class="cx"> cssyyparse(this);
</span><span class="cx"> sheet->shrinkToFit();
</span><span class="cx"> m_currentRuleDataStack.reset();
</span><del>- m_ruleSourceDataResult = 0;
- m_rule = 0;
</del><ins>+ m_ruleSourceDataResult = nullptr;
+ m_rule = nullptr;
</ins><span class="cx"> m_ignoreErrorsInDeclaration = false;
</span><span class="cx"> m_logErrors = false;
</span><span class="cx"> }
</span><span class="lines">@@ -1198,7 +1198,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template <typename CharacterType>
</span><del>-static bool parseTransformTranslateArguments(WebKitCSSTransformValue* transformValue, CharacterType* characters, unsigned length, unsigned start, unsigned expectedCount)
</del><ins>+static bool parseTransformTranslateArguments(WebKitCSSTransformValue& transformValue, CharacterType* characters, unsigned length, unsigned start, unsigned expectedCount)
</ins><span class="cx"> {
</span><span class="cx"> while (expectedCount) {
</span><span class="cx"> size_t end = WTF::find(characters, length, expectedCount == 1 ? ')' : ',', start);
</span><span class="lines">@@ -1211,7 +1211,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> if (unit != CSSPrimitiveValue::CSS_PX && (number || unit != CSSPrimitiveValue::CSS_NUMBER))
</span><span class="cx"> return false;
</span><del>- transformValue->append(cssValuePool().createValue(number, CSSPrimitiveValue::CSS_PX));
</del><ins>+ transformValue.append(cssValuePool().createValue(number, CSSPrimitiveValue::CSS_PX));
</ins><span class="cx"> start = end + 1;
</span><span class="cx"> --expectedCount;
</span><span class="cx"> }
</span><span class="lines">@@ -1254,9 +1254,9 @@
</span><span class="cx"> RefPtr<WebKitCSSTransformValue> transformValue = WebKitCSSTransformValue::create(transformType);
</span><span class="cx"> bool success;
</span><span class="cx"> if (string.is8Bit())
</span><del>- success = parseTransformTranslateArguments(transformValue.get(), string.characters8(), string.length(), argumentStart, expectedArgumentCount);
</del><ins>+ success = parseTransformTranslateArguments(*transformValue, string.characters8(), string.length(), argumentStart, expectedArgumentCount);
</ins><span class="cx"> else
</span><del>- success = parseTransformTranslateArguments(transformValue.get(), string.characters16(), string.length(), argumentStart, expectedArgumentCount);
</del><ins>+ success = parseTransformTranslateArguments(*transformValue, string.characters16(), string.length(), argumentStart, expectedArgumentCount);
</ins><span class="cx"> if (!success)
</span><span class="cx"> return false;
</span><span class="cx"> RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
</span><span class="lines">@@ -1268,14 +1268,14 @@
</span><span class="cx"> PassRefPtr<CSSValueList> CSSParser::parseFontFaceValue(const AtomicString& string)
</span><span class="cx"> {
</span><span class="cx"> if (string.isEmpty())
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> RefPtr<MutableStyleProperties> dummyStyle = MutableStyleProperties::create();
</span><del>- if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, false, CSSQuirksMode, 0))
- return 0;
</del><ins>+ if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, false, CSSQuirksMode, nullptr))
+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSValue> fontFamily = dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily);
</span><span class="cx"> if (!fontFamily->isValueList())
</span><del>- return 0; // FIXME: "initial" and "inherit" should be parsed as font names in the face attribute.
</del><ins>+ return nullptr; // FIXME: "initial" and "inherit" should be parsed as font names in the face attribute.
</ins><span class="cx"> return static_pointer_cast<CSSValueList>(fontFamily.release());
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1313,7 +1313,7 @@
</span><span class="cx">
</span><span class="cx"> cssyyparse(this);
</span><span class="cx">
</span><del>- m_rule = 0;
</del><ins>+ m_rule = nullptr;
</ins><span class="cx">
</span><span class="cx"> bool ok = false;
</span><span class="cx"> if (m_hasFontFaceOnlyValues)
</span><span class="lines">@@ -1341,11 +1341,11 @@
</span><span class="cx"> if (!parser.parseColor(string))
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSValue* value = parser.m_parsedProperties.first().value();
- if (!is<CSSPrimitiveValue>(*value))
</del><ins>+ CSSValue& value = *parser.m_parsedProperties.first().value();
+ if (!is<CSSPrimitiveValue>(value))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(*value);
</del><ins>+ CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(value);
</ins><span class="cx"> if (!primitiveValue.isRGBColor())
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -1357,7 +1357,7 @@
</span><span class="cx"> {
</span><span class="cx"> setupParser("@-webkit-decls{color:", string, "} ");
</span><span class="cx"> cssyyparse(this);
</span><del>- m_rule = 0;
</del><ins>+ m_rule = nullptr;
</ins><span class="cx">
</span><span class="cx"> return !m_parsedProperties.isEmpty() && m_parsedProperties.first().id() == CSSPropertyColor;
</span><span class="cx"> }
</span><span class="lines">@@ -1389,7 +1389,7 @@
</span><span class="cx">
</span><span class="cx"> cssyyparse(this);
</span><span class="cx">
</span><del>- m_selectorListForParseSelector = 0;
</del><ins>+ m_selectorListForParseSelector = nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRef<ImmutableStyleProperties> CSSParser::parseInlineStyleDeclaration(const String& string, Element* element)
</span><span class="lines">@@ -1405,7 +1405,7 @@
</span><span class="cx">
</span><span class="cx"> setupParser("@-webkit-decls{", string, "} ");
</span><span class="cx"> cssyyparse(this);
</span><del>- m_rule = 0;
</del><ins>+ m_rule = nullptr;
</ins><span class="cx">
</span><span class="cx"> if (m_hasFontFaceOnlyValues)
</span><span class="cx"> deleteFontFaceOnlyValues();
</span><span class="lines">@@ -1431,7 +1431,7 @@
</span><span class="cx">
</span><span class="cx"> setupParser("@-webkit-decls{", string, "} ");
</span><span class="cx"> cssyyparse(this);
</span><del>- m_rule = 0;
</del><ins>+ m_rule = nullptr;
</ins><span class="cx">
</span><span class="cx"> bool ok = false;
</span><span class="cx"> if (m_hasFontFaceOnlyValues)
</span><span class="lines">@@ -1581,7 +1581,7 @@
</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::validCalculationUnit(CSSParserValue& value, Units unitflags, ReleaseParsedCalcValueCondition releaseCalc)
</ins><span class="cx"> {
</span><span class="cx"> bool mustBeNonNegative = unitflags & FNonNeg;
</span><span class="cx">
</span><span class="lines">@@ -1628,29 +1628,29 @@
</span><span class="cx"> return b;
</span><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::validUnit(CSSParserValue& value, Units unitflags, CSSParserMode cssParserMode, ReleaseParsedCalcValueCondition releaseCalc)
</ins><span class="cx"> {
</span><span class="cx"> if (isCalculation(value))
</span><span class="cx"> return validCalculationUnit(value, unitflags, releaseCalc);
</span><span class="cx">
</span><span class="cx"> bool b = false;
</span><del>- switch (value->unit) {
</del><ins>+ switch (value.unit) {
</ins><span class="cx"> case CSSPrimitiveValue::CSS_NUMBER:
</span><span class="cx"> b = (unitflags & FNumber);
</span><span class="cx"> if (!b && shouldAcceptUnitLessValues(value, unitflags, cssParserMode)) {
</span><del>- value->unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX :
</del><ins>+ value.unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX :
</ins><span class="cx"> ((unitflags & FAngle) ? CSSPrimitiveValue::CSS_DEG : CSSPrimitiveValue::CSS_MS);
</span><span class="cx"> b = true;
</span><span class="cx"> }
</span><del>- if (!b && (unitflags & FInteger) && value->isInt)
</del><ins>+ if (!b && (unitflags & FInteger) && 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) && value.isInt && value.fValue > 0)
</ins><span class="cx"> b = true;
</span><span class="cx"> break;
</span><span class="cx"> case CSSPrimitiveValue::CSS_PERCENTAGE:
</span><span class="lines">@@ -1696,14 +1696,14 @@
</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 && value.fValue < 0)
</ins><span class="cx"> b = false;
</span><del>- if (b && std::isinf(value->fValue))
</del><ins>+ if (b && std::isinf(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 PassRef<CSSPrimitiveValue> CSSParser::createPrimitiveNumericValue(CSSParserValue* value)
</del><ins>+inline PassRef<CSSPrimitiveValue> CSSParser::createPrimitiveNumericValue(CSSParserValue& value)
</ins><span class="cx"> {
</span><span class="cx"> if (m_parsedCalculation) {
</span><span class="cx"> ASSERT(isCalculation(value));
</span><span class="lines">@@ -1711,22 +1711,22 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY)
</span><del>- ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
- || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_CHS)
- || (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
- || (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM));
</del><ins>+ ASSERT((value.unit >= CSSPrimitiveValue::CSS_NUMBER && value.unit <= CSSPrimitiveValue::CSS_KHZ)
+ || (value.unit >= CSSPrimitiveValue::CSS_TURN && value.unit <= CSSPrimitiveValue::CSS_CHS)
+ || (value.unit >= CSSPrimitiveValue::CSS_VW && value.unit <= CSSPrimitiveValue::CSS_VMAX)
+ || (value.unit >= CSSPrimitiveValue::CSS_DPPX && value.unit <= CSSPrimitiveValue::CSS_DPCM));
</ins><span class="cx"> #else
</span><del>- ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
- || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_CHS)
- || (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX));
</del><ins>+ ASSERT((value.unit >= CSSPrimitiveValue::CSS_NUMBER && value.unit <= CSSPrimitiveValue::CSS_KHZ)
+ || (value.unit >= CSSPrimitiveValue::CSS_TURN && value.unit <= CSSPrimitiveValue::CSS_CHS)
+ || (value.unit >= CSSPrimitiveValue::CSS_VW && value.unit <= CSSPrimitiveValue::CSS_VMAX));
</ins><span class="cx"> #endif
</span><del>- return cssValuePool().createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value->unit));
</del><ins>+ return cssValuePool().createValue(value.fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value.unit));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline PassRef<CSSPrimitiveValue> CSSParser::createPrimitiveStringValue(CSSParserValue* value)
</del><ins>+inline PassRef<CSSPrimitiveValue> CSSParser::createPrimitiveStringValue(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
- return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_STRING);
</del><ins>+ ASSERT(value.unit == CSSPrimitiveValue::CSS_STRING || value.unit == CSSPrimitiveValue::CSS_IDENT);
+ return cssValuePool().createValue(value.string, CSSPrimitiveValue::CSS_STRING);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static inline bool isComma(CSSParserValue* value)
</span><span class="lines">@@ -1734,51 +1734,50 @@
</span><span class="cx"> return value && value->unit == CSSParserValue::Operator && value->iValue == ',';
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static inline bool isForwardSlashOperator(CSSParserValue* value)
</del><ins>+static inline bool isForwardSlashOperator(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- ASSERT(value);
- return value->unit == CSSParserValue::Operator && value->iValue == '/';
</del><ins>+ return value.unit == CSSParserValue::Operator && value.iValue == '/';
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::validWidth(CSSParserValue* value)
</del><ins>+bool CSSParser::validWidth(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- int id = value->id;
</del><ins>+ int id = 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><span class="cx"> return !id && validUnit(value, FLength | FPercent | FNonNeg);
</span><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::validHeight(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- int id = value->id;
</del><ins>+ int id = value.id;
</ins><span class="cx"> if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic)
</span><span class="cx"> return true;
</span><span class="cx"> return !id && validUnit(value, FLength | FPercent | FNonNeg);
</span><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, CSSParserValue& value)
</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)
</del><ins>+ if (value.unit == CSSPrimitiveValue::CSS_STRING)
</ins><span class="cx"> return createPrimitiveStringValue(value);
</span><del>- if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
</del><ins>+ if (value.unit >= CSSPrimitiveValue::CSS_NUMBER && value.unit <= CSSPrimitiveValue::CSS_KHZ)
</ins><span class="cx"> return createPrimitiveNumericValue(value);
</span><del>- if (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_CHS)
</del><ins>+ if (value.unit >= CSSPrimitiveValue::CSS_TURN && value.unit <= CSSPrimitiveValue::CSS_CHS)
</ins><span class="cx"> return createPrimitiveNumericValue(value);
</span><del>- if (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
</del><ins>+ if (value.unit >= CSSPrimitiveValue::CSS_VW && value.unit <= CSSPrimitiveValue::CSS_VMAX)
</ins><span class="cx"> return createPrimitiveNumericValue(value);
</span><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)
</del><ins>+ if (value.unit >= CSSPrimitiveValue::CSS_DPPX && value.unit <= CSSPrimitiveValue::CSS_DPCM)
</ins><span class="cx"> return createPrimitiveNumericValue(value);
</span><span class="cx"> #endif
</span><del>- if (value->unit >= CSSParserValue::Q_EMS)
- return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
</del><ins>+ if (value.unit >= CSSParserValue::Q_EMS)
+ return CSSPrimitiveValue::createAllowingMarginQuirk(value.fValue, CSSPrimitiveValue::CSS_EMS);
</ins><span class="cx"> if (isCalculation(value))
</span><span class="cx"> return CSSPrimitiveValue::create(m_parsedCalculation.release());
</span><span class="cx">
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void CSSParser::addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtr<CSSValue> prpValue, bool important)
</span><span class="lines">@@ -1933,7 +1932,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 = validUnit(*value, 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">@@ -1987,7 +1986,7 @@
</span><span class="cx"> // -webkit-zoom-out ] ] | inherit
</span><span class="cx"> RefPtr<CSSValueList> list;
</span><span class="cx"> while (value) {
</span><del>- RefPtr<CSSValue> image = 0;
</del><ins>+ RefPtr<CSSValue> image;
</ins><span class="cx"> if (value->unit == CSSPrimitiveValue::CSS_URI) {
</span><span class="cx"> String uri = value->string;
</span><span class="cx"> if (!uri.isNull())
</span><span class="lines">@@ -2117,8 +2116,8 @@
</span><span class="cx"> } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
</span><span class="cx"> parsedValue = CSSImageValue::create(completeURL(value->string));
</span><span class="cx"> m_valueList->next();
</span><del>- } else if (isGeneratedImageValue(value)) {
- if (parseGeneratedImage(m_valueList.get(), parsedValue))
</del><ins>+ } else if (isGeneratedImageValue(*value)) {
+ if (parseGeneratedImage(*m_valueList, parsedValue))
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="lines">@@ -2147,21 +2146,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 = validUnit(*value, 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 = validUnit(*value, 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 = validUnit(*value, FLength | FPercent);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyTextIndent:
</span><span class="lines">@@ -2176,37 +2175,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 && validUnit(*value, 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 || validWidth(*value));
</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 = validWidth(*value);
</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 || validWidth(*value));
</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 || validHeight(*value));
</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 = validHeight(*value);
</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 || validHeight(*value));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyFontSize:
</span><span class="lines">@@ -2222,7 +2221,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 && validUnit(*value, 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 +2239,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 && validUnit(*value, 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 && validUnit(*value, 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 +2254,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 && validUnit(*value, FPositiveInteger, CSSQuirksMode));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyLineHeight:
</span><span class="lines">@@ -2305,7 +2304,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 && validUnit(*value, 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 +2370,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 = validUnit(*value, 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(*value);
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> parsedValue2;
</span><span class="cx"> if (num == 2) {
</span><span class="cx"> value = m_valueList->next();
</span><del>- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
</del><ins>+ validPrimitive = validUnit(*value, FLength | FPercent | FNonNeg);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> return false;
</span><del>- parsedValue2 = createPrimitiveNumericValue(value);
</del><ins>+ parsedValue2 = createPrimitiveNumericValue(*value);
</ins><span class="cx"> } else
</span><span class="cx"> parsedValue2 = parsedValue1;
</span><span class="cx">
</span><span class="lines">@@ -2389,7 +2388,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 = validUnit(*value, 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 +2396,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 = validUnit(*value, 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">@@ -2405,7 +2404,7 @@
</span><span class="cx"> if (id == CSSValueNone)
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else {
</span><del>- RefPtr<CSSValueList> shadowValueList = parseShadow(m_valueList.get(), propId);
</del><ins>+ RefPtr<CSSValueList> shadowValueList = parseShadow(*m_valueList, propId);
</ins><span class="cx"> if (shadowValueList) {
</span><span class="cx"> addProperty(propId, shadowValueList.release(), important);
</span><span class="cx"> m_valueList->next();
</span><span class="lines">@@ -2420,17 +2419,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 = validUnit(*value, 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(*value);
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> parsedValue2;
</span><span class="cx"> if (num == 2) {
</span><span class="cx"> value = m_valueList->next();
</span><del>- validPrimitive = validUnit(value, FPositiveInteger);
</del><ins>+ validPrimitive = validUnit(*value, FPositiveInteger);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> return false;
</span><del>- parsedValue2 = createPrimitiveNumericValue(value);
</del><ins>+ parsedValue2 = createPrimitiveNumericValue(*value);
</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 +2444,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 = validUnit(*value, FNumber);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitBoxFlex:
</span><del>- validPrimitive = validUnit(value, FNumber);
</del><ins>+ validPrimitive = validUnit(*value, FNumber);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitBoxFlexGroup:
</span><del>- validPrimitive = validUnit(value, FInteger | FNonNeg, CSSStrictMode);
</del><ins>+ validPrimitive = validUnit(*value, 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 = validUnit(*value, FInteger | FNonNeg, CSSStrictMode) && 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">@@ -2464,7 +2463,7 @@
</span><span class="cx"> validPrimitive = true;
</span><span class="cx"> else {
</span><span class="cx"> RefPtr<CSSValue> currValue;
</span><del>- if (!parseFilter(m_valueList.get(), currValue))
</del><ins>+ if (!parseFilter(*m_valueList, currValue))
</ins><span class="cx"> return false;
</span><span class="cx"> addProperty(propId, currValue, important);
</span><span class="cx"> return true;
</span><span class="lines">@@ -2488,21 +2487,21 @@
</span><span class="cx"> addProperty(CSSPropertyFlexBasis, cssValuePool().createIdentifierValue(CSSValueAuto), important);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- return parseFlex(m_valueList.get(), important);
</del><ins>+ return parseFlex(*m_valueList, important);
</ins><span class="cx"> }
</span><span class="cx"> case CSSPropertyFlexBasis:
</span><span class="cx"> // FIXME: Support intrinsic dimensions too.
</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 && validUnit(*value, 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 = validUnit(*value, FNumber | FNonNeg);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyOrder:
</span><del>- if (validUnit(value, FInteger, CSSStrictMode)) {
</del><ins>+ if (validUnit(*value, 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><span class="cx"> double result = std::max<double>(std::numeric_limits<int>::min() + 2, parsedDouble(*value, ReleaseParsedCalcValue));
</span><span class="cx"> parsedValue = cssValuePool().createValue(result, CSSPrimitiveValue::CSS_NUMBER);
</span><span class="lines">@@ -2515,19 +2514,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 = validUnit(*value, 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 = validUnit(*value, 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 = validUnit(*value, 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 +2573,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 (validUnit(*value, FNumber | FLength | FNonNeg)) {
+ RefPtr<CSSValue> val = createPrimitiveNumericValue(*value);
</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 +2694,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 && validUnit(*value, 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 && validUnit(*value, 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 = validUnit(*value, 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 +2719,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 (validUnit(*value, FNumber | FNonNeg) && parsedDouble(*value, ReleaseParsedCalcValue) == 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,7 +2729,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);
</del><ins>+ validPrimitive = validUnit(*value, FLength | FNonNeg, CSSStrictMode) && parsedDouble(*value);
</ins><span class="cx"> if (!validPrimitive)
</span><span class="cx"> m_parsedCalculation.clear();
</span><span class="cx"> }
</span><span class="lines">@@ -2742,7 +2741,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 && (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE || value->fValue) && validUnit(*value, 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,13 +2749,13 @@
</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 && validUnit(*value, 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 = validUnit(*value, FLength);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyWebkitHyphenateCharacter:
</span><span class="lines">@@ -2766,12 +2765,12 @@
</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 || validUnit(*value, 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 || validUnit(*value, FInteger | FNonNeg, CSSStrictMode))
</ins><span class="cx"> validPrimitive = true;
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="lines">@@ -2957,15 +2956,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 && validUnit(*value, 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 && validUnit(*value, 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 && validUnit(*value, 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,7 +3114,7 @@
</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, *value);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> ASSERT(!m_parsedCalculation);
</span><span class="lines">@@ -3169,8 +3168,8 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- RefPtr<CSSPrimitiveValue> position = 0;
- RefPtr<CSSPrimitiveValue> overflowAlignmentKeyword = 0;
</del><ins>+ RefPtr<CSSPrimitiveValue> position;
+ RefPtr<CSSPrimitiveValue> overflowAlignmentKeyword;
</ins><span class="cx"> if (isItemPositionKeyword(value->id)) {
</span><span class="cx"> position = cssValuePool().createIdentifierValue(value->id);
</span><span class="cx"> value = m_valueList->next();
</span><span class="lines">@@ -3202,11 +3201,11 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtr<CSSValue>& cssValue)
</del><ins>+static bool parseBackgroundClip(CSSParserValue& parserValue, RefPtr<CSSValue>& cssValue)
</ins><span class="cx"> {
</span><del>- if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox
- || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) {
- cssValue = cssValuePool().createIdentifierValue(parserValue->id);
</del><ins>+ if (parserValue.id == CSSValueBorderBox || parserValue.id == CSSValuePaddingBox
+ || parserValue.id == CSSValueContentBox || parserValue.id == CSSValueWebkitText) {
+ cssValue = cssValuePool().createIdentifierValue(parserValue.id);
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> return false;
</span><span class="lines">@@ -3222,13 +3221,13 @@
</span><span class="cx"> {
</span><span class="cx"> RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
</span><span class="cx"> while (CSSParserValue* val = m_valueList->current()) {
</span><del>- if (validUnit(val, FPercent | FLength))
- values->append(createPrimitiveNumericValue(val));
</del><ins>+ if (validUnit(*val, FPercent | FLength))
+ values->append(createPrimitiveNumericValue(*val));
</ins><span class="cx"> else if (val->unit == CSSParserValue::Function
</span><del>- && val->function->args != 0
</del><ins>+ && val->function->args
</ins><span class="cx"> && val->function->args->size() == 1
</span><span class="cx"> && equalIgnoringCase(val->function->name, "repeat(")) {
</span><del>- CSSParserValue* parserVal = val->function->args.get()->current();
</del><ins>+ CSSParserValue& parserVal = *val->function->args.get()->current();
</ins><span class="cx"> if (validUnit(parserVal, FLength | FPercent)) {
</span><span class="cx"> values->append(cssValuePool().createValue(LengthRepeat::create(createPrimitiveNumericValue(parserVal))));
</span><span class="cx"> m_valueList->next();
</span><span class="lines">@@ -3254,14 +3253,14 @@
</span><span class="cx"> if (m_valueList->size() != 2)
</span><span class="cx"> return false;
</span><span class="cx"> CSSParserValue* curParserVal = m_valueList->current();
</span><del>- if (!validUnit(curParserVal, FPercent | FLength))
</del><ins>+ if (!validUnit(*curParserVal, FPercent | FLength))
</ins><span class="cx"> return false;
</span><del>- RefPtr<CSSValue> cssValueX = createPrimitiveNumericValue(curParserVal);
</del><ins>+ RefPtr<CSSValue> cssValueX = createPrimitiveNumericValue(*curParserVal);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> curParserVal = m_valueList->current();
</span><del>- if (!validUnit(curParserVal, FPercent | FLength))
</del><ins>+ if (!validUnit(*curParserVal, FPercent | FLength))
</ins><span class="cx"> return false;
</span><del>- RefPtr<CSSValue> cssValueY = createPrimitiveNumericValue(curParserVal);
</del><ins>+ RefPtr<CSSValue> cssValueY = createPrimitiveNumericValue(*curParserVal);
</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,11 +3272,11 @@
</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>+ CSSParserValue& parsedValueX = *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();
</del><ins>+ CSSParserValue& parsedValueY = *m_valueList->current();
</ins><span class="cx"> if (!validUnit(parsedValueX, FPercent | FLength) || !validUnit(parsedValueY, FPercent | FLength))
</span><span class="cx"> return false;
</span><span class="cx"> positions->append(createPrimitiveNumericValue(parsedValueX));
</span><span class="lines">@@ -3312,8 +3311,8 @@
</span><span class="cx"> bool foundPositionCSSProperty = false;
</span><span class="cx">
</span><span class="cx"> while (m_valueList->current()) {
</span><del>- CSSParserValue* val = m_valueList->current();
- if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
</del><ins>+ CSSParserValue& currentValue = *m_valueList->current();
+ if (currentValue.unit == CSSParserValue::Operator && currentValue.iValue == ',') {
</ins><span class="cx"> // We hit the end. Fill in all remaining values with the initial value.
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> for (i = 0; i < numProperties; ++i) {
</span><span class="lines">@@ -3340,7 +3339,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool sizeCSSPropertyExpected = false;
</span><del>- if (isForwardSlashOperator(val) && foundPositionCSSProperty) {
</del><ins>+ if (isForwardSlashOperator(currentValue) && foundPositionCSSProperty) {
</ins><span class="cx"> sizeCSSPropertyExpected = true;
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="lines">@@ -3358,7 +3357,7 @@
</span><span class="cx"> RefPtr<CSSValue> val1;
</span><span class="cx"> RefPtr<CSSValue> val2;
</span><span class="cx"> CSSPropertyID propId1, propId2;
</span><del>- CSSParserValue* parserValue = m_valueList->current();
</del><ins>+ CSSParserValue& parserValue = *m_valueList->current();
</ins><span class="cx"> if (parseFillProperty(properties[i], propId1, propId2, val1, val2)) {
</span><span class="cx"> parsedProperty[i] = found = true;
</span><span class="cx"> addFillValue(values[i], val1.releaseNonNull());
</span><span class="lines">@@ -3388,7 +3387,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Now add all of the properties we found.
</span><del>- for (i = 0; i < numProperties; i++) {
</del><ins>+ for (i = 0; i < numProperties; ++i) {
</ins><span class="cx"> // Fill in any remaining properties with the initial value.
</span><span class="cx"> if (!parsedProperty[i]) {
</span><span class="cx"> addFillValue(values[i], cssValuePool().createImplicitInitialValue());
</span><span class="lines">@@ -3578,7 +3577,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Now add all of the properties we found.
</span><del>- for (i = 0; i < numProperties; i++)
</del><ins>+ for (i = 0; i < numProperties; ++i)
</ins><span class="cx"> addPropertyWithPrefixingVariant(shorthand.properties()[i], values[i].release(), important);
</span><span class="cx">
</span><span class="cx"> return true;
</span><span class="lines">@@ -3614,7 +3613,7 @@
</span><span class="cx"> return true;
</span><span class="cx">
</span><span class="cx"> // Fill in any remaining properties with the initial value.
</span><del>- ImplicitScope implicitScope(this, PropertyImplicit);
</del><ins>+ ImplicitScope implicitScope(*this, PropertyImplicit);
</ins><span class="cx"> const StylePropertyShorthand* propertiesForInitialization = shorthand.propertiesForInitialization();
</span><span class="cx"> for (unsigned i = 0; i < shorthand.length(); ++i) {
</span><span class="cx"> if (propertyFound[i])
</span><span class="lines">@@ -3651,7 +3650,7 @@
</span><span class="cx"> if (!parseValue(properties[0], important))
</span><span class="cx"> return false;
</span><span class="cx"> CSSValue* value = m_parsedProperties.last().value();
</span><del>- ImplicitScope implicitScope(this, PropertyImplicit);
</del><ins>+ ImplicitScope implicitScope(*this, PropertyImplicit);
</ins><span class="cx"> addProperty(properties[1], value, important);
</span><span class="cx"> addProperty(properties[2], value, important);
</span><span class="cx"> addProperty(properties[3], value, important);
</span><span class="lines">@@ -3661,7 +3660,7 @@
</span><span class="cx"> if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
</span><span class="cx"> return false;
</span><span class="cx"> CSSValue* value = m_parsedProperties[m_parsedProperties.size() - 2].value();
</span><del>- ImplicitScope implicitScope(this, PropertyImplicit);
</del><ins>+ ImplicitScope implicitScope(*this, PropertyImplicit);
</ins><span class="cx"> addProperty(properties[2], value, important);
</span><span class="cx"> value = m_parsedProperties[m_parsedProperties.size() - 2].value();
</span><span class="cx"> addProperty(properties[3], value, important);
</span><span class="lines">@@ -3671,7 +3670,7 @@
</span><span class="cx"> if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
</span><span class="cx"> return false;
</span><span class="cx"> CSSValue* value = m_parsedProperties[m_parsedProperties.size() - 2].value();
</span><del>- ImplicitScope implicitScope(this, PropertyImplicit);
</del><ins>+ ImplicitScope implicitScope(*this, PropertyImplicit);
</ins><span class="cx"> addProperty(properties[3], value, important);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -3705,7 +3704,7 @@
</span><span class="cx"> addProperty(propId, cssValuePool().createIdentifierValue(value->id), important);
</span><span class="cx"> return true;
</span><span class="cx"> } else if (value->id == 0 && value->unit == CSSPrimitiveValue::CSS_IDENT) {
</span><del>- addProperty(propId, createPrimitiveStringValue(value), important);
</del><ins>+ addProperty(propId, createPrimitiveStringValue(*value), important);
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> return false;
</span><span class="lines">@@ -3726,14 +3725,14 @@
</span><span class="cx"> RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
</span><span class="cx">
</span><span class="cx"> // First parameter.
</span><del>- SizeParameterType paramType = parseSizeParameter(parsedValues.get(), value, None);
</del><ins>+ SizeParameterType paramType = parseSizeParameter(*parsedValues, *value, None);
</ins><span class="cx"> if (paramType == None)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // Second parameter, if any.
</span><span class="cx"> value = m_valueList->next();
</span><span class="cx"> if (value) {
</span><del>- paramType = parseSizeParameter(parsedValues.get(), value, paramType);
</del><ins>+ paramType = parseSizeParameter(*parsedValues, *value, paramType);
</ins><span class="cx"> if (paramType == None)
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="lines">@@ -3742,19 +3741,19 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-CSSParser::SizeParameterType CSSParser::parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType)
</del><ins>+CSSParser::SizeParameterType CSSParser::parseSizeParameter(CSSValueList& parsedValues, CSSParserValue& value, SizeParameterType prevParamType)
</ins><span class="cx"> {
</span><del>- switch (value->id) {
</del><ins>+ switch (value.id) {
</ins><span class="cx"> case CSSValueAuto:
</span><span class="cx"> if (prevParamType == None) {
</span><del>- parsedValues->append(cssValuePool().createIdentifierValue(value->id));
</del><ins>+ parsedValues.append(cssValuePool().createIdentifierValue(value.id));
</ins><span class="cx"> return Auto;
</span><span class="cx"> }
</span><span class="cx"> return None;
</span><span class="cx"> case CSSValueLandscape:
</span><span class="cx"> case CSSValuePortrait:
</span><span class="cx"> if (prevParamType == None || prevParamType == PageSize) {
</span><del>- parsedValues->append(cssValuePool().createIdentifierValue(value->id));
</del><ins>+ parsedValues.append(cssValuePool().createIdentifierValue(value.id));
</ins><span class="cx"> return Orientation;
</span><span class="cx"> }
</span><span class="cx"> return None;
</span><span class="lines">@@ -3769,13 +3768,13 @@
</span><span class="cx"> if (prevParamType == None || prevParamType == Orientation) {
</span><span class="cx"> // Normalize to Page Size then Orientation order by prepending.
</span><span class="cx"> // This is not specified by the CSS3 Paged Media specification, but for simpler processing later (StyleResolver::applyPageSizeProperty).
</span><del>- parsedValues->prepend(cssValuePool().createIdentifierValue(value->id));
</del><ins>+ parsedValues.prepend(cssValuePool().createIdentifierValue(value.id));
</ins><span class="cx"> return PageSize;
</span><span class="cx"> }
</span><span class="cx"> return None;
</span><del>- case 0:
</del><ins>+ case CSSValueInvalid:
</ins><span class="cx"> if (validUnit(value, FLength | FNonNeg) && (prevParamType == None || prevParamType == Length)) {
</span><del>- parsedValues->append(createPrimitiveNumericValue(value));
</del><ins>+ parsedValues.append(createPrimitiveNumericValue(value));
</ins><span class="cx"> return Length;
</span><span class="cx"> }
</span><span class="cx"> return None;
</span><span class="lines">@@ -3789,10 +3788,10 @@
</span><span class="cx"> bool CSSParser::parseQuotes(CSSPropertyID propId, bool important)
</span><span class="cx"> {
</span><span class="cx"> RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
</span><del>- while (CSSParserValue* val = m_valueList->current()) {
- if (val->unit != CSSPrimitiveValue::CSS_STRING)
</del><ins>+ while (CSSParserValue* value = m_valueList->current()) {
+ if (value->unit != CSSPrimitiveValue::CSS_STRING)
</ins><span class="cx"> break;
</span><del>- values->append(CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_STRING));
</del><ins>+ values->append(CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_STRING));
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> if (values->length()) {
</span><span class="lines">@@ -3805,17 +3804,17 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseAlt(CSSPropertyID propID, bool important)
</span><span class="cx"> {
</span><del>- CSSParserValue* val = m_valueList->current();
</del><ins>+ CSSParserValue& currentValue = *m_valueList->current();
</ins><span class="cx"> RefPtr<CSSValue> parsedValue;
</span><span class="cx">
</span><del>- if (val->unit == CSSPrimitiveValue::CSS_STRING)
- parsedValue = createPrimitiveStringValue(val);
- else if (val->unit == CSSParserValue::Function) {
- CSSParserValueList* args = val->function->args.get();
</del><ins>+ if (currentValue.unit == CSSPrimitiveValue::CSS_STRING)
+ parsedValue = createPrimitiveStringValue(currentValue);
+ else if (currentValue.unit == CSSParserValue::Function) {
+ CSSParserValueList* args = currentValue.function->args.get();
</ins><span class="cx"> if (!args)
</span><span class="cx"> return false;
</span><del>- if (equalIgnoringCase(val->function->name, "attr("))
- parsedValue = parseAttr(args);
</del><ins>+ if (equalIgnoringCase(currentValue.function->name, "attr("))
+ parsedValue = parseAttr(*args);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (parsedValue) {
</span><span class="lines">@@ -3834,40 +3833,40 @@
</span><span class="cx"> {
</span><span class="cx"> RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
</span><span class="cx">
</span><del>- while (CSSParserValue* val = m_valueList->current()) {
</del><ins>+ while (CSSParserValue* value = m_valueList->current()) {
</ins><span class="cx"> RefPtr<CSSValue> parsedValue;
</span><del>- if (val->unit == CSSPrimitiveValue::CSS_URI) {
</del><ins>+ if (value->unit == CSSPrimitiveValue::CSS_URI) {
</ins><span class="cx"> // url
</span><del>- parsedValue = CSSImageValue::create(completeURL(val->string));
- } else if (val->unit == CSSParserValue::Function) {
</del><ins>+ parsedValue = CSSImageValue::create(completeURL(value->string));
+ } else if (value->unit == CSSParserValue::Function) {
</ins><span class="cx"> // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
</span><del>- CSSParserValueList* args = val->function->args.get();
</del><ins>+ CSSParserValueList* args = value->function->args.get();
</ins><span class="cx"> if (!args)
</span><span class="cx"> return false;
</span><del>- if (equalIgnoringCase(val->function->name, "attr(")) {
- parsedValue = parseAttr(args);
</del><ins>+ if (equalIgnoringCase(value->function->name, "attr(")) {
+ parsedValue = parseAttr(*args);
</ins><span class="cx"> if (!parsedValue)
</span><span class="cx"> return false;
</span><del>- } else if (equalIgnoringCase(val->function->name, "counter(")) {
- parsedValue = parseCounterContent(args, false);
</del><ins>+ } else if (equalIgnoringCase(value->function->name, "counter(")) {
+ parsedValue = parseCounterContent(*args, false);
</ins><span class="cx"> if (!parsedValue)
</span><span class="cx"> return false;
</span><del>- } else if (equalIgnoringCase(val->function->name, "counters(")) {
- parsedValue = parseCounterContent(args, true);
</del><ins>+ } else if (equalIgnoringCase(value->function->name, "counters(")) {
+ parsedValue = parseCounterContent(*args, true);
</ins><span class="cx"> if (!parsedValue)
</span><span class="cx"> return false;
</span><span class="cx"> #if ENABLE(CSS_IMAGE_SET)
</span><del>- } else if (equalIgnoringCase(val->function->name, "-webkit-image-set(")) {
</del><ins>+ } else if (equalIgnoringCase(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="cx"> #endif
</span><del>- } else if (isGeneratedImageValue(val)) {
- if (!parseGeneratedImage(m_valueList.get(), parsedValue))
</del><ins>+ } else if (isGeneratedImageValue(*value)) {
+ if (!parseGeneratedImage(*m_valueList, parsedValue))
</ins><span class="cx"> return false;
</span><span class="cx"> } else
</span><span class="cx"> return false;
</span><del>- } else if (val->unit == CSSPrimitiveValue::CSS_IDENT) {
</del><ins>+ } else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
</ins><span class="cx"> // open-quote
</span><span class="cx"> // close-quote
</span><span class="cx"> // no-open-quote
</span><span class="lines">@@ -3876,20 +3875,20 @@
</span><span class="cx"> // FIXME: These are not yet implemented (http://bugs.webkit.org/show_bug.cgi?id=6503).
</span><span class="cx"> // none
</span><span class="cx"> // normal
</span><del>- switch (val->id) {
</del><ins>+ switch (value->id) {
</ins><span class="cx"> case CSSValueOpenQuote:
</span><span class="cx"> case CSSValueCloseQuote:
</span><span class="cx"> case CSSValueNoOpenQuote:
</span><span class="cx"> case CSSValueNoCloseQuote:
</span><span class="cx"> case CSSValueNone:
</span><span class="cx"> case CSSValueNormal:
</span><del>- parsedValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ parsedValue = cssValuePool().createIdentifierValue(value->id);
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
- parsedValue = createPrimitiveStringValue(val);
</del><ins>+ } else if (value->unit == CSSPrimitiveValue::CSS_STRING) {
+ parsedValue = createPrimitiveStringValue(*value);
</ins><span class="cx"> }
</span><span class="cx"> if (!parsedValue)
</span><span class="cx"> break;
</span><span class="lines">@@ -3906,22 +3905,22 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSValue> CSSParser::parseAttr(CSSParserValueList* args)
</del><ins>+PassRefPtr<CSSValue> CSSParser::parseAttr(CSSParserValueList& args)
</ins><span class="cx"> {
</span><del>- if (args->size() != 1)
- return 0;
</del><ins>+ if (args.size() != 1)
+ return nullptr;
</ins><span class="cx">
</span><del>- CSSParserValue* a = args->current();
</del><ins>+ CSSParserValue& argument = *args.current();
</ins><span class="cx">
</span><del>- if (a->unit != CSSPrimitiveValue::CSS_IDENT)
- return 0;
</del><ins>+ if (argument.unit != CSSPrimitiveValue::CSS_IDENT)
+ return nullptr;
</ins><span class="cx">
</span><del>- String attrName = a->string;
</del><ins>+ String attrName = argument.string;
</ins><span class="cx"> // CSS allows identifiers with "-" at the start, like "-webkit-mask-image".
</span><span class="cx"> // But HTML attribute names can't have those characters, and we should not
</span><span class="cx"> // even parse them inside attr().
</span><span class="cx"> if (attrName[0] == '-')
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> if (m_context.isHTMLDocument)
</span><span class="cx"> attrName = attrName.lower();
</span><span class="lines">@@ -3938,22 +3937,22 @@
</span><span class="cx"> return parseColor();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFillImage(CSSParserValueList* valueList, RefPtr<CSSValue>& value)
</del><ins>+bool CSSParser::parseFillImage(CSSParserValueList& valueList, RefPtr<CSSValue>& value)
</ins><span class="cx"> {
</span><del>- if (valueList->current()->id == CSSValueNone) {
</del><ins>+ if (valueList.current()->id == CSSValueNone) {
</ins><span class="cx"> value = cssValuePool().createIdentifierValue(CSSValueNone);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
- value = CSSImageValue::create(completeURL(valueList->current()->string));
</del><ins>+ if (valueList.current()->unit == CSSPrimitiveValue::CSS_URI) {
+ value = CSSImageValue::create(completeURL(valueList.current()->string));
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (isGeneratedImageValue(valueList->current()))
</del><ins>+ if (isGeneratedImageValue(*valueList.current()))
</ins><span class="cx"> return parseGeneratedImage(valueList, value);
</span><span class="cx">
</span><span class="cx"> #if ENABLE(CSS_IMAGE_SET)
</span><del>- if (valueList->current()->unit == CSSParserValue::Function && equalIgnoringCase(valueList->current()->function->name, "-webkit-image-set(")) {
</del><ins>+ if (valueList.current()->unit == CSSParserValue::Function && equalIgnoringCase(valueList.current()->function->name, "-webkit-image-set(")) {
</ins><span class="cx"> value = parseImageSet();
</span><span class="cx"> if (value)
</span><span class="cx"> return true;
</span><span class="lines">@@ -3963,9 +3962,9 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSValue> CSSParser::parseFillPositionX(CSSParserValueList* valueList)
</del><ins>+PassRefPtr<CSSValue> CSSParser::parseFillPositionX(CSSParserValueList& valueList)
</ins><span class="cx"> {
</span><del>- int id = valueList->current()->id;
</del><ins>+ int id = valueList.current()->id;
</ins><span class="cx"> if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
</span><span class="cx"> int percent = 0;
</span><span class="cx"> if (id == CSSValueRight)
</span><span class="lines">@@ -3974,14 +3973,14 @@
</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());
- return 0;
</del><ins>+ if (validUnit(*valueList.current(), FPercent | FLength))
+ return createPrimitiveNumericValue(*valueList.current());
+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSValue> CSSParser::parseFillPositionY(CSSParserValueList* valueList)
</del><ins>+PassRefPtr<CSSValue> CSSParser::parseFillPositionY(CSSParserValueList& valueList)
</ins><span class="cx"> {
</span><del>- int id = valueList->current()->id;
</del><ins>+ int id = valueList.current()->id;
</ins><span class="cx"> if (id == CSSValueTop || id == CSSValueBottom || id == CSSValueCenter) {
</span><span class="cx"> int percent = 0;
</span><span class="cx"> if (id == CSSValueBottom)
</span><span class="lines">@@ -3990,14 +3989,14 @@
</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());
- return 0;
</del><ins>+ if (validUnit(*valueList.current(), FPercent | FLength))
+ return createPrimitiveNumericValue(*valueList.current());
+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSPrimitiveValue> CSSParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode parsingMode)
</del><ins>+PassRefPtr<CSSPrimitiveValue> CSSParser::parseFillPositionComponent(CSSParserValueList& valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode parsingMode)
</ins><span class="cx"> {
</span><del>- CSSValueID id = valueList->current()->id;
</del><ins>+ CSSValueID id = valueList.current()->id;
</ins><span class="cx"> if (id == CSSValueLeft || id == CSSValueTop || id == CSSValueRight || id == CSSValueBottom || id == CSSValueCenter) {
</span><span class="cx"> int percent = 0;
</span><span class="cx"> if (id == CSSValueLeft || id == CSSValueRight) {
</span><span class="lines">@@ -4027,7 +4026,7 @@
</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>+ if (validUnit(*valueList.current(), FPercent | FLength)) {
</ins><span class="cx"> if (!cumulativeFlags) {
</span><span class="cx"> cumulativeFlags |= XFillPosition;
</span><span class="cx"> individualFlag = XFillPosition;
</span><span class="lines">@@ -4039,7 +4038,7 @@
</span><span class="cx"> m_parsedCalculation = nullptr;
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><del>- return createPrimitiveNumericValue(valueList->current());
</del><ins>+ return createPrimitiveNumericValue(*valueList.current());
</ins><span class="cx"> }
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="lines">@@ -4060,7 +4059,7 @@
</span><span class="cx"> return value == CSSValueLeft || value == CSSValueTop || value == CSSValueBottom || value == CSSValueRight || value == CSSValueCenter;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParser::parse4ValuesFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, PassRefPtr<CSSPrimitiveValue> parsedValue1, PassRefPtr<CSSPrimitiveValue> parsedValue2)
</del><ins>+void CSSParser::parse4ValuesFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, PassRefPtr<CSSPrimitiveValue> parsedValue1, PassRefPtr<CSSPrimitiveValue> parsedValue2)
</ins><span class="cx"> {
</span><span class="cx"> // [ left | right ] [ <percentage] | <length> ] && [ top | bottom ] [ <percentage> | <length> ]
</span><span class="cx"> // In the case of 4 values <position> requires the second value to be a length or a percentage.
</span><span class="lines">@@ -4088,7 +4087,7 @@
</span><span class="cx"> if (isValueConflictingWithCurrentEdge(ident1, ident3))
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- valueList->next();
</del><ins>+ valueList.next();
</ins><span class="cx">
</span><span class="cx"> cumulativeFlags = 0;
</span><span class="cx"> FillPositionFlag value4Flag = InvalidFillPosition;
</span><span class="lines">@@ -4106,9 +4105,9 @@
</span><span class="cx"> if (ident1 == CSSValueTop || ident1 == CSSValueBottom)
</span><span class="cx"> value1.swap(value2);
</span><span class="cx">
</span><del>- valueList->next();
</del><ins>+ valueList.next();
</ins><span class="cx"> }
</span><del>-void CSSParser::parse3ValuesFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, PassRefPtr<CSSPrimitiveValue> parsedValue1, PassRefPtr<CSSPrimitiveValue> parsedValue2)
</del><ins>+void CSSParser::parse3ValuesFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, PassRefPtr<CSSPrimitiveValue> parsedValue1, PassRefPtr<CSSPrimitiveValue> parsedValue2)
</ins><span class="cx"> {
</span><span class="cx"> unsigned cumulativeFlags = 0;
</span><span class="cx"> FillPositionFlag value3Flag = InvalidFillPosition;
</span><span class="lines">@@ -4118,7 +4117,7 @@
</span><span class="cx"> if (!value3)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- valueList->next();
</del><ins>+ valueList.next();
</ins><span class="cx">
</span><span class="cx"> bool swapNeeded = false;
</span><span class="cx"> CSSValueID ident1 = parsedValue1->getValueID();
</span><span class="lines">@@ -4199,17 +4198,17 @@
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool CSSParser::isPotentialPositionValue(CSSParserValue* value)
</del><ins>+inline bool CSSParser::isPotentialPositionValue(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- return isFillPositionKeyword(value->id) || validUnit(value, FPercent | FLength, ReleaseParsedCalcValue);
</del><ins>+ return isFillPositionKeyword(value.id) || validUnit(value, FPercent | FLength, ReleaseParsedCalcValue);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParser::parseFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
</del><ins>+void CSSParser::parseFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
</ins><span class="cx"> {
</span><span class="cx"> unsigned numberOfValues = 0;
</span><del>- for (unsigned i = valueList->currentIndex(); i < valueList->size(); ++i, ++numberOfValues) {
- CSSParserValue* current = valueList->valueAt(i);
- if (isComma(current) || !current || isForwardSlashOperator(current) || !isPotentialPositionValue(current))
</del><ins>+ for (unsigned i = valueList.currentIndex(); i < valueList.size(); ++i, ++numberOfValues) {
+ CSSParserValue* current = valueList.valueAt(i);
+ if (!current || isComma(current) || isForwardSlashOperator(*current) || !isPotentialPositionValue(*current))
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4224,7 +4223,7 @@
</span><span class="cx">
</span><span class="cx"> ASSERT(numberOfValues > 2 && numberOfValues <= 4);
</span><span class="cx">
</span><del>- CSSParserValue* value = valueList->current();
</del><ins>+ CSSParserValue* value = valueList.current();
</ins><span class="cx">
</span><span class="cx"> // <position> requires the first value to be a background keyword.
</span><span class="cx"> if (!isFillPositionKeyword(value->id))
</span><span class="lines">@@ -4238,14 +4237,14 @@
</span><span class="cx"> if (!value1)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- value = valueList->next();
</del><ins>+ value = valueList.next();
</ins><span class="cx">
</span><span class="cx"> // In case we are parsing more than two values, relax the check inside of parseFillPositionComponent. top 20px is
</span><span class="cx"> // a valid start for <position>.
</span><span class="cx"> cumulativeFlags = AmbiguousFillPosition;
</span><span class="cx"> value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag, ResolveValuesAsKeyword);
</span><span class="cx"> if (value2)
</span><del>- valueList->next();
</del><ins>+ valueList.next();
</ins><span class="cx"> else {
</span><span class="cx"> value1.clear();
</span><span class="cx"> return;
</span><span class="lines">@@ -4267,9 +4266,9 @@
</span><span class="cx"> parse4ValuesFillPosition(valueList, value1, value2, parsedValue1.release(), parsedValue2.release());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParser::parse2ValuesFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
</del><ins>+void CSSParser::parse2ValuesFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
</ins><span class="cx"> {
</span><del>- CSSParserValue* value = valueList->current();
</del><ins>+ CSSParserValue* value = valueList.current();
</ins><span class="cx">
</span><span class="cx"> // Parse the first value. We're just making sure that it is one of the valid keywords or a percentage/length.
</span><span class="cx"> unsigned cumulativeFlags = 0;
</span><span class="lines">@@ -4282,16 +4281,16 @@
</span><span class="cx"> // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
</span><span class="cx"> // can assume that any other values belong to the rest of the shorthand). If we're not parsing a shorthand, though, the
</span><span class="cx"> // value was explicitly specified for our property.
</span><del>- value = valueList->next();
</del><ins>+ value = valueList.next();
</ins><span class="cx">
</span><span class="cx"> // First check for the comma. If so, we are finished parsing this value or value pair.
</span><span class="cx"> if (isComma(value))
</span><del>- value = 0;
</del><ins>+ value = nullptr;
</ins><span class="cx">
</span><span class="cx"> if (value) {
</span><span class="cx"> value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag);
</span><span class="cx"> if (value2)
</span><del>- valueList->next();
</del><ins>+ valueList.next();
</ins><span class="cx"> else {
</span><span class="cx"> if (!inShorthand()) {
</span><span class="cx"> value1.clear();
</span><span class="lines">@@ -4331,7 +4330,7 @@
</span><span class="cx"> if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)
</span><span class="cx"> value1 = cssValuePool().createIdentifierValue(id);
</span><span class="cx"> else {
</span><del>- value1 = 0;
</del><ins>+ value1 = nullptr;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4365,9 +4364,9 @@
</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))
- return 0;
- parsedValue1 = createPrimitiveNumericValue(value);
</del><ins>+ if (!validUnit(*value, FLength | FPercent))
+ return nullptr;
+ parsedValue1 = createPrimitiveNumericValue(*value);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSPrimitiveValue> parsedValue2;
</span><span class="lines">@@ -4375,13 +4374,13 @@
</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>+ if (!validUnit(*value, FLength | FPercent)) {
</ins><span class="cx"> if (!inShorthand())
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><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(*value);
</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">@@ -4400,13 +4399,13 @@
</span><span class="cx"> {
</span><span class="cx"> RefPtr<CSSValueList> values;
</span><span class="cx"> RefPtr<CSSValueList> values2;
</span><del>- CSSParserValue* val;
</del><ins>+ CSSParserValue* currentValue;
</ins><span class="cx"> RefPtr<CSSValue> value;
</span><span class="cx"> RefPtr<CSSValue> value2;
</span><span class="cx">
</span><span class="cx"> bool allowComma = false;
</span><span class="cx">
</span><del>- retValue1 = retValue2 = 0;
</del><ins>+ retValue1 = retValue2 = nullptr;
</ins><span class="cx"> propId1 = propId;
</span><span class="cx"> propId2 = propId;
</span><span class="cx"> if (propId == CSSPropertyBackgroundPosition) {
</span><span class="lines">@@ -4423,12 +4422,12 @@
</span><span class="cx"> propId2 = CSSPropertyWebkitMaskRepeatY;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- while ((val = m_valueList->current())) {
</del><ins>+ while ((currentValue = m_valueList->current())) {
</ins><span class="cx"> RefPtr<CSSValue> currValue;
</span><span class="cx"> RefPtr<CSSValue> currValue2;
</span><span class="cx">
</span><span class="cx"> if (allowComma) {
</span><del>- if (!isComma(val))
</del><ins>+ if (!isComma(currentValue))
</ins><span class="cx"> return false;
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> allowComma = false;
</span><span class="lines">@@ -4441,14 +4440,14 @@
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundAttachment:
</span><del>- if (val->id == CSSValueScroll || val->id == CSSValueFixed || val->id == CSSValueLocal) {
- currValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ if (currentValue->id == CSSValueScroll || currentValue->id == CSSValueFixed || currentValue->id == CSSValueLocal) {
+ currValue = cssValuePool().createIdentifierValue(currentValue->id);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundImage:
</span><span class="cx"> case CSSPropertyWebkitMaskImage:
</span><del>- if (parseFillImage(m_valueList.get(), currValue))
</del><ins>+ if (parseFillImage(*m_valueList, currValue))
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitBackgroundClip:
</span><span class="lines">@@ -4457,57 +4456,57 @@
</span><span class="cx"> case CSSPropertyWebkitMaskOrigin:
</span><span class="cx"> // The first three values here are deprecated and do not apply to the version of the property that has
</span><span class="cx"> // the -webkit- prefix removed.
</span><del>- if (val->id == CSSValueBorder || val->id == CSSValuePadding || val->id == CSSValueContent ||
- val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox ||
- ((propId == CSSPropertyWebkitBackgroundClip || propId == CSSPropertyWebkitMaskClip) &&
- (val->id == CSSValueText || val->id == CSSValueWebkitText))) {
- currValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ if (currentValue->id == CSSValueBorder || currentValue->id == CSSValuePadding || currentValue->id == CSSValueContent
+ || currentValue->id == CSSValueBorderBox || currentValue->id == CSSValuePaddingBox || currentValue->id == CSSValueContentBox
+ || ((propId == CSSPropertyWebkitBackgroundClip || propId == CSSPropertyWebkitMaskClip)
+ && (currentValue->id == CSSValueText || currentValue->id == CSSValueWebkitText))) {
+ currValue = cssValuePool().createIdentifierValue(currentValue->id);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundClip:
</span><del>- if (parseBackgroundClip(val, currValue))
</del><ins>+ if (parseBackgroundClip(*currentValue, currValue))
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundOrigin:
</span><del>- if (val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox) {
- currValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ if (currentValue->id == CSSValueBorderBox || currentValue->id == CSSValuePaddingBox || currentValue->id == CSSValueContentBox) {
+ currValue = cssValuePool().createIdentifierValue(currentValue->id);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundPosition:
</span><span class="cx"> case CSSPropertyWebkitMaskPosition:
</span><del>- parseFillPosition(m_valueList.get(), currValue, currValue2);
</del><ins>+ parseFillPosition(*m_valueList, currValue, currValue2);
</ins><span class="cx"> // parseFillPosition advances the m_valueList pointer.
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundPositionX:
</span><span class="cx"> case CSSPropertyWebkitMaskPositionX: {
</span><del>- currValue = parseFillPositionX(m_valueList.get());
</del><ins>+ currValue = parseFillPositionX(*m_valueList);
</ins><span class="cx"> if (currValue)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyBackgroundPositionY:
</span><span class="cx"> case CSSPropertyWebkitMaskPositionY: {
</span><del>- currValue = parseFillPositionY(m_valueList.get());
</del><ins>+ currValue = parseFillPositionY(*m_valueList);
</ins><span class="cx"> if (currValue)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyWebkitBackgroundComposite:
</span><span class="cx"> case CSSPropertyWebkitMaskComposite:
</span><del>- if (val->id >= CSSValueClear && val->id <= CSSValuePlusLighter) {
- currValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ if (currentValue->id >= CSSValueClear && currentValue->id <= CSSValuePlusLighter) {
+ currValue = cssValuePool().createIdentifierValue(currentValue->id);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyBackgroundBlendMode:
</span><del>- if (cssCompositingEnabled() && (val->id == CSSValueNormal || val->id == CSSValueMultiply
- || val->id == CSSValueScreen || val->id == CSSValueOverlay || val->id == CSSValueDarken
- || val->id == CSSValueLighten || val->id == CSSValueColorDodge || val->id == CSSValueColorBurn
- || val->id == CSSValueHardLight || val->id == CSSValueSoftLight || val->id == CSSValueDifference
- || val->id == CSSValueExclusion)) {
- currValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ if (cssCompositingEnabled() && (currentValue->id == CSSValueNormal || currentValue->id == CSSValueMultiply
+ || currentValue->id == CSSValueScreen || currentValue->id == CSSValueOverlay || currentValue->id == CSSValueDarken
+ || currentValue->id == CSSValueLighten || currentValue->id == CSSValueColorDodge || currentValue->id == CSSValueColorBurn
+ || currentValue->id == CSSValueHardLight || currentValue->id == CSSValueSoftLight || currentValue->id == CSSValueDifference
+ || currentValue->id == CSSValueExclusion)) {
+ currValue = cssValuePool().createIdentifierValue(currentValue->id);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="lines">@@ -4525,11 +4524,11 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyWebkitMaskSourceType: {
</span><del>- if (val->id == CSSValueAuto || val->id == CSSValueAlpha || val->id == CSSValueLuminance) {
- currValue = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ if (currentValue->id == CSSValueAuto || currentValue->id == CSSValueAlpha || currentValue->id == CSSValueLuminance) {
+ currValue = cssValuePool().createIdentifierValue(currentValue->id);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> } else
</span><del>- currValue = 0;
</del><ins>+ currValue = nullptr;
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> default:
</span><span class="lines">@@ -4582,10 +4581,10 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationDelay()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
</del><ins>+ CSSParserValue& value = *m_valueList->current();
</ins><span class="cx"> if (validUnit(value, FTime))
</span><span class="cx"> return createPrimitiveNumericValue(value);
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationDirection()
</span><span class="lines">@@ -4593,15 +4592,15 @@
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><span class="cx"> if (value->id == CSSValueNormal || value->id == CSSValueAlternate || value->id == CSSValueReverse || value->id == CSSValueAlternateReverse)
</span><span class="cx"> return cssValuePool().createIdentifierValue(value->id);
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationDuration()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
</del><ins>+ CSSParserValue& value = *m_valueList->current();
</ins><span class="cx"> if (validUnit(value, FTime | FNonNeg))
</span><span class="cx"> return createPrimitiveNumericValue(value);
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationFillMode()
</span><span class="lines">@@ -4609,46 +4608,45 @@
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><span class="cx"> if (value->id == CSSValueNone || value->id == CSSValueForwards || value->id == CSSValueBackwards || value->id == CSSValueBoth)
</span><span class="cx"> return cssValuePool().createIdentifierValue(value->id);
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationIterationCount()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (value->id == CSSValueInfinite)
- return cssValuePool().createIdentifierValue(value->id);
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ if (value.id == CSSValueInfinite)
+ return cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx"> if (validUnit(value, FNumber | FNonNeg))
</span><span class="cx"> return createPrimitiveNumericValue(value);
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationName()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT) {
- if (value->id == CSSValueNone || (value->unit == CSSPrimitiveValue::CSS_STRING && equalIgnoringCase(value, "none"))) {
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ if (value.unit == CSSPrimitiveValue::CSS_STRING || value.unit == CSSPrimitiveValue::CSS_IDENT) {
+ if (value.id == CSSValueNone || (value.unit == CSSPrimitiveValue::CSS_STRING && equalIgnoringCase(value, "none"))) {
</ins><span class="cx"> return cssValuePool().createIdentifierValue(CSSValueNone);
</span><del>- } else {
- return createPrimitiveStringValue(value);
</del><span class="cx"> }
</span><ins>+ return createPrimitiveStringValue(value);
</ins><span class="cx"> }
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationPlayState()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (value->id == CSSValueRunning || value->id == CSSValuePaused)
- return cssValuePool().createIdentifierValue(value->id);
- return 0;
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ if (value.id == CSSValueRunning || value.id == CSSValuePaused)
+ return cssValuePool().createIdentifierValue(value.id);
+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationProperty(AnimationParseContext& context)
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (value->unit != CSSPrimitiveValue::CSS_IDENT)
- return 0;
- CSSPropertyID result = cssPropertyID(value->string);
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ if (value.unit != CSSPrimitiveValue::CSS_IDENT)
+ return nullptr;
+ CSSPropertyID result = cssPropertyID(value.string);
</ins><span class="cx"> if (result)
</span><span class="cx"> return cssValuePool().createIdentifierValue(result);
</span><span class="cx"> if (equalIgnoringCase(value, "all")) {
</span><span class="lines">@@ -4660,17 +4658,17 @@
</span><span class="cx"> context.sawAnimationPropertyKeyword();
</span><span class="cx"> return cssValuePool().createIdentifierValue(CSSValueNone);
</span><span class="cx"> }
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseTransformOriginShorthand(RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, RefPtr<CSSValue>& value3)
</span><span class="cx"> {
</span><del>- parse2ValuesFillPosition(m_valueList.get(), value1, value2);
</del><ins>+ parse2ValuesFillPosition(*m_valueList, value1, value2);
</ins><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>+ if (validUnit(*m_valueList->current(), FLength)) {
+ value3 = createPrimitiveNumericValue(*m_valueList->current());
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -4680,91 +4678,91 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result)
</del><ins>+bool CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList& args, double& result)
</ins><span class="cx"> {
</span><del>- CSSParserValue* value = args->current();
- if (!validUnit(value, FNumber))
</del><ins>+ CSSParserValue* value = args.current();
+ if (!validUnit(*value, FNumber))
</ins><span class="cx"> return false;
</span><span class="cx"> result = parsedDouble(*value, ReleaseParsedCalcValue);
</span><del>- value = args->next();
</del><ins>+ value = args.next();
</ins><span class="cx"> if (!value) {
</span><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><span class="cx"> if (!isComma(value))
</span><span class="cx"> return false;
</span><del>- args->next();
</del><ins>+ args.next();
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseAnimationTimingFunction()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- if (value->id == CSSValueEase || value->id == CSSValueLinear || value->id == CSSValueEaseIn || value->id == CSSValueEaseOut
- || value->id == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd)
- return cssValuePool().createIdentifierValue(value->id);
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ if (value.id == CSSValueEase || value.id == CSSValueLinear || value.id == CSSValueEaseIn || value.id == CSSValueEaseOut
+ || value.id == CSSValueEaseInOut || value.id == CSSValueStepStart || value.id == CSSValueStepEnd)
+ return cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx">
</span><span class="cx"> // We must be a function.
</span><del>- if (value->unit != CSSParserValue::Function)
- return 0;
</del><ins>+ if (value.unit != CSSParserValue::Function)
+ return nullptr;
</ins><span class="cx">
</span><del>- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx">
</span><del>- if (equalIgnoringCase(value->function->name, "steps(")) {
</del><ins>+ if (equalIgnoringCase(value.function->name, "steps(")) {
</ins><span class="cx"> // For steps, 1 or 2 params must be specified (comma-separated)
</span><span class="cx"> if (!args || (args->size() != 1 && args->size() != 3))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // There are two values.
</span><span class="cx"> int numSteps;
</span><span class="cx"> bool stepAtStart = false;
</span><span class="cx">
</span><del>- CSSParserValue* v = args->current();
- if (!validUnit(v, FInteger))
- return 0;
- numSteps = clampToInteger(v->fValue);
</del><ins>+ CSSParserValue* currentValue = args->current();
+ if (!validUnit(*currentValue, FInteger))
+ return nullptr;
+ numSteps = clampToInteger(currentValue->fValue);
</ins><span class="cx"> if (numSteps < 1)
</span><del>- return 0;
- v = args->next();
</del><ins>+ return nullptr;
+ currentValue = args->next();
</ins><span class="cx">
</span><del>- if (v) {
</del><ins>+ if (currentValue) {
</ins><span class="cx"> // There is a comma so we need to parse the second value
</span><del>- if (!isComma(v))
- return 0;
- v = args->next();
- if (v->id != CSSValueStart && v->id != CSSValueEnd)
- return 0;
- stepAtStart = v->id == CSSValueStart;
</del><ins>+ if (!isComma(currentValue))
+ return nullptr;
+ currentValue = args->next();
+ if (currentValue->id != CSSValueStart && currentValue->id != CSSValueEnd)
+ return nullptr;
+ stepAtStart = currentValue->id == CSSValueStart;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (equalIgnoringCase(value->function->name, "cubic-bezier(")) {
</del><ins>+ if (equalIgnoringCase(value.function->name, "cubic-bezier(")) {
</ins><span class="cx"> // For cubic bezier, 4 values must be specified.
</span><span class="cx"> if (!args || args->size() != 7)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // There are two points specified. The x values must be between 0 and 1 but the y values can exceed this range.
</span><span class="cx"> double x1, y1, x2, y2;
</span><span class="cx">
</span><del>- if (!parseCubicBezierTimingFunctionValue(args, x1))
- return 0;
</del><ins>+ if (!parseCubicBezierTimingFunctionValue(*args, x1))
+ return nullptr;
</ins><span class="cx"> if (x1 < 0 || x1 > 1)
</span><del>- return 0;
- if (!parseCubicBezierTimingFunctionValue(args, y1))
- return 0;
- if (!parseCubicBezierTimingFunctionValue(args, x2))
- return 0;
</del><ins>+ return nullptr;
+ if (!parseCubicBezierTimingFunctionValue(*args, y1))
+ return nullptr;
+ if (!parseCubicBezierTimingFunctionValue(*args, x2))
+ return nullptr;
</ins><span class="cx"> if (x2 < 0 || x2 > 1)
</span><del>- return 0;
- if (!parseCubicBezierTimingFunctionValue(args, y2))
- return 0;
</del><ins>+ return nullptr;
+ if (!parseCubicBezierTimingFunctionValue(*args, y2))
+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseAnimationProperty(CSSPropertyID propId, RefPtr<CSSValue>& result, AnimationParseContext& context)
</span><span class="lines">@@ -4774,7 +4772,7 @@
</span><span class="cx"> RefPtr<CSSValue> value;
</span><span class="cx"> bool allowComma = false;
</span><span class="cx">
</span><del>- result = 0;
</del><ins>+ result = nullptr;
</ins><span class="cx">
</span><span class="cx"> while ((val = m_valueList->current())) {
</span><span class="cx"> RefPtr<CSSValue> currValue;
</span><span class="lines">@@ -4896,21 +4894,21 @@
</span><span class="cx"> bool CSSParser::parseIntegerOrCustomIdentFromGridPosition(RefPtr<CSSPrimitiveValue>& numericValue, RefPtr<CSSPrimitiveValue>& gridLineName)
</span><span class="cx"> {
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><del>- if (validUnit(value, FInteger) && value->fValue) {
- numericValue = createPrimitiveNumericValue(value);
</del><ins>+ if (validUnit(*value, FInteger) && value->fValue) {
+ numericValue = createPrimitiveNumericValue(*value);
</ins><span class="cx"> value = m_valueList->next();
</span><span class="cx"> if (value && isValidCustomIdent(*value)) {
</span><del>- gridLineName = createPrimitiveStringValue(m_valueList->current());
</del><ins>+ gridLineName = createPrimitiveStringValue(*m_valueList->current());
</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><span class="cx"> if (isValidCustomIdent(*value)) {
</span><del>- gridLineName = createPrimitiveStringValue(m_valueList->current());
</del><ins>+ gridLineName = createPrimitiveStringValue(*m_valueList->current());
</ins><span class="cx"> value = m_valueList->next();
</span><del>- if (value && validUnit(value, FInteger) && value->fValue) {
- numericValue = createPrimitiveNumericValue(value);
</del><ins>+ if (value && validUnit(*value, FInteger) && value->fValue) {
+ numericValue = createPrimitiveNumericValue(*value);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> return true;
</span><span class="lines">@@ -4934,7 +4932,7 @@
</span><span class="cx"> if (value->id == CSSValueSpan) {
</span><span class="cx"> hasSeenSpanKeyword = true;
</span><span class="cx"> if (auto* nextValue = m_valueList->next()) {
</span><del>- if (!isForwardSlashOperator(nextValue) && !parseIntegerOrCustomIdentFromGridPosition(numericValue, gridLineName))
</del><ins>+ if (!isForwardSlashOperator(*nextValue) && !parseIntegerOrCustomIdentFromGridPosition(numericValue, gridLineName))
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx"> } else if (parseIntegerOrCustomIdentFromGridPosition(numericValue, gridLineName)) {
</span><span class="lines">@@ -4947,7 +4945,7 @@
</span><span class="cx">
</span><span class="cx"> // Check that we have consumed all the value list. For shorthands, the parser will pass
</span><span class="cx"> // the whole value list (including the opposite position).
</span><del>- if (m_valueList->current() && !isForwardSlashOperator(m_valueList->current()))
</del><ins>+ if (m_valueList->current() && !isForwardSlashOperator(*m_valueList->current()))
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> // If we didn't parse anything, this is not a valid grid position.
</span><span class="lines">@@ -4973,10 +4971,10 @@
</span><span class="cx"> return values.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static PassRefPtr<CSSValue> gridMissingGridPositionValue(CSSValue* value)
</del><ins>+static PassRefPtr<CSSValue> gridMissingGridPositionValue(CSSValue& value)
</ins><span class="cx"> {
</span><del>- if (is<CSSPrimitiveValue>(*value) && downcast<CSSPrimitiveValue>(*value).isString())
- return value;
</del><ins>+ if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).isString())
+ return &value;
</ins><span class="cx">
</span><span class="cx"> return cssValuePool().createIdentifierValue(CSSValueAuto);
</span><span class="cx"> }
</span><span class="lines">@@ -4993,7 +4991,7 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSValue> endValue;
</span><span class="cx"> if (m_valueList->current()) {
</span><del>- if (!isForwardSlashOperator(m_valueList->current()))
</del><ins>+ if (!isForwardSlashOperator(*m_valueList->current()))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (!m_valueList->next())
</span><span class="lines">@@ -5003,7 +5001,7 @@
</span><span class="cx"> if (!endValue || m_valueList->current())
</span><span class="cx"> return false;
</span><span class="cx"> } else
</span><del>- endValue = gridMissingGridPositionValue(startValue.get());
</del><ins>+ endValue = gridMissingGridPositionValue(*startValue);
</ins><span class="cx">
</span><span class="cx"> addProperty(shorthand.properties()[0], startValue, important);
</span><span class="cx"> addProperty(shorthand.properties()[1], endValue, important);
</span><span class="lines">@@ -5090,7 +5088,7 @@
</span><span class="cx">
</span><span class="cx"> // 2- <grid-template-columns> / <grid-template-columns> syntax.
</span><span class="cx"> if (columnsValue) {
</span><del>- if (!(m_valueList->current() && isForwardSlashOperator(m_valueList->current()) && m_valueList->next()))
</del><ins>+ if (!(m_valueList->current() && isForwardSlashOperator(*m_valueList->current()) && m_valueList->next()))
</ins><span class="cx"> return false;
</span><span class="cx"> index = m_valueList->currentIndex();
</span><span class="cx"> if (RefPtr<CSSValue> rowsValue = parseGridTrackList()) {
</span><span class="lines">@@ -5143,7 +5141,7 @@
</span><span class="cx"> if (!autoColumnsValue)
</span><span class="cx"> return false;
</span><span class="cx"> if (m_valueList->current()) {
</span><del>- if (!isForwardSlashOperator(m_valueList->current()) || !m_valueList->next())
</del><ins>+ if (!isForwardSlashOperator(*m_valueList->current()) || !m_valueList->next())
</ins><span class="cx"> return false;
</span><span class="cx"> autoRowsValue = parseGridTrackSize(*m_valueList);
</span><span class="cx"> if (!autoRowsValue)
</span><span class="lines">@@ -5195,13 +5193,13 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (!columnStartValue)
</span><del>- columnStartValue = gridMissingGridPositionValue(rowStartValue.get());
</del><ins>+ columnStartValue = gridMissingGridPositionValue(*rowStartValue);
</ins><span class="cx">
</span><span class="cx"> if (!rowEndValue)
</span><del>- rowEndValue = gridMissingGridPositionValue(rowStartValue.get());
</del><ins>+ rowEndValue = gridMissingGridPositionValue(*rowStartValue);
</ins><span class="cx">
</span><span class="cx"> if (!columnEndValue)
</span><del>- columnEndValue = gridMissingGridPositionValue(columnStartValue.get());
</del><ins>+ columnEndValue = gridMissingGridPositionValue(*columnStartValue);
</ins><span class="cx">
</span><span class="cx"> addProperty(CSSPropertyWebkitGridRowStart, rowStartValue, important);
</span><span class="cx"> addProperty(CSSPropertyWebkitGridColumnStart, columnStartValue, important);
</span><span class="lines">@@ -5215,7 +5213,7 @@
</span><span class="cx"> if (!m_valueList->current())
</span><span class="cx"> return true;
</span><span class="cx">
</span><del>- if (!isForwardSlashOperator(m_valueList->current()))
</del><ins>+ if (!isForwardSlashOperator(*m_valueList->current()))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (!m_valueList->next())
</span><span class="lines">@@ -5229,20 +5227,20 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(inputList.current() && inputList.current()->unit == CSSParserValue::ValueList);
</span><span class="cx">
</span><del>- CSSParserValueList* identList = inputList.current()->valueList;
- if (!identList->size()) {
</del><ins>+ CSSParserValueList& identList = *inputList.current()->valueList;
+ if (!identList.size()) {
</ins><span class="cx"> inputList.next();
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Need to ensure the identList is at the heading index, since the parserList might have been rewound.
</span><del>- identList->setCurrentIndex(0);
</del><ins>+ identList.setCurrentIndex(0);
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSGridLineNamesValue> lineNames = previousNamedAreaTrailingLineNames ? previousNamedAreaTrailingLineNames : CSSGridLineNamesValue::create();
</span><del>- while (CSSParserValue* identValue = identList->current()) {
</del><ins>+ while (CSSParserValue* identValue = identList.current()) {
</ins><span class="cx"> ASSERT(identValue->unit == CSSPrimitiveValue::CSS_IDENT);
</span><del>- lineNames->append(createPrimitiveStringValue(identValue));
- identList->next();
</del><ins>+ lineNames->append(createPrimitiveStringValue(*identValue));
+ identList.next();
</ins><span class="cx"> }
</span><span class="cx"> if (!previousNamedAreaTrailingLineNames)
</span><span class="cx"> valueList.append(lineNames.releaseNonNull());
</span><span class="lines">@@ -5267,7 +5265,7 @@
</span><span class="cx">
</span><span class="cx"> bool seenTrackSizeOrRepeatFunction = false;
</span><span class="cx"> while (CSSParserValue* currentValue = m_valueList->current()) {
</span><del>- if (isForwardSlashOperator(currentValue))
</del><ins>+ if (isForwardSlashOperator(*currentValue))
</ins><span class="cx"> break;
</span><span class="cx"> if (currentValue->unit == CSSParserValue::Function && equalIgnoringCase(currentValue->function->name, "repeat(")) {
</span><span class="cx"> if (!parseGridTrackRepeatFunction(*values))
</span><span class="lines">@@ -5295,7 +5293,7 @@
</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 || !validUnit(*arguments->valueAt(0), FPositiveInteger) || !isComma(arguments->valueAt(1)))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> ASSERT(arguments->valueAt(0)->fValue > 0);
</span><span class="lines">@@ -5346,25 +5344,25 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseGridTrackSize(CSSParserValueList& inputList)
</span><span class="cx"> {
</span><del>- CSSParserValue* currentValue = inputList.current();
</del><ins>+ CSSParserValue& currentValue = *inputList.current();
</ins><span class="cx"> inputList.next();
</span><span class="cx">
</span><del>- if (currentValue->id == CSSValueAuto)
</del><ins>+ if (currentValue.id == CSSValueAuto)
</ins><span class="cx"> return cssValuePool().createIdentifierValue(CSSValueAuto);
</span><span class="cx">
</span><del>- if (currentValue->unit == CSSParserValue::Function && equalIgnoringCase(currentValue->function->name, "minmax(")) {
</del><ins>+ if (currentValue.unit == CSSParserValue::Function && equalIgnoringCase(currentValue.function->name, "minmax(")) {
</ins><span class="cx"> // The spec defines the following grammar: minmax( <track-breadth> , <track-breadth> )
</span><del>- CSSParserValueList* arguments = currentValue->function->args.get();
</del><ins>+ CSSParserValueList* arguments = currentValue.function->args.get();
</ins><span class="cx"> if (!arguments || arguments->size() != 3 || !isComma(arguments->valueAt(1)))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- RefPtr<CSSPrimitiveValue> minTrackBreadth = parseGridBreadth(arguments->valueAt(0));
</del><ins>+ RefPtr<CSSPrimitiveValue> minTrackBreadth = parseGridBreadth(*arguments->valueAt(0));
</ins><span class="cx"> if (!minTrackBreadth)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- RefPtr<CSSPrimitiveValue> maxTrackBreadth = parseGridBreadth(arguments->valueAt(2));
</del><ins>+ RefPtr<CSSPrimitiveValue> maxTrackBreadth = parseGridBreadth(*arguments->valueAt(2));
</ins><span class="cx"> if (!maxTrackBreadth)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSValueList> parsedArguments = CSSValueList::createCommaSeparated();
</span><span class="cx"> parsedArguments->append(minTrackBreadth.releaseNonNull());
</span><span class="lines">@@ -5375,23 +5373,23 @@
</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& currentValue)
</ins><span class="cx"> {
</span><del>- if (currentValue->id == CSSValueWebkitMinContent || currentValue->id == CSSValueWebkitMaxContent)
- return cssValuePool().createIdentifierValue(currentValue->id);
</del><ins>+ if (currentValue.id == CSSValueWebkitMinContent || currentValue.id == CSSValueWebkitMaxContent)
+ return cssValuePool().createIdentifierValue(currentValue.id);
</ins><span class="cx">
</span><del>- if (currentValue->unit == CSSPrimitiveValue::CSS_FR) {
- double flexValue = currentValue->fValue;
</del><ins>+ if (currentValue.unit == CSSPrimitiveValue::CSS_FR) {
+ double flexValue = currentValue.fValue;
</ins><span class="cx">
</span><span class="cx"> // Fractional unit is a non-negative dimension.
</span><span class="cx"> if (flexValue <= 0)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> return cssValuePool().createValue(flexValue, CSSPrimitiveValue::CSS_FR);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (!validUnit(currentValue, FNonNeg | FLength | FPercent))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> return createPrimitiveNumericValue(currentValue);
</span><span class="cx"> }
</span><span class="lines">@@ -5464,8 +5462,8 @@
</span><span class="cx"> {
</span><span class="cx"> if (args->size() == (DASHBOARD_REGION_NUM_PARAMETERS*2-1) ||
</span><span class="cx"> args->size() == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
</span><del>- CSSParserValue* current = args->current();
- if (current->unit == CSSParserValue::Operator && current->iValue == ',')
</del><ins>+ CSSParserValue& current = *args->current();
+ if (current.unit == CSSParserValue::Operator && current.iValue == ',')
</ins><span class="cx"> return args->next();
</span><span class="cx"> }
</span><span class="cx"> return args->current();
</span><span class="lines">@@ -5485,10 +5483,10 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<DashboardRegion> firstRegion = DashboardRegion::create();
</span><del>- DashboardRegion* region = 0;
</del><ins>+ DashboardRegion* region = nullptr;
</ins><span class="cx">
</span><span class="cx"> while (value) {
</span><del>- if (region == 0) {
</del><ins>+ if (!region) {
</ins><span class="cx"> region = firstRegion.get();
</span><span class="cx"> } else {
</span><span class="cx"> RefPtr<DashboardRegion> nextRegion = DashboardRegion::create();
</span><span class="lines">@@ -5537,9 +5535,9 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (equalIgnoringCase(arg, "circle"))
</del><ins>+ if (equalIgnoringCase(*arg, "circle"))
</ins><span class="cx"> region->m_isCircle = true;
</span><del>- else if (equalIgnoringCase(arg, "rectangle"))
</del><ins>+ else if (equalIgnoringCase(*arg, "rectangle"))
</ins><span class="cx"> region->m_isRectangle = true;
</span><span class="cx"> else {
</span><span class="cx"> valid = false;
</span><span class="lines">@@ -5558,18 +5556,15 @@
</span><span class="cx"> region->setLeft(amount);
</span><span class="cx"> } else {
</span><span class="cx"> // Next four arguments must be offset numbers
</span><del>- int i;
- for (i = 0; i < 4; i++) {
</del><ins>+ for (int i = 0; i < 4; ++i) {
</ins><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>+ valid = arg->id == CSSValueAuto || validUnit(*arg, 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(*arg);
</ins><span class="cx">
</span><span class="cx"> if (i == 0)
</span><span class="cx"> region->setTop(amount);
</span><span class="lines">@@ -5641,15 +5636,15 @@
</span><span class="cx"> // The following checks test that the grid area is a single filled-in rectangle.
</span><span class="cx"> // 1. The new row is adjacent to the previously parsed row.
</span><span class="cx"> if (rowCount != gridCoordinate.rows.resolvedFinalPosition.next().toInt())
</span><del>- return 0;
</del><ins>+ return false;
</ins><span class="cx">
</span><span class="cx"> // 2. The new area starts at the same position as the previously parsed area.
</span><span class="cx"> if (currentColumn != gridCoordinate.columns.resolvedInitialPosition.toInt())
</span><del>- return 0;
</del><ins>+ return false;
</ins><span class="cx">
</span><span class="cx"> // 3. The new area ends at the same position as the previously parsed area.
</span><span class="cx"> if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition.toInt())
</span><del>- return 0;
</del><ins>+ return false;
</ins><span class="cx">
</span><span class="cx"> ++gridCoordinate.rows.resolvedFinalPosition;
</span><span class="cx"> }
</span><span class="lines">@@ -5668,62 +5663,62 @@
</span><span class="cx">
</span><span class="cx"> while (m_valueList->current()) {
</span><span class="cx"> if (!parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> ++rowCount;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (!rowCount || !columnCount)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
</span><span class="cx"> }
</span><span class="cx"> #endif /* ENABLE(CSS_GRID_LAYOUT) */
</span><span class="cx">
</span><del>-PassRefPtr<CSSValue> CSSParser::parseCounterContent(CSSParserValueList* args, bool counters)
</del><ins>+PassRefPtr<CSSValue> CSSParser::parseCounterContent(CSSParserValueList& args, bool counters)
</ins><span class="cx"> {
</span><del>- unsigned numArgs = args->size();
</del><ins>+ unsigned numArgs = args.size();
</ins><span class="cx"> if (counters && numArgs != 3 && numArgs != 5)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> if (!counters && numArgs != 1 && numArgs != 3)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- CSSParserValue* i = args->current();
- if (i->unit != CSSPrimitiveValue::CSS_IDENT)
- return 0;
- RefPtr<CSSPrimitiveValue> identifier = createPrimitiveStringValue(i);
</del><ins>+ CSSParserValue* argument = args.current();
+ if (argument->unit != CSSPrimitiveValue::CSS_IDENT)
+ return nullptr;
+ RefPtr<CSSPrimitiveValue> identifier = createPrimitiveStringValue(*argument);
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSPrimitiveValue> separator;
</span><span class="cx"> if (!counters)
</span><span class="cx"> separator = cssValuePool().createValue(String(), CSSPrimitiveValue::CSS_STRING);
</span><span class="cx"> else {
</span><del>- i = args->next();
- if (i->unit != CSSParserValue::Operator || i->iValue != ',')
- return 0;
</del><ins>+ argument = args.next();
+ if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
+ return nullptr;
</ins><span class="cx">
</span><del>- i = args->next();
- if (i->unit != CSSPrimitiveValue::CSS_STRING)
- return 0;
</del><ins>+ argument = args.next();
+ if (argument->unit != CSSPrimitiveValue::CSS_STRING)
+ return nullptr;
</ins><span class="cx">
</span><del>- separator = createPrimitiveStringValue(i);
</del><ins>+ separator = createPrimitiveStringValue(*argument);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSPrimitiveValue> listStyle;
</span><del>- i = args->next();
- if (!i) // Make the list style default decimal
</del><ins>+ argument = args.next();
+ if (!argument) // Make the list style default decimal
</ins><span class="cx"> listStyle = cssValuePool().createIdentifierValue(CSSValueDecimal);
</span><span class="cx"> else {
</span><del>- if (i->unit != CSSParserValue::Operator || i->iValue != ',')
- return 0;
</del><ins>+ if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
+ return nullptr;
</ins><span class="cx">
</span><del>- i = args->next();
- if (i->unit != CSSPrimitiveValue::CSS_IDENT)
- return 0;
</del><ins>+ argument = args.next();
+ if (argument->unit != CSSPrimitiveValue::CSS_IDENT)
+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> CSSValueID listStyleID = CSSValueInvalid;
</span><del>- if (i->id == CSSValueNone || (i->id >= CSSValueDisc && i->id <= CSSValueKatakanaIroha))
- listStyleID = i->id;
</del><ins>+ if (argument->id == CSSValueNone || (argument->id >= CSSValueDisc && argument->id <= CSSValueKatakanaIroha))
+ listStyleID = argument->id;
</ins><span class="cx"> else
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> listStyle = cssValuePool().createIdentifierValue(listStyleID);
</span><span class="cx"> }
</span><span class="lines">@@ -5733,10 +5728,10 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseClipShape(CSSPropertyID propId, bool important)
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx">
</span><del>- if (!equalIgnoringCase(value->function->name, "rect(") || !args)
</del><ins>+ if (!equalIgnoringCase(value.function->name, "rect(") || !args)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // rect(t, r, b, l) || rect(t r b l)
</span><span class="lines">@@ -5745,14 +5740,12 @@
</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* a = args->current();
- while (a) {
- valid = a->id == CSSValueAuto || validUnit(a, FLength);
</del><ins>+ CSSParserValue* currentValue = args->current();
+ while (currentValue) {
+ valid = currentValue->id == CSSValueAuto || validUnit(*currentValue, FLength);
</ins><span class="cx"> if (!valid)
</span><span class="cx"> break;
</span><del>- RefPtr<CSSPrimitiveValue> length = a->id == CSSValueAuto ?
- cssValuePool().createIdentifierValue(CSSValueAuto) :
- createPrimitiveNumericValue(a);
</del><ins>+ RefPtr<CSSPrimitiveValue> length = currentValue->id == CSSValueAuto ? cssValuePool().createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(*currentValue);
</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">@@ -5761,10 +5754,10 @@
</span><span class="cx"> rect->setBottom(length);
</span><span class="cx"> else
</span><span class="cx"> rect->setLeft(length);
</span><del>- a = args->next();
- if (a && args->size() == 7) {
- if (a->unit == CSSParserValue::Operator && a->iValue == ',') {
- a = args->next();
</del><ins>+ currentValue = args->next();
+ if (currentValue && args->size() == 7) {
+ if (currentValue->unit == CSSParserValue::Operator && currentValue->iValue == ',') {
+ currentValue = args->next();
</ins><span class="cx"> } else {
</span><span class="cx"> valid = false;
</span><span class="cx"> break;
</span><span class="lines">@@ -5794,9 +5787,9 @@
</span><span class="cx">
</span><span class="cx"> // FIXME: This should be refactored with CSSParser::parseBorderRadius.
</span><span class="cx"> // CSSParser::parseBorderRadius contains support for some legacy radius construction.
</span><del>-PassRefPtr<CSSBasicShape> CSSParser::parseInsetRoundedCorners(PassRefPtr<CSSBasicShapeInset> shape, CSSParserValueList* args)
</del><ins>+PassRefPtr<CSSBasicShape> CSSParser::parseInsetRoundedCorners(PassRefPtr<CSSBasicShapeInset> shape, CSSParserValueList& args)
</ins><span class="cx"> {
</span><del>- CSSParserValue* argument = args->next();
</del><ins>+ CSSParserValue* argument = args.next();
</ins><span class="cx">
</span><span class="cx"> if (!argument)
</span><span class="cx"> return nullptr;
</span><span class="lines">@@ -5804,7 +5797,7 @@
</span><span class="cx"> Vector<CSSParserValue*> radiusArguments;
</span><span class="cx"> while (argument) {
</span><span class="cx"> radiusArguments.append(argument);
</span><del>- argument = args->next();
</del><ins>+ argument = args.next();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> unsigned num = radiusArguments.size();
</span><span class="lines">@@ -5815,9 +5808,9 @@
</span><span class="cx">
</span><span class="cx"> unsigned indexAfterSlash = 0;
</span><span class="cx"> for (unsigned i = 0; i < num; ++i) {
</span><del>- CSSParserValue* value = radiusArguments.at(i);
- if (value->unit == CSSParserValue::Operator) {
- if (value->iValue != '/')
</del><ins>+ CSSParserValue& value = *radiusArguments.at(i);
+ if (value.unit == CSSParserValue::Operator) {
+ if (value.iValue != '/')
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> if (!i || indexAfterSlash || i + 1 == num || num > i + 5)
</span><span class="lines">@@ -5857,13 +5850,11 @@
</span><span class="cx"> return shape;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeInset(CSSParserValueList* args)
</del><ins>+PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeInset(CSSParserValueList& args)
</ins><span class="cx"> {
</span><del>- ASSERT(args);
-
</del><span class="cx"> RefPtr<CSSBasicShapeInset> shape = CSSBasicShapeInset::create();
</span><span class="cx">
</span><del>- CSSParserValue* argument = args->current();
</del><ins>+ CSSParserValue* argument = args.current();
</ins><span class="cx"> Vector<RefPtr<CSSPrimitiveValue> > widthArguments;
</span><span class="cx"> bool hasRoundedInset = false;
</span><span class="cx"> while (argument) {
</span><span class="lines">@@ -5873,11 +5864,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>+ if (!validUnit(*argument, unitFlags) || widthArguments.size() > 4)
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- widthArguments.append(createPrimitiveNumericValue(argument));
- argument = args->next();
</del><ins>+ widthArguments.append(createPrimitiveNumericValue(*argument));
+ argument = args.next();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> switch (widthArguments.size()) {
</span><span class="lines">@@ -5906,36 +5897,34 @@
</span><span class="cx"> return shape;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSPrimitiveValue> CSSParser::parseShapeRadius(CSSParserValue* value)
</del><ins>+PassRefPtr<CSSPrimitiveValue> CSSParser::parseShapeRadius(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide)
- return cssValuePool().createIdentifierValue(value->id);
</del><ins>+ if (value.id == CSSValueClosestSide || value.id == CSSValueFarthestSide)
+ return cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx">
</span><span class="cx"> if (!validUnit(value, FLength | FPercent | FNonNeg))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> return createPrimitiveNumericValue(value);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeCircle(CSSParserValueList* args)
</del><ins>+PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeCircle(CSSParserValueList& args)
</ins><span class="cx"> {
</span><del>- ASSERT(args);
-
</del><span class="cx"> // circle(radius)
</span><span class="cx"> // circle(radius at <position>)
</span><span class="cx"> // circle(at <position>)
</span><span class="cx"> // where position defines centerX and centerY using a CSS <position> data type.
</span><span class="cx"> RefPtr<CSSBasicShapeCircle> shape = CSSBasicShapeCircle::create();
</span><span class="cx">
</span><del>- for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {
</del><ins>+ for (CSSParserValue* argument = args.current(); argument; argument = args.next()) {
</ins><span class="cx"> // The call to parseFillPosition below should consume all of the
</span><span class="cx"> // arguments except the first two. Thus, and index greater than one
</span><span class="cx"> // indicates an invalid production.
</span><del>- if (args->currentIndex() > 1)
</del><ins>+ if (args.currentIndex() > 1)
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- if (!args->currentIndex() && argument->id != CSSValueAt) {
- if (RefPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
</del><ins>+ if (!args.currentIndex() && argument->id != CSSValueAt) {
+ if (RefPtr<CSSPrimitiveValue> radius = parseShapeRadius(*argument)) {
</ins><span class="cx"> shape->setRadius(radius);
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="lines">@@ -5943,11 +5932,11 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (argument->id == CSSValueAt && args->next()) {
</del><ins>+ if (argument->id == CSSValueAt && args.next()) {
</ins><span class="cx"> RefPtr<CSSValue> centerX;
</span><span class="cx"> RefPtr<CSSValue> centerY;
</span><span class="cx"> parseFillPosition(args, centerX, centerY);
</span><del>- if (centerX && centerY && !args->current()) {
</del><ins>+ if (centerX && centerY && !args.current()) {
</ins><span class="cx"> shape->setCenterX(downcast<CSSPrimitiveValue>(centerX.get()));
</span><span class="cx"> shape->setCenterY(downcast<CSSPrimitiveValue>(centerY.get()));
</span><span class="cx"> } else
</span><span class="lines">@@ -5959,10 +5948,8 @@
</span><span class="cx"> return shape;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeEllipse(CSSParserValueList* args)
</del><ins>+PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapeEllipse(CSSParserValueList& args)
</ins><span class="cx"> {
</span><del>- ASSERT(args);
-
</del><span class="cx"> // ellipse(radiusX)
</span><span class="cx"> // ellipse(radiusX at <position>)
</span><span class="cx"> // ellipse(radiusX radiusY)
</span><span class="lines">@@ -5971,15 +5958,15 @@
</span><span class="cx"> // where position defines centerX and centerY using a CSS <position> data type.
</span><span class="cx"> RefPtr<CSSBasicShapeEllipse> shape = CSSBasicShapeEllipse::create();
</span><span class="cx">
</span><del>- for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {
</del><ins>+ for (CSSParserValue* argument = args.current(); argument; argument = args.next()) {
</ins><span class="cx"> // The call to parseFillPosition below should consume all of the
</span><span class="cx"> // arguments except the first three. Thus, an index greater than two
</span><span class="cx"> // indicates an invalid production.
</span><del>- if (args->currentIndex() > 2)
</del><ins>+ if (args.currentIndex() > 2)
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- if (args->currentIndex() < 2 && argument->id != CSSValueAt) {
- if (RefPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
</del><ins>+ if (args.currentIndex() < 2 && argument->id != CSSValueAt) {
+ if (RefPtr<CSSPrimitiveValue> radius = parseShapeRadius(*argument)) {
</ins><span class="cx"> if (!shape->radiusX())
</span><span class="cx"> shape->setRadiusX(radius);
</span><span class="cx"> else
</span><span class="lines">@@ -5990,13 +5977,13 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (argument->id != CSSValueAt || !args->next()) // expecting ellipse(.. at <position>)
</del><ins>+ if (argument->id != CSSValueAt || !args.next()) // expecting ellipse(.. at <position>)
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSValue> centerX;
</span><span class="cx"> RefPtr<CSSValue> centerY;
</span><span class="cx"> parseFillPosition(args, centerX, centerY);
</span><del>- if (!centerX || !centerY || args->current())
</del><ins>+ if (!centerX || !centerY || args.current())
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> shape->setCenterX(downcast<CSSPrimitiveValue>(centerX.get()));
</span><span class="lines">@@ -6006,52 +5993,50 @@
</span><span class="cx"> return shape;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapePolygon(CSSParserValueList* args)
</del><ins>+PassRefPtr<CSSBasicShape> CSSParser::parseBasicShapePolygon(CSSParserValueList& args)
</ins><span class="cx"> {
</span><del>- ASSERT(args);
-
- unsigned size = args->size();
</del><ins>+ unsigned size = args.size();
</ins><span class="cx"> if (!size)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::create();
</span><span class="cx">
</span><del>- CSSParserValue* argument = args->current();
</del><ins>+ CSSParserValue* argument = args.current();
</ins><span class="cx"> if (argument->id == CSSValueEvenodd || argument->id == CSSValueNonzero) {
</span><span class="cx"> shape->setWindRule(argument->id == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO);
</span><span class="cx">
</span><del>- if (!isComma(args->next()))
- return 0;
</del><ins>+ if (!isComma(args.next()))
+ return nullptr;
</ins><span class="cx">
</span><del>- argument = args->next();
</del><ins>+ argument = args.next();
</ins><span class="cx"> size -= 2;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // <length> <length>, ... <length> <length> -> each pair has 3 elements except the last one
</span><span class="cx"> if (!size || (size % 3) - 2)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> CSSParserValue* argumentX = argument;
</span><span class="cx"> while (argumentX) {
</span><span class="cx">
</span><del>- if (!validUnit(argumentX, FLength | FPercent))
- return 0;
- RefPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(argumentX);
</del><ins>+ if (!validUnit(*argumentX, FLength | FPercent))
+ return nullptr;
+ RefPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(*argumentX);
</ins><span class="cx">
</span><del>- CSSParserValue* argumentY = args->next();
- if (!argumentY || !validUnit(argumentY, FLength | FPercent))
- return 0;
- RefPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(argumentY);
</del><ins>+ CSSParserValue* argumentY = args.next();
+ if (!argumentY || !validUnit(*argumentY, FLength | FPercent))
+ return nullptr;
+ RefPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(*argumentY);
</ins><span class="cx">
</span><span class="cx"> shape->appendPoint(xLength.release(), yLength.release());
</span><span class="cx">
</span><del>- CSSParserValue* commaOrNull = args->next();
</del><ins>+ CSSParserValue* commaOrNull = args.next();
</ins><span class="cx"> if (!commaOrNull)
</span><del>- argumentX = 0;
</del><ins>+ argumentX = nullptr;
</ins><span class="cx"> else if (!isComma(commaOrNull))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> else
</span><del>- argumentX = args->next();
</del><ins>+ argumentX = args.next();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return shape;
</span><span class="lines">@@ -6096,7 +6081,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 = parseValidPrimitive(valueId, *value);
</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">@@ -6116,8 +6101,8 @@
</span><span class="cx"> if (!RuntimeEnabledFeatures::sharedFeatures().cssShapesEnabled())
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><del>- CSSParserValue* value = m_valueList->current();
- CSSValueID valueId = value->id;
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ CSSValueID valueId = value.id;
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> keywordValue;
</span><span class="cx"> RefPtr<CSSPrimitiveValue> shapeValue;
</span><span class="cx">
</span><span class="lines">@@ -6128,7 +6113,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSValue> imageValue;
</span><del>- if (valueId != CSSValueNone && parseFillImage(m_valueList.get(), imageValue)) {
</del><ins>+ if (valueId != CSSValueNone && parseFillImage(*m_valueList, imageValue)) {
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> return imageValue.release();
</span><span class="cx"> }
</span><span class="lines">@@ -6139,16 +6124,16 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseClipPath()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- CSSValueID valueId = value->id;
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ CSSValueID valueId = value.id;
</ins><span class="cx">
</span><span class="cx"> if (valueId == CSSValueNone) {
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> return parseValidPrimitive(valueId, value);
</span><span class="cx"> }
</span><del>- if (value->unit == CSSPrimitiveValue::CSS_URI) {
</del><ins>+ if (value.unit == CSSPrimitiveValue::CSS_URI) {
</ins><span class="cx"> m_valueList->next();
</span><del>- return CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
</del><ins>+ return CSSPrimitiveValue::create(value.string, CSSPrimitiveValue::CSS_URI);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return parseBasicShapeAndOrBox(CSSPropertyWebkitClipPath);
</span><span class="lines">@@ -6156,22 +6141,22 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSPrimitiveValue> CSSParser::parseBasicShape()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- ASSERT(value->unit == CSSParserValue::Function);
- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ ASSERT(value.unit == CSSParserValue::Function);
+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx">
</span><span class="cx"> if (!args)
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSBasicShape> shape;
</span><del>- if (equalIgnoringCase(value->function->name, "circle("))
- shape = parseBasicShapeCircle(args);
- else if (equalIgnoringCase(value->function->name, "ellipse("))
- shape = parseBasicShapeEllipse(args);
- else if (equalIgnoringCase(value->function->name, "polygon("))
- shape = parseBasicShapePolygon(args);
- else if (equalIgnoringCase(value->function->name, "inset("))
- shape = parseBasicShapeInset(args);
</del><ins>+ if (equalIgnoringCase(value.function->name, "circle("))
+ shape = parseBasicShapeCircle(*args);
+ else if (equalIgnoringCase(value.function->name, "ellipse("))
+ shape = parseBasicShapeEllipse(*args);
+ else if (equalIgnoringCase(value.function->name, "polygon("))
+ shape = parseBasicShapePolygon(*args);
+ else if (equalIgnoringCase(value.function->name, "inset("))
+ shape = parseBasicShapeInset(*args);
</ins><span class="cx">
</span><span class="cx"> if (!shape)
</span><span class="cx"> return nullptr;
</span><span class="lines">@@ -6229,7 +6214,7 @@
</span><span class="cx"> if (!value)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (isForwardSlashOperator(value)) {
</del><ins>+ if (isForwardSlashOperator(*value)) {
</ins><span class="cx"> // The line-height property.
</span><span class="cx"> value = m_valueList->next();
</span><span class="cx"> if (!value)
</span><span class="lines">@@ -6257,7 +6242,7 @@
</span><span class="cx">
</span><span class="cx"> class FontFamilyValueBuilder {
</span><span class="cx"> public:
</span><del>- FontFamilyValueBuilder(CSSValueList* list)
</del><ins>+ FontFamilyValueBuilder(CSSValueList& list)
</ins><span class="cx"> : m_list(list)
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="lines">@@ -6279,13 +6264,13 @@
</span><span class="cx"> {
</span><span class="cx"> if (m_builder.isEmpty())
</span><span class="cx"> return;
</span><del>- m_list->append(cssValuePool().createFontFamilyValue(m_builder.toString()));
</del><ins>+ m_list.append(cssValuePool().createFontFamilyValue(m_builder.toString()));
</ins><span class="cx"> m_builder.clear();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> StringBuilder m_builder;
</span><del>- CSSValueList* m_list;
</del><ins>+ CSSValueList& m_list;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValueList> CSSParser::parseFontFamily()
</span><span class="lines">@@ -6293,7 +6278,7 @@
</span><span class="cx"> RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
</span><span class="cx"> CSSParserValue* value = m_valueList->current();
</span><span class="cx">
</span><del>- FontFamilyValueBuilder familyBuilder(list.get());
</del><ins>+ FontFamilyValueBuilder familyBuilder(*list);
</ins><span class="cx"> bool inFamily = false;
</span><span class="cx">
</span><span class="cx"> while (value) {
</span><span class="lines">@@ -6358,14 +6343,14 @@
</span><span class="cx"> familyBuilder.commit();
</span><span class="cx">
</span><span class="cx"> if (!list->length())
</span><del>- list = 0;
</del><ins>+ list = nullptr;
</ins><span class="cx"> return list.release();
</span><span class="cx"> }
</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>+ CSSParserValue& value = *m_valueList->current();
+ CSSValueID id = 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="lines">@@ -6379,8 +6364,8 @@
</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>+ CSSParserValue& value = *m_valueList->current();
+ CSSValueID id = 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="lines">@@ -6454,7 +6439,7 @@
</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)) {
</del><ins>+ if (validUnit(value, FInteger | FNonNeg, CSSQuirksMode)) {
</ins><span class="cx"> int weight = static_cast<int>(parsedDouble(value, ReleaseParsedCalcValue));
</span><span class="cx"> if (!(weight % 100) && weight >= 100 && weight <= 900) {
</span><span class="cx"> addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(createFontWeightValueKeyword(weight)), important);
</span><span class="lines">@@ -6464,18 +6449,18 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFontFaceSrcURI(CSSValueList* valueList)
</del><ins>+bool CSSParser::parseFontFaceSrcURI(CSSValueList& valueList)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(m_valueList->current()->string)));
</span><span class="cx">
</span><span class="cx"> CSSParserValue* value = m_valueList->next();
</span><span class="cx"> if (!value) {
</span><del>- valueList->append(uriValue.releaseNonNull());
</del><ins>+ valueList.append(uriValue.releaseNonNull());
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> if (value->unit == CSSParserValue::Operator && value->iValue == ',') {
</span><span class="cx"> m_valueList->next();
</span><del>- valueList->append(uriValue.releaseNonNull());
</del><ins>+ valueList.append(uriValue.releaseNonNull());
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -6488,21 +6473,21 @@
</span><span class="cx"> if (!args || args->size() != 1 || (args->current()->unit != CSSPrimitiveValue::CSS_STRING && args->current()->unit != CSSPrimitiveValue::CSS_IDENT))
</span><span class="cx"> return false;
</span><span class="cx"> uriValue->setFormat(args->current()->string);
</span><del>- valueList->append(uriValue.releaseNonNull());
</del><ins>+ valueList.append(uriValue.releaseNonNull());
</ins><span class="cx"> value = m_valueList->next();
</span><span class="cx"> if (value && value->unit == CSSParserValue::Operator && value->iValue == ',')
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFontFaceSrcLocal(CSSValueList* valueList)
</del><ins>+bool CSSParser::parseFontFaceSrcLocal(CSSValueList& valueList)
</ins><span class="cx"> {
</span><span class="cx"> CSSParserValueList* args = m_valueList->current()->function->args.get();
</span><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (args->size() == 1 && args->current()->unit == CSSPrimitiveValue::CSS_STRING)
</span><del>- valueList->append(CSSFontFaceSrcValue::createLocal(args->current()->string));
</del><ins>+ valueList.append(CSSFontFaceSrcValue::createLocal(args->current()->string));
</ins><span class="cx"> else if (args->current()->unit == CSSPrimitiveValue::CSS_IDENT) {
</span><span class="cx"> StringBuilder builder;
</span><span class="cx"> for (CSSParserValue* localValue = args->current(); localValue; localValue = args->next()) {
</span><span class="lines">@@ -6512,7 +6497,7 @@
</span><span class="cx"> builder.append(' ');
</span><span class="cx"> builder.append(localValue->string);
</span><span class="cx"> }
</span><del>- valueList->append(CSSFontFaceSrcValue::createLocal(builder.toString()));
</del><ins>+ valueList.append(CSSFontFaceSrcValue::createLocal(builder.toString()));
</ins><span class="cx"> } else
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -6529,10 +6514,10 @@
</span><span class="cx">
</span><span class="cx"> while (CSSParserValue* value = m_valueList->current()) {
</span><span class="cx"> if (value->unit == CSSPrimitiveValue::CSS_URI) {
</span><del>- if (!parseFontFaceSrcURI(values.get()))
</del><ins>+ if (!parseFontFaceSrcURI(*values))
</ins><span class="cx"> return false;
</span><span class="cx"> } else if (value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "local(")) {
</span><del>- if (!parseFontFaceSrcLocal(values.get()))
</del><ins>+ if (!parseFontFaceSrcLocal(*values))
</ins><span class="cx"> return false;
</span><span class="cx"> } else
</span><span class="cx"> return false;
</span><span class="lines">@@ -6958,13 +6943,13 @@
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::isCalculation(CSSParserValue* value)
</del><ins>+bool CSSParser::isCalculation(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- return (value->unit == CSSParserValue::Function)
- && (equalIgnoringCase(value->function->name, "calc(")
- || equalIgnoringCase(value->function->name, "-webkit-calc(")
- || equalIgnoringCase(value->function->name, "-webkit-min(")
- || equalIgnoringCase(value->function->name, "-webkit-max("));
</del><ins>+ return (value.unit == CSSParserValue::Function)
+ && (equalIgnoringCase(value.function->name, "calc(")
+ || equalIgnoringCase(value.function->name, "-webkit-calc(")
+ || equalIgnoringCase(value.function->name, "-webkit-min(")
+ || equalIgnoringCase(value.function->name, "-webkit-max("));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline int CSSParser::colorIntFromValue(CSSParserValue& value)
</span><span class="lines">@@ -6993,15 +6978,15 @@
</span><span class="cx"> return static_cast<int>(doubleValue);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseColorParameters(CSSParserValue* value, int* colorArray, bool parseAlpha)
</del><ins>+bool CSSParser::parseColorParameters(CSSParserValue& value, int* colorArray, bool parseAlpha)
</ins><span class="cx"> {
</span><del>- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx"> CSSParserValue* currentValue = args->current();
</span><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 (validUnit(*currentValue, FInteger, CSSStrictMode))
</ins><span class="cx"> unitType = FInteger;
</span><del>- else if (validUnit(currentValue, FPercent, CSSStrictMode))
</del><ins>+ else if (validUnit(*currentValue, FPercent, CSSStrictMode))
</ins><span class="cx"> unitType = FPercent;
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="lines">@@ -7012,7 +6997,7 @@
</span><span class="cx"> if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</span><span class="cx"> return false;
</span><span class="cx"> currentValue = args->next();
</span><del>- if (!validUnit(currentValue, unitType, CSSStrictMode))
</del><ins>+ if (!validUnit(*currentValue, unitType, CSSStrictMode))
</ins><span class="cx"> return false;
</span><span class="cx"> colorArray[i] = colorIntFromValue(*currentValue);
</span><span class="cx"> }
</span><span class="lines">@@ -7021,7 +7006,7 @@
</span><span class="cx"> if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</span><span class="cx"> return false;
</span><span class="cx"> currentValue = args->next();
</span><del>- if (!validUnit(currentValue, FNumber, CSSStrictMode))
</del><ins>+ if (!validUnit(*currentValue, FNumber, CSSStrictMode))
</ins><span class="cx"> return false;
</span><span class="cx"> double doubleValue = parsedDouble(*currentValue, ReleaseParsedCalcValue);
</span><span class="cx"> // Convert the floating pointer number of alpha to an integer in the range [0, 256),
</span><span class="lines">@@ -7036,12 +7021,12 @@
</span><span class="cx"> // and with alpha, the format is
</span><span class="cx"> // hsla(<number>, <percent>, <percent>, <number>)
</span><span class="cx"> // The first value, HUE, is in an angle with a value between 0 and 360
</span><del>-bool CSSParser::parseHSLParameters(CSSParserValue* value, double* colorArray, bool parseAlpha)
</del><ins>+bool CSSParser::parseHSLParameters(CSSParserValue& value, double* colorArray, bool parseAlpha)
</ins><span class="cx"> {
</span><del>- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx"> CSSParserValue* currentValue = args->current();
</span><span class="cx"> // Get the first value
</span><del>- if (!validUnit(currentValue, FNumber, CSSStrictMode))
</del><ins>+ if (!validUnit(*currentValue, 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><span class="cx"> colorArray[0] = (((static_cast<int>(parsedDouble(*currentValue, ReleaseParsedCalcValue)) % 360) + 360) % 360) / 360.0;
</span><span class="lines">@@ -7050,7 +7035,7 @@
</span><span class="cx"> if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</span><span class="cx"> return false;
</span><span class="cx"> currentValue = args->next();
</span><del>- if (!validUnit(currentValue, FPercent, CSSStrictMode))
</del><ins>+ if (!validUnit(*currentValue, FPercent, CSSStrictMode))
</ins><span class="cx"> return false;
</span><span class="cx"> colorArray[i] = std::max<double>(0, std::min<double>(100, parsedDouble(*currentValue, ReleaseParsedCalcValue))) / 100.0; // needs to be value between 0 and 1.0
</span><span class="cx"> }
</span><span class="lines">@@ -7059,7 +7044,7 @@
</span><span class="cx"> if (currentValue->unit != CSSParserValue::Operator && currentValue->iValue != ',')
</span><span class="cx"> return false;
</span><span class="cx"> currentValue = args->next();
</span><del>- if (!validUnit(currentValue, FNumber, CSSStrictMode))
</del><ins>+ if (!validUnit(*currentValue, FNumber, CSSStrictMode))
</ins><span class="cx"> return false;
</span><span class="cx"> colorArray[3] = std::max<double>(0, std::min<double>(1, parsedDouble(*currentValue, ReleaseParsedCalcValue)));
</span><span class="cx"> }
</span><span class="lines">@@ -7069,53 +7054,53 @@
</span><span class="cx"> PassRefPtr<CSSPrimitiveValue> CSSParser::parseColor(CSSParserValue* value)
</span><span class="cx"> {
</span><span class="cx"> RGBA32 c = Color::transparent;
</span><del>- if (!parseColorFromValue(value ? value : m_valueList->current(), c))
- return 0;
</del><ins>+ if (!parseColorFromValue(value ? *value : *m_valueList->current(), c))
+ return nullptr;
</ins><span class="cx"> return cssValuePool().createColorValue(c);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseColorFromValue(CSSParserValue* value, RGBA32& c)
</del><ins>+bool CSSParser::parseColorFromValue(CSSParserValue& value, RGBA32& c)
</ins><span class="cx"> {
</span><del>- if (inQuirksMode() && value->unit == CSSPrimitiveValue::CSS_NUMBER
- && value->fValue >= 0. && value->fValue < 1000000.) {
- String str = String::format("%06d", static_cast<int>((value->fValue+.5)));
</del><ins>+ if (inQuirksMode() && value.unit == CSSPrimitiveValue::CSS_NUMBER
+ && value.fValue >= 0. && value.fValue < 1000000.) {
+ String str = String::format("%06d", static_cast<int>((value.fValue+.5)));
</ins><span class="cx"> // FIXME: This should be strict parsing for SVG as well.
</span><span class="cx"> if (!fastParseColor(c, str, inStrictMode()))
</span><span class="cx"> return false;
</span><del>- } else if (value->unit == CSSPrimitiveValue::CSS_PARSER_HEXCOLOR ||
- value->unit == CSSPrimitiveValue::CSS_IDENT ||
- (inQuirksMode() && value->unit == CSSPrimitiveValue::CSS_DIMENSION)) {
- if (!fastParseColor(c, value->string, inStrictMode() && value->unit == CSSPrimitiveValue::CSS_IDENT))
</del><ins>+ } else if (value.unit == CSSPrimitiveValue::CSS_PARSER_HEXCOLOR
+ || value.unit == CSSPrimitiveValue::CSS_IDENT
+ || (inQuirksMode() && value.unit == CSSPrimitiveValue::CSS_DIMENSION)) {
+ if (!fastParseColor(c, value.string, inStrictMode() && value.unit == CSSPrimitiveValue::CSS_IDENT))
</ins><span class="cx"> return false;
</span><del>- } else if (value->unit == CSSParserValue::Function &&
- value->function->args != 0 &&
- value->function->args->size() == 5 /* rgb + two commas */ &&
- equalIgnoringCase(value->function->name, "rgb(")) {
</del><ins>+ } else if (value.unit == CSSParserValue::Function
+ && value.function->args
+ && value.function->args->size() == 5 /* rgb + two commas */
+ && equalIgnoringCase(value.function->name, "rgb(")) {
</ins><span class="cx"> int colorValues[3];
</span><span class="cx"> if (!parseColorParameters(value, colorValues, false))
</span><span class="cx"> return false;
</span><span class="cx"> c = makeRGB(colorValues[0], colorValues[1], colorValues[2]);
</span><span class="cx"> } else {
</span><del>- if (value->unit == CSSParserValue::Function &&
- value->function->args != 0 &&
- value->function->args->size() == 7 /* rgba + three commas */ &&
- equalIgnoringCase(value->function->name, "rgba(")) {
</del><ins>+ if (value.unit == CSSParserValue::Function
+ && value.function->args
+ && value.function->args->size() == 7 /* rgba + three commas */
+ && equalIgnoringCase(value.function->name, "rgba(")) {
</ins><span class="cx"> int colorValues[4];
</span><span class="cx"> if (!parseColorParameters(value, colorValues, true))
</span><span class="cx"> return false;
</span><span class="cx"> c = makeRGBA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
</span><del>- } else if (value->unit == CSSParserValue::Function &&
- value->function->args != 0 &&
- value->function->args->size() == 5 /* hsl + two commas */ &&
- equalIgnoringCase(value->function->name, "hsl(")) {
</del><ins>+ } else if (value.unit == CSSParserValue::Function
+ && value.function->args
+ && value.function->args->size() == 5 /* hsl + two commas */
+ && equalIgnoringCase(value.function->name, "hsl(")) {
</ins><span class="cx"> double colorValues[3];
</span><span class="cx"> if (!parseHSLParameters(value, colorValues, false))
</span><span class="cx"> return false;
</span><span class="cx"> c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], 1.0);
</span><del>- } else if (value->unit == CSSParserValue::Function &&
- value->function->args != 0 &&
- value->function->args->size() == 7 /* hsla + three commas */ &&
- equalIgnoringCase(value->function->name, "hsla(")) {
</del><ins>+ } else if (value.unit == CSSParserValue::Function
+ && value.function->args
+ && value.function->args->size() == 7 /* hsla + three commas */
+ && equalIgnoringCase(value.function->name, "hsla(")) {
</ins><span class="cx"> double colorValues[4];
</span><span class="cx"> if (!parseHSLParameters(value, colorValues, true))
</span><span class="cx"> return false;
</span><span class="lines">@@ -7130,7 +7115,7 @@
</span><span class="cx"> // This class tracks parsing state for shadow values. If it goes out of scope (e.g., due to an early return)
</span><span class="cx"> // without the allowBreak bit being set, then it will clean up all of the objects and destroy them.
</span><span class="cx"> struct ShadowParseContext {
</span><del>- ShadowParseContext(CSSPropertyID prop, CSSParser* parser)
</del><ins>+ ShadowParseContext(CSSPropertyID prop, CSSParser& parser)
</ins><span class="cx"> : property(prop)
</span><span class="cx"> , m_parser(parser)
</span><span class="cx"> , allowX(true)
</span><span class="lines">@@ -7159,10 +7144,10 @@
</span><span class="cx"> // Now reset for the next shadow value.
</span><span class="cx"> x = 0;
</span><span class="cx"> y = 0;
</span><del>- blur = 0;
- spread = 0;
- style = 0;
- color = 0;
</del><ins>+ blur = nullptr;
+ spread = nullptr;
+ style = nullptr;
+ color = nullptr;
</ins><span class="cx">
</span><span class="cx"> allowX = true;
</span><span class="cx"> allowColor = true;
</span><span class="lines">@@ -7173,30 +7158,30 @@
</span><span class="cx"> allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void commitLength(CSSParserValue* v)
</del><ins>+ void commitLength(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- RefPtr<CSSPrimitiveValue> val = m_parser->createPrimitiveNumericValue(v);
</del><ins>+ RefPtr<CSSPrimitiveValue> primitiveValue = m_parser.createPrimitiveNumericValue(value);
</ins><span class="cx">
</span><span class="cx"> if (allowX) {
</span><del>- x = val.release();
</del><ins>+ x = primitiveValue.release();
</ins><span class="cx"> allowX = false;
</span><span class="cx"> allowY = true;
</span><span class="cx"> allowColor = false;
</span><span class="cx"> allowStyle = false;
</span><span class="cx"> allowBreak = false;
</span><span class="cx"> } else if (allowY) {
</span><del>- y = val.release();
</del><ins>+ y = primitiveValue.release();
</ins><span class="cx"> allowY = false;
</span><span class="cx"> allowBlur = true;
</span><span class="cx"> allowColor = true;
</span><span class="cx"> allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
</span><span class="cx"> allowBreak = true;
</span><span class="cx"> } else if (allowBlur) {
</span><del>- blur = val.release();
</del><ins>+ blur = primitiveValue.release();
</ins><span class="cx"> allowBlur = false;
</span><span class="cx"> allowSpread = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
</span><span class="cx"> } else if (allowSpread) {
</span><del>- spread = val.release();
</del><ins>+ spread = primitiveValue.release();
</ins><span class="cx"> allowSpread = false;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -7215,9 +7200,9 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void commitStyle(CSSParserValue* v)
</del><ins>+ void commitStyle(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- style = cssValuePool().createIdentifierValue(v->id);
</del><ins>+ style = cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx"> allowStyle = false;
</span><span class="cx"> if (allowX)
</span><span class="cx"> allowBreak = false;
</span><span class="lines">@@ -7229,7 +7214,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> CSSPropertyID property;
</span><del>- CSSParser* m_parser;
</del><ins>+ CSSParser& m_parser;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSValueList> values;
</span><span class="cx"> RefPtr<CSSPrimitiveValue> x;
</span><span class="lines">@@ -7248,62 +7233,63 @@
</span><span class="cx"> bool allowBreak;
</span><span class="cx"> };
</span><span class="cx">
</span><del>-PassRefPtr<CSSValueList> CSSParser::parseShadow(CSSParserValueList* valueList, CSSPropertyID propId)
</del><ins>+PassRefPtr<CSSValueList> CSSParser::parseShadow(CSSParserValueList& valueList, CSSPropertyID propId)
</ins><span class="cx"> {
</span><del>- ShadowParseContext context(propId, this);
- CSSParserValue* val;
- while ((val = valueList->current())) {
</del><ins>+ ShadowParseContext context(propId, *this);
+ CSSParserValue* value;
+ while ((value = valueList.current())) {
</ins><span class="cx"> // Check for a comma break first.
</span><del>- if (val->unit == CSSParserValue::Operator) {
- if (val->iValue != ',' || !context.allowBreak)
</del><ins>+ if (value->unit == CSSParserValue::Operator) {
+ if (value->iValue != ',' || !context.allowBreak) {
</ins><span class="cx"> // Other operators aren't legal or we aren't done with the current shadow
</span><span class="cx"> // value. Treat as invalid.
</span><del>- return 0;
</del><ins>+ return nullptr;
+ }
</ins><span class="cx"> // -webkit-svg-shadow does not support multiple values.
</span><span class="cx"> if (propId == CSSPropertyWebkitSvgShadow)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> // The value is good. Commit it.
</span><span class="cx"> context.commitValue();
</span><del>- } else if (validUnit(val, FLength, CSSStrictMode)) {
</del><ins>+ } else if (validUnit(*value, FLength, CSSStrictMode)) {
</ins><span class="cx"> // We required a length and didn't get one. Invalid.
</span><span class="cx"> if (!context.allowLength())
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // Blur radius must be non-negative.
</span><del>- if (context.allowBlur && !validUnit(val, FLength | FNonNeg, CSSStrictMode))
- return 0;
</del><ins>+ if (context.allowBlur && !validUnit(*value, FLength | FNonNeg, CSSStrictMode))
+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // A length is allowed here. Construct the value and add it.
</span><del>- context.commitLength(val);
- } else if (val->id == CSSValueInset) {
</del><ins>+ context.commitLength(*value);
+ } else if (value->id == CSSValueInset) {
</ins><span class="cx"> if (!context.allowStyle)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- context.commitStyle(val);
</del><ins>+ context.commitStyle(*value);
</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><del>- bool isColor = ((val->id >= CSSValueAqua && val->id <= CSSValueWindowtext) || val->id == CSSValueMenu
- || (val->id >= CSSValueWebkitFocusRingColor && val->id <= CSSValueWebkitText && inQuirksMode())
- || val->id == CSSValueCurrentcolor);
</del><ins>+ bool isColor = ((value->id >= CSSValueAqua && value->id <= CSSValueWindowtext) || value->id == CSSValueMenu
+ || (value->id >= CSSValueWebkitFocusRingColor && value->id <= CSSValueWebkitText && inQuirksMode())
+ || value->id == CSSValueCurrentcolor);
</ins><span class="cx"> if (isColor) {
</span><span class="cx"> if (!context.allowColor)
</span><del>- return 0;
- parsedColor = cssValuePool().createIdentifierValue(val->id);
</del><ins>+ return nullptr;
+ parsedColor = cssValuePool().createIdentifierValue(value->id);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (!parsedColor)
</span><span class="cx"> // It's not built-in. Try to parse it as a color.
</span><del>- parsedColor = parseColor(val);
</del><ins>+ parsedColor = parseColor(value);
</ins><span class="cx">
</span><span class="cx"> if (!parsedColor || !context.allowColor)
</span><del>- return 0; // This value is not a color or length and is invalid or
</del><ins>+ return nullptr; // This value is not a color or length and is invalid or
</ins><span class="cx"> // it is a color, but a color isn't allowed at this point.
</span><span class="cx">
</span><span class="cx"> context.commitColor(parsedColor.release());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- valueList->next();
</del><ins>+ valueList.next();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (context.allowBreak) {
</span><span class="lines">@@ -7312,7 +7298,7 @@
</span><span class="cx"> return context.values.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseReflect(CSSPropertyID propId, bool important)
</span><span class="lines">@@ -7320,34 +7306,34 @@
</span><span class="cx"> // box-reflect: <direction> <offset> <mask>
</span><span class="cx">
</span><span class="cx"> // Direction comes first.
</span><del>- CSSParserValue* val = m_valueList->current();
</del><ins>+ CSSParserValue* currentValue = m_valueList->current();
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> direction;
</span><del>- switch (val->id) {
</del><ins>+ switch (currentValue->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(val->id);
</del><ins>+ direction = cssValuePool().createIdentifierValue(currentValue->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>- val = m_valueList->next();
</del><ins>+ currentValue = m_valueList->next();
</ins><span class="cx"> RefPtr<CSSPrimitiveValue> offset;
</span><del>- if (!val)
</del><ins>+ if (!currentValue)
</ins><span class="cx"> offset = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
</span><span class="cx"> else {
</span><del>- if (!validUnit(val, FLength | FPercent))
</del><ins>+ if (!validUnit(*currentValue, FLength | FPercent))
</ins><span class="cx"> return false;
</span><del>- offset = createPrimitiveNumericValue(val);
</del><ins>+ offset = createPrimitiveNumericValue(*currentValue);
</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>- val = m_valueList->next();
- if (val) {
</del><ins>+ currentValue = m_valueList->next();
+ if (currentValue) {
</ins><span class="cx"> if (!parseBorderImage(propId, mask))
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="lines">@@ -7357,35 +7343,35 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFlex(CSSParserValueList* args, bool important)
</del><ins>+bool CSSParser::parseFlex(CSSParserValueList& args, bool important)
</ins><span class="cx"> {
</span><del>- if (!args || !args->size() || args->size() > 3)
</del><ins>+ if (!args.size() || args.size() > 3)
</ins><span class="cx"> return false;
</span><span class="cx"> static const double unsetValue = -1;
</span><span class="cx"> double flexGrow = unsetValue;
</span><span class="cx"> double flexShrink = unsetValue;
</span><span class="cx"> RefPtr<CSSPrimitiveValue> flexBasis;
</span><span class="cx">
</span><del>- while (CSSParserValue* arg = args->current()) {
- if (validUnit(arg, FNumber | FNonNeg)) {
</del><ins>+ while (CSSParserValue* argument = args.current()) {
+ if (validUnit(*argument, FNumber | FNonNeg)) {
</ins><span class="cx"> if (flexGrow == unsetValue)
</span><del>- flexGrow = parsedDouble(*arg, ReleaseParsedCalcValue);
</del><ins>+ flexGrow = parsedDouble(*argument, ReleaseParsedCalcValue);
</ins><span class="cx"> else if (flexShrink == unsetValue)
</span><del>- flexShrink = parsedDouble(*arg, ReleaseParsedCalcValue);
- else if (!parsedDouble(*arg, ReleaseParsedCalcValue)) {
</del><ins>+ flexShrink = parsedDouble(*argument, ReleaseParsedCalcValue);
+ else if (!parsedDouble(*argument, ReleaseParsedCalcValue)) {
</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 && (arg->id == CSSValueAuto || validUnit(arg, FLength | FPercent | FNonNeg)))
- flexBasis = parseValidPrimitive(arg->id, arg);
</del><ins>+ } else if (!flexBasis && (argument->id == CSSValueAuto || validUnit(*argument, FLength | FPercent | FNonNeg)))
+ flexBasis = parseValidPrimitive(argument->id, *argument);
</ins><span class="cx"> else {
</span><span class="cx"> // Not a valid arg for flex.
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- args->next();
</del><ins>+ args.next();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (flexGrow == unsetValue)
</span><span class="lines">@@ -7488,7 +7474,7 @@
</span><span class="cx"> return createBorderImageValue(m_image, m_imageSlice, m_borderSlice, m_outset, m_repeat);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void commitBorderImage(CSSParser* parser, bool important)
</del><ins>+ void commitBorderImage(CSSParser& parser, bool important)
</ins><span class="cx"> {
</span><span class="cx"> commitBorderImageProperty(CSSPropertyBorderImageSource, parser, m_image, important);
</span><span class="cx"> commitBorderImageProperty(CSSPropertyBorderImageSlice, parser, m_imageSlice, important);
</span><span class="lines">@@ -7497,12 +7483,12 @@
</span><span class="cx"> commitBorderImageProperty(CSSPropertyBorderImageRepeat, parser, m_repeat, important);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void commitBorderImageProperty(CSSPropertyID propId, CSSParser* parser, PassRefPtr<CSSValue> value, bool important)
</del><ins>+ void commitBorderImageProperty(CSSPropertyID propId, CSSParser& parser, PassRefPtr<CSSValue> value, bool important)
</ins><span class="cx"> {
</span><span class="cx"> if (value)
</span><del>- parser->addProperty(propId, value, important);
</del><ins>+ parser.addProperty(propId, value, important);
</ins><span class="cx"> else
</span><del>- parser->addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
</del><ins>+ parser.addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool m_canAdvance;
</span><span class="lines">@@ -7528,30 +7514,30 @@
</span><span class="cx"> {
</span><span class="cx"> ShorthandScope scope(this, propId);
</span><span class="cx"> BorderImageParseContext context;
</span><del>- while (CSSParserValue* val = m_valueList->current()) {
</del><ins>+ while (CSSParserValue* currentValue = m_valueList->current()) {
</ins><span class="cx"> context.setCanAdvance(false);
</span><span class="cx">
</span><del>- if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
</del><ins>+ if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(*currentValue))
</ins><span class="cx"> context.commitForwardSlashOperator();
</span><span class="cx">
</span><span class="cx"> if (!context.canAdvance() && context.allowImage()) {
</span><del>- if (val->unit == CSSPrimitiveValue::CSS_URI)
- context.commitImage(CSSImageValue::create(completeURL(val->string)));
- else if (isGeneratedImageValue(val)) {
</del><ins>+ if (currentValue->unit == CSSPrimitiveValue::CSS_URI)
+ context.commitImage(CSSImageValue::create(completeURL(currentValue->string)));
+ else if (isGeneratedImageValue(*currentValue)) {
</ins><span class="cx"> RefPtr<CSSValue> value;
</span><del>- if (parseGeneratedImage(m_valueList.get(), value))
</del><ins>+ if (parseGeneratedImage(*m_valueList, value))
</ins><span class="cx"> context.commitImage(value.release());
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="cx"> #if ENABLE(CSS_IMAGE_SET)
</span><del>- } else if (val->unit == CSSParserValue::Function && equalIgnoringCase(val->function->name, "-webkit-image-set(")) {
</del><ins>+ } else if (currentValue->unit == CSSParserValue::Function && equalIgnoringCase(currentValue->function->name, "-webkit-image-set(")) {
</ins><span class="cx"> RefPtr<CSSValue> value = parseImageSet();
</span><span class="cx"> if (value)
</span><span class="cx"> context.commitImage(value.release());
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="cx"> #endif
</span><del>- } else if (val->id == CSSValueNone)
</del><ins>+ } else if (currentValue->id == CSSValueNone)
</ins><span class="cx"> context.commitImage(cssValuePool().createIdentifierValue(CSSValueNone));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -7587,7 +7573,7 @@
</span><span class="cx">
</span><span class="cx"> if (context.allowCommit()) {
</span><span class="cx"> if (propId == CSSPropertyBorderImage)
</span><del>- context.commitBorderImage(this, important);
</del><ins>+ context.commitBorderImage(*this, important);
</ins><span class="cx"> else
</span><span class="cx"> // Need to fully commit as a single value.
</span><span class="cx"> result = context.commitWebKitBorderImage();
</span><span class="lines">@@ -7636,7 +7622,7 @@
</span><span class="cx">
</span><span class="cx"> class BorderImageSliceParseContext {
</span><span class="cx"> public:
</span><del>- BorderImageSliceParseContext(CSSParser* parser)
</del><ins>+ BorderImageSliceParseContext(CSSParser& parser)
</ins><span class="cx"> : m_parser(parser)
</span><span class="cx"> , m_allowNumber(true)
</span><span class="cx"> , m_allowFill(true)
</span><span class="lines">@@ -7649,18 +7635,18 @@
</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* v)
</del><ins>+ void commitNumber(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- RefPtr<CSSPrimitiveValue> val = m_parser->createPrimitiveNumericValue(v);
</del><ins>+ RefPtr<CSSPrimitiveValue> primitiveValue = m_parser.createPrimitiveNumericValue(value);
</ins><span class="cx"> if (!m_top)
</span><del>- m_top = val;
</del><ins>+ m_top = primitiveValue.release();
</ins><span class="cx"> else if (!m_right)
</span><del>- m_right = val;
</del><ins>+ m_right = primitiveValue.release();
</ins><span class="cx"> else if (!m_bottom)
</span><del>- m_bottom = val;
</del><ins>+ m_bottom = primitiveValue.release();
</ins><span class="cx"> else {
</span><span class="cx"> ASSERT(!m_left);
</span><del>- m_left = val;
</del><ins>+ m_left = primitiveValue.release();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_allowNumber = !m_left;
</span><span class="lines">@@ -7697,7 +7683,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- CSSParser* m_parser;
</del><ins>+ CSSParser& m_parser;
</ins><span class="cx">
</span><span class="cx"> bool m_allowNumber;
</span><span class="cx"> bool m_allowFill;
</span><span class="lines">@@ -7713,13 +7699,13 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseBorderImageSlice(CSSPropertyID propId, RefPtr<CSSBorderImageSliceValue>& result)
</span><span class="cx"> {
</span><del>- BorderImageSliceParseContext context(this);
- CSSParserValue* val;
- while ((val = m_valueList->current())) {
</del><ins>+ BorderImageSliceParseContext context(*this);
+ CSSParserValue* value;
+ while ((value = m_valueList->current())) {
</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(val) && validUnit(val, FInteger | FNonNeg | FPercent, CSSStrictMode)) {
- context.commitNumber(val);
- } else if (context.allowFill() && val->id == CSSValueFill)
</del><ins>+ if (context.allowNumber() && !isCalculation(*value) && validUnit(*value, FInteger | FNonNeg | FPercent, CSSStrictMode)) {
+ context.commitNumber(*value);
+ } else if (context.allowFill() && value->id == CSSValueFill)
</ins><span class="cx"> context.commitFill();
</span><span class="cx"> else if (!inShorthand()) {
</span><span class="cx"> // If we're not parsing a shorthand then we are invalid.
</span><span class="lines">@@ -7750,7 +7736,7 @@
</span><span class="cx">
</span><span class="cx"> class BorderImageQuadParseContext {
</span><span class="cx"> public:
</span><del>- BorderImageQuadParseContext(CSSParser* parser)
</del><ins>+ BorderImageQuadParseContext(CSSParser& parser)
</ins><span class="cx"> : m_parser(parser)
</span><span class="cx"> , m_allowNumber(true)
</span><span class="cx"> , m_allowFinalCommit(false)
</span><span class="lines">@@ -7760,23 +7746,23 @@
</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* v)
</del><ins>+ void commitNumber(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- RefPtr<CSSPrimitiveValue> val;
- if (v->id == CSSValueAuto)
- val = cssValuePool().createIdentifierValue(v->id);
</del><ins>+ RefPtr<CSSPrimitiveValue> primitiveValue;
+ if (value.id == CSSValueAuto)
+ primitiveValue = cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx"> else
</span><del>- val = m_parser->createPrimitiveNumericValue(v);
</del><ins>+ primitiveValue = m_parser.createPrimitiveNumericValue(value);
</ins><span class="cx">
</span><span class="cx"> if (!m_top)
</span><del>- m_top = val;
</del><ins>+ m_top = primitiveValue.release();
</ins><span class="cx"> else if (!m_right)
</span><del>- m_right = val;
</del><ins>+ m_right = primitiveValue.release();
</ins><span class="cx"> else if (!m_bottom)
</span><del>- m_bottom = val;
</del><ins>+ m_bottom = primitiveValue.release();
</ins><span class="cx"> else {
</span><span class="cx"> ASSERT(!m_left);
</span><del>- m_left = val;
</del><ins>+ m_left = primitiveValue.release();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_allowNumber = !m_left;
</span><span class="lines">@@ -7814,7 +7800,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- CSSParser* m_parser;
</del><ins>+ CSSParser& m_parser;
</ins><span class="cx">
</span><span class="cx"> bool m_allowNumber;
</span><span class="cx"> bool m_allowFinalCommit;
</span><span class="lines">@@ -7827,11 +7813,11 @@
</span><span class="cx">
</span><span class="cx"> bool CSSParser::parseBorderImageQuad(Units validUnits, RefPtr<CSSPrimitiveValue>& result)
</span><span class="cx"> {
</span><del>- BorderImageQuadParseContext context(this);
- CSSParserValue* val;
- while ((val = m_valueList->current())) {
- if (context.allowNumber() && (validUnit(val, validUnits, CSSStrictMode) || val->id == CSSValueAuto)) {
- context.commitNumber(val);
</del><ins>+ BorderImageQuadParseContext context(*this);
+ CSSParserValue* currentValue;
+ while ((currentValue = m_valueList->current())) {
+ if (context.allowNumber() && (validUnit(*currentValue, validUnits, CSSStrictMode) || currentValue->id == CSSValueAuto)) {
+ context.commitNumber(*currentValue);
</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">@@ -7872,9 +7858,9 @@
</span><span class="cx">
</span><span class="cx"> unsigned indexAfterSlash = 0;
</span><span class="cx"> for (unsigned i = 0; i < num; ++i) {
</span><del>- CSSParserValue* value = m_valueList->valueAt(i);
- if (value->unit == CSSParserValue::Operator) {
- if (value->iValue != '/')
</del><ins>+ CSSParserValue& value = *m_valueList->valueAt(i);
+ if (value.unit == CSSParserValue::Operator) {
+ if (value.iValue != '/')
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (!i || indexAfterSlash || i + 1 == num || num > i + 5)
</span><span class="lines">@@ -7912,7 +7898,7 @@
</span><span class="cx"> } else
</span><span class="cx"> completeBorderRadii(radii[1]);
</span><span class="cx">
</span><del>- ImplicitScope implicitScope(this, PropertyImplicit);
</del><ins>+ ImplicitScope implicitScope(*this, PropertyImplicit);
</ins><span class="cx"> addProperty(CSSPropertyBorderTopLeftRadius, createPrimitiveValuePair(radii[0][0].release(), radii[1][0].release()), important);
</span><span class="cx"> addProperty(CSSPropertyBorderTopRightRadius, createPrimitiveValuePair(radii[0][1].release(), radii[1][1].release()), important);
</span><span class="cx"> addProperty(CSSPropertyBorderBottomRightRadius, createPrimitiveValuePair(radii[0][2].release(), radii[1][2].release()), important);
</span><span class="lines">@@ -7934,9 +7920,9 @@
</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);
- CSSParserValue* op = m_valueList->valueAt(1);
- CSSParserValue* rvalue = m_valueList->valueAt(2);
</del><ins>+ CSSParserValue& lvalue = *m_valueList->valueAt(0);
+ CSSParserValue& op = *m_valueList->valueAt(1);
+ CSSParserValue& rvalue = *m_valueList->valueAt(2);
</ins><span class="cx">
</span><span class="cx"> if (!isForwardSlashOperator(op))
</span><span class="cx"> return false;
</span><span class="lines">@@ -7944,10 +7930,10 @@
</span><span class="cx"> if (!validUnit(lvalue, FNumber | FNonNeg) || !validUnit(rvalue, FNumber | FNonNeg))
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (!lvalue->fValue || !rvalue->fValue)
</del><ins>+ if (!lvalue.fValue || !rvalue.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(lvalue.fValue), narrowPrecisionToFloat(rvalue.fValue)), important);
</ins><span class="cx">
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -7960,11 +7946,11 @@
</span><span class="cx"> RefPtr<CSSPrimitiveValue> counterName;
</span><span class="cx">
</span><span class="cx"> while (true) {
</span><del>- CSSParserValue* val = m_valueList->current();
</del><ins>+ CSSParserValue* value = m_valueList->current();
</ins><span class="cx"> switch (state) {
</span><span class="cx"> case ID:
</span><del>- if (val && val->unit == CSSPrimitiveValue::CSS_IDENT) {
- counterName = createPrimitiveStringValue(val);
</del><ins>+ if (value && value->unit == CSSPrimitiveValue::CSS_IDENT) {
+ counterName = createPrimitiveStringValue(*value);
</ins><span class="cx"> state = VAL;
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> continue;
</span><span class="lines">@@ -7972,8 +7958,8 @@
</span><span class="cx"> break;
</span><span class="cx"> case VAL: {
</span><span class="cx"> int i = defaultValue;
</span><del>- if (val && val->unit == CSSPrimitiveValue::CSS_NUMBER) {
- i = clampToInteger(val->fValue);
</del><ins>+ if (value && value->unit == CSSPrimitiveValue::CSS_NUMBER) {
+ i = clampToInteger(value->fValue);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -7995,44 +7981,44 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // This should go away once we drop support for -webkit-gradient
</span><del>-static PassRefPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue* a, bool horizontal)
</del><ins>+static PassRefPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue& value, bool horizontal)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSPrimitiveValue> result;
</span><del>- if (a->unit == CSSPrimitiveValue::CSS_IDENT) {
- if ((equalIgnoringCase(a, "left") && horizontal)
- || (equalIgnoringCase(a, "top") && !horizontal))
</del><ins>+ if (value.unit == CSSPrimitiveValue::CSS_IDENT) {
+ if ((equalIgnoringCase(value, "left") && horizontal)
+ || (equalIgnoringCase(value, "top") && !horizontal))
</ins><span class="cx"> result = cssValuePool().createValue(0., CSSPrimitiveValue::CSS_PERCENTAGE);
</span><del>- else if ((equalIgnoringCase(a, "right") && horizontal)
- || (equalIgnoringCase(a, "bottom") && !horizontal))
</del><ins>+ else if ((equalIgnoringCase(value, "right") && horizontal)
+ || (equalIgnoringCase(value, "bottom") && !horizontal))
</ins><span class="cx"> result = cssValuePool().createValue(100., CSSPrimitiveValue::CSS_PERCENTAGE);
</span><del>- else if (equalIgnoringCase(a, "center"))
</del><ins>+ else if (equalIgnoringCase(value, "center"))
</ins><span class="cx"> result = cssValuePool().createValue(50., CSSPrimitiveValue::CSS_PERCENTAGE);
</span><del>- } else if (a->unit == CSSPrimitiveValue::CSS_NUMBER || a->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
- result = cssValuePool().createValue(a->fValue, static_cast<CSSPrimitiveValue::UnitTypes>(a->unit));
</del><ins>+ } else if (value.unit == CSSPrimitiveValue::CSS_NUMBER || value.unit == CSSPrimitiveValue::CSS_PERCENTAGE)
+ result = cssValuePool().createValue(value.fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value.unit));
</ins><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool parseDeprecatedGradientColorStop(CSSParser* p, CSSParserValue* a, CSSGradientColorStop& stop)
</del><ins>+static bool parseDeprecatedGradientColorStop(CSSParser& parser, CSSParserValue& value, CSSGradientColorStop& stop)
</ins><span class="cx"> {
</span><del>- if (a->unit != CSSParserValue::Function)
</del><ins>+ if (value.unit != CSSParserValue::Function)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (!equalIgnoringCase(a->function->name, "from(") &&
- !equalIgnoringCase(a->function->name, "to(") &&
- !equalIgnoringCase(a->function->name, "color-stop("))
</del><ins>+ if (!equalIgnoringCase(value.function->name, "from(")
+ && !equalIgnoringCase(value.function->name, "to(")
+ && !equalIgnoringCase(value.function->name, "color-stop("))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValueList* args = a->function->args.get();
</del><ins>+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx"> if (!args)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (equalIgnoringCase(a->function->name, "from(")
- || equalIgnoringCase(a->function->name, "to(")) {
</del><ins>+ if (equalIgnoringCase(value.function->name, "from(")
+ || equalIgnoringCase(value.function->name, "to(")) {
</ins><span class="cx"> // The "from" and "to" stops expect 1 argument.
</span><span class="cx"> if (args->size() != 1)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (equalIgnoringCase(a->function->name, "from("))
</del><ins>+ if (equalIgnoringCase(value.function->name, "from("))
</ins><span class="cx"> stop.m_position = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER);
</span><span class="cx"> else
</span><span class="cx"> stop.m_position = cssValuePool().createValue(1, CSSPrimitiveValue::CSS_NUMBER);
</span><span class="lines">@@ -8041,13 +8027,13 @@
</span><span class="cx"> if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu)
</span><span class="cx"> stop.m_color = cssValuePool().createIdentifierValue(id);
</span><span class="cx"> else
</span><del>- stop.m_color = p->parseColor(args->current());
</del><ins>+ stop.m_color = parser.parseColor(args->current());
</ins><span class="cx"> if (!stop.m_color)
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // The "color-stop" function expects 3 arguments.
</span><del>- if (equalIgnoringCase(a->function->name, "color-stop(")) {
</del><ins>+ if (equalIgnoringCase(value.function->name, "color-stop(")) {
</ins><span class="cx"> if (args->size() != 3)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -8068,7 +8054,7 @@
</span><span class="cx"> if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu)
</span><span class="cx"> stop.m_color = cssValuePool().createIdentifierValue(id);
</span><span class="cx"> else
</span><del>- stop.m_color = p->parseColor(stopArg);
</del><ins>+ stop.m_color = parser.parseColor(stopArg);
</ins><span class="cx"> if (!stop.m_color)
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="lines">@@ -8076,21 +8062,21 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtr<CSSValue>& gradient)
</del><ins>+bool CSSParser::parseDeprecatedGradient(CSSParserValueList& valueList, RefPtr<CSSValue>& gradient)
</ins><span class="cx"> {
</span><span class="cx"> // Walk the arguments.
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || args->size() == 0)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // The first argument is the gradient type. It is an identifier.
</span><span class="cx"> CSSGradientType gradientType;
</span><del>- CSSParserValue* a = args->current();
- if (!a || a->unit != CSSPrimitiveValue::CSS_IDENT)
</del><ins>+ CSSParserValue* argument = args->current();
+ if (!argument || argument->unit != CSSPrimitiveValue::CSS_IDENT)
</ins><span class="cx"> return false;
</span><del>- if (equalIgnoringCase(a, "linear"))
</del><ins>+ if (equalIgnoringCase(*argument, "linear"))
</ins><span class="cx"> gradientType = CSSDeprecatedLinearGradient;
</span><del>- else if (equalIgnoringCase(a, "radial"))
</del><ins>+ else if (equalIgnoringCase(*argument, "radial"))
</ins><span class="cx"> gradientType = CSSDeprecatedRadialGradient;
</span><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="lines">@@ -8109,63 +8095,63 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Comma.
</span><del>- a = args->next();
- if (!isComma(a))
</del><ins>+ argument = args->next();
+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // Next comes the starting point for the gradient as an x y pair. There is no
</span><span class="cx"> // comma between the x and the y values.
</span><span class="cx"> // First X. It can be left, right, number or percent.
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><del>- RefPtr<CSSPrimitiveValue> point = parseDeprecatedGradientPoint(a, true);
</del><ins>+ RefPtr<CSSPrimitiveValue> point = parseDeprecatedGradientPoint(*argument, true);
</ins><span class="cx"> if (!point)
</span><span class="cx"> return false;
</span><span class="cx"> result->setFirstX(point.release());
</span><span class="cx">
</span><span class="cx"> // First Y. It can be top, bottom, number or percent.
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><del>- point = parseDeprecatedGradientPoint(a, false);
</del><ins>+ point = parseDeprecatedGradientPoint(*argument, false);
</ins><span class="cx"> if (!point)
</span><span class="cx"> return false;
</span><span class="cx"> result->setFirstY(point.release());
</span><span class="cx">
</span><span class="cx"> // Comma after the first point.
</span><del>- a = args->next();
- if (!isComma(a))
</del><ins>+ argument = args->next();
+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // For radial gradients only, we now expect a numeric radius.
</span><span class="cx"> if (gradientType == CSSDeprecatedRadialGradient) {
</span><del>- a = args->next();
- if (!a || a->unit != CSSPrimitiveValue::CSS_NUMBER)
</del><ins>+ argument = args->next();
+ if (!argument || argument->unit != CSSPrimitiveValue::CSS_NUMBER)
</ins><span class="cx"> return false;
</span><del>- downcast<CSSRadialGradientValue>(*result).setFirstRadius(createPrimitiveNumericValue(a));
</del><ins>+ downcast<CSSRadialGradientValue>(*result).setFirstRadius(createPrimitiveNumericValue(*argument));
</ins><span class="cx">
</span><span class="cx"> // Comma after the first radius.
</span><del>- a = args->next();
- if (!isComma(a))
</del><ins>+ argument = args->next();
+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Next is the ending point for the gradient as an x, y pair.
</span><span class="cx"> // Second X. It can be left, right, number or percent.
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><del>- point = parseDeprecatedGradientPoint(a, true);
</del><ins>+ point = parseDeprecatedGradientPoint(*argument, true);
</ins><span class="cx"> if (!point)
</span><span class="cx"> return false;
</span><span class="cx"> result->setSecondX(point.release());
</span><span class="cx">
</span><span class="cx"> // Second Y. It can be top, bottom, number or percent.
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><del>- point = parseDeprecatedGradientPoint(a, false);
</del><ins>+ point = parseDeprecatedGradientPoint(*argument, false);
</ins><span class="cx"> if (!point)
</span><span class="cx"> return false;
</span><span class="cx"> result->setSecondY(point.release());
</span><span class="lines">@@ -8173,48 +8159,48 @@
</span><span class="cx"> // For radial gradients only, we now expect the second radius.
</span><span class="cx"> if (gradientType == CSSDeprecatedRadialGradient) {
</span><span class="cx"> // Comma after the second point.
</span><del>- a = args->next();
- if (!isComma(a))
</del><ins>+ argument = args->next();
+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- a = args->next();
- if (!a || a->unit != CSSPrimitiveValue::CSS_NUMBER)
</del><ins>+ argument = args->next();
+ if (!argument || argument->unit != CSSPrimitiveValue::CSS_NUMBER)
</ins><span class="cx"> return false;
</span><del>- downcast<CSSRadialGradientValue>(*result).setSecondRadius(createPrimitiveNumericValue(a));
</del><ins>+ downcast<CSSRadialGradientValue>(*result).setSecondRadius(createPrimitiveNumericValue(*argument));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // We now will accept any number of stops (0 or more).
</span><del>- a = args->next();
- while (a) {
</del><ins>+ argument = args->next();
+ while (argument) {
</ins><span class="cx"> // Look for the comma before the next stop.
</span><del>- if (!isComma(a))
</del><ins>+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // Now examine the stop itself.
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // The function name needs to be one of "from", "to", or "color-stop."
</span><span class="cx"> CSSGradientColorStop stop;
</span><del>- if (!parseDeprecatedGradientColorStop(this, a, stop))
</del><ins>+ if (!parseDeprecatedGradientColorStop(*this, *argument, stop))
</ins><span class="cx"> return false;
</span><span class="cx"> result->addStop(stop);
</span><span class="cx">
</span><span class="cx"> // Advance
</span><del>- a = args->next();
</del><ins>+ argument = args->next();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> gradient = result.release();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static PassRefPtr<CSSPrimitiveValue> valueFromSideKeyword(CSSParserValue* a, bool& isHorizontal)
</del><ins>+static PassRefPtr<CSSPrimitiveValue> valueFromSideKeyword(CSSParserValue& value, bool& isHorizontal)
</ins><span class="cx"> {
</span><del>- if (a->unit != CSSPrimitiveValue::CSS_IDENT)
- return 0;
</del><ins>+ if (value.unit != CSSPrimitiveValue::CSS_IDENT)
+ return nullptr;
</ins><span class="cx">
</span><del>- switch (a->id) {
</del><ins>+ switch (value.id) {
</ins><span class="cx"> case CSSValueLeft:
</span><span class="cx"> case CSSValueRight:
</span><span class="cx"> isHorizontal = true;
</span><span class="lines">@@ -8224,37 +8210,37 @@
</span><span class="cx"> isHorizontal = false;
</span><span class="cx"> break;
</span><span class="cx"> default:
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><del>- return cssValuePool().createIdentifierValue(a->id);
</del><ins>+ return cssValuePool().createIdentifierValue(value.id);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static PassRefPtr<CSSPrimitiveValue> parseGradientColorOrKeyword(CSSParser* p, CSSParserValue* value)
</del><ins>+static PassRefPtr<CSSPrimitiveValue> parseGradientColorOrKeyword(CSSParser& parser, CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- CSSValueID id = value->id;
</del><ins>+ CSSValueID id = value.id;
</ins><span class="cx"> if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor)
</span><span class="cx"> return cssValuePool().createIdentifierValue(id);
</span><span class="cx">
</span><del>- return p->parseColor(value);
</del><ins>+ return parser.parseColor(&value);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseDeprecatedLinearGradient(CSSParserValueList* valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</del><ins>+bool CSSParser::parseDeprecatedLinearGradient(CSSParserValueList& valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSPrefixedLinearGradient);
</span><span class="cx">
</span><span class="cx"> // Walk the arguments.
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue* a = args->current();
- if (!a)
</del><ins>+ CSSParserValue* argument = args->current();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> bool expectComma = false;
</span><span class="cx"> // Look for angle.
</span><del>- if (validUnit(a, FAngle, CSSStrictMode)) {
- result->setAngle(createPrimitiveNumericValue(a));
</del><ins>+ if (validUnit(*argument, FAngle, CSSStrictMode)) {
+ result->setAngle(createPrimitiveNumericValue(*argument));
</ins><span class="cx">
</span><span class="cx"> args->next();
</span><span class="cx"> expectComma = true;
</span><span class="lines">@@ -8264,14 +8250,14 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSPrimitiveValue> location;
</span><span class="cx"> bool isHorizontal = false;
</span><del>- if ((location = valueFromSideKeyword(a, isHorizontal))) {
</del><ins>+ if ((location = valueFromSideKeyword(*argument, isHorizontal))) {
</ins><span class="cx"> if (isHorizontal)
</span><span class="cx"> startX = location;
</span><span class="cx"> else
</span><span class="cx"> startY = location;
</span><span class="cx">
</span><del>- if ((a = args->next())) {
- if ((location = valueFromSideKeyword(a, isHorizontal))) {
</del><ins>+ if ((argument = args->next())) {
+ if ((location = valueFromSideKeyword(*argument, isHorizontal))) {
</ins><span class="cx"> if (isHorizontal) {
</span><span class="cx"> if (startX)
</span><span class="cx"> return false;
</span><span class="lines">@@ -8296,7 +8282,7 @@
</span><span class="cx"> result->setFirstY(startY.release());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (!parseGradientColorStops(args, result.get(), expectComma))
</del><ins>+ if (!parseGradientColorStops(*args, *result, expectComma))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (!result->stopCount())
</span><span class="lines">@@ -8306,17 +8292,17 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseDeprecatedRadialGradient(CSSParserValueList* valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</del><ins>+bool CSSParser::parseDeprecatedRadialGradient(CSSParserValueList& valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
</span><span class="cx">
</span><span class="cx"> // Walk the arguments.
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue* a = args->current();
- if (!a)
</del><ins>+ CSSParserValue* argument = args->current();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> bool expectComma = false;
</span><span class="lines">@@ -8325,18 +8311,18 @@
</span><span class="cx"> RefPtr<CSSValue> centerX;
</span><span class="cx"> RefPtr<CSSValue> centerY;
</span><span class="cx"> // parse2ValuesFillPosition advances the args next pointer.
</span><del>- parse2ValuesFillPosition(args, centerX, centerY);
- a = args->current();
- if (!a)
</del><ins>+ parse2ValuesFillPosition(*args, centerX, centerY);
+ argument = args->current();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (centerX || centerY) {
</span><span class="cx"> // Comma
</span><del>- if (!isComma(a))
</del><ins>+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -8351,14 +8337,14 @@
</span><span class="cx">
</span><span class="cx"> // Optional shape and/or size in any order.
</span><span class="cx"> for (int i = 0; i < 2; ++i) {
</span><del>- if (a->unit != CSSPrimitiveValue::CSS_IDENT)
</del><ins>+ if (argument->unit != CSSPrimitiveValue::CSS_IDENT)
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> bool foundValue = false;
</span><del>- switch (a->id) {
</del><ins>+ switch (argument->id) {
</ins><span class="cx"> case CSSValueCircle:
</span><span class="cx"> case CSSValueEllipse:
</span><del>- shapeValue = cssValuePool().createIdentifierValue(a->id);
</del><ins>+ shapeValue = cssValuePool().createIdentifierValue(argument->id);
</ins><span class="cx"> foundValue = true;
</span><span class="cx"> break;
</span><span class="cx"> case CSSValueClosestSide:
</span><span class="lines">@@ -8367,7 +8353,7 @@
</span><span class="cx"> case CSSValueFarthestCorner:
</span><span class="cx"> case CSSValueContain:
</span><span class="cx"> case CSSValueCover:
</span><del>- sizeValue = cssValuePool().createIdentifierValue(a->id);
</del><ins>+ sizeValue = cssValuePool().createIdentifierValue(argument->id);
</ins><span class="cx"> foundValue = true;
</span><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="lines">@@ -8375,8 +8361,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (foundValue) {
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> expectComma = true;
</span><span class="lines">@@ -8391,20 +8377,20 @@
</span><span class="cx"> RefPtr<CSSPrimitiveValue> verticalSize;
</span><span class="cx">
</span><span class="cx"> if (!shapeValue && !sizeValue) {
</span><del>- if (validUnit(a, FLength | FPercent)) {
- horizontalSize = createPrimitiveNumericValue(a);
- a = args->next();
- if (!a)
</del><ins>+ if (validUnit(*argument, FLength | FPercent)) {
+ horizontalSize = createPrimitiveNumericValue(*argument);
+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> expectComma = true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (validUnit(a, FLength | FPercent)) {
- verticalSize = createPrimitiveNumericValue(a);
</del><ins>+ if (validUnit(*argument, FLength | FPercent)) {
+ verticalSize = createPrimitiveNumericValue(*argument);
</ins><span class="cx">
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx"> expectComma = true;
</span><span class="cx"> }
</span><span class="lines">@@ -8417,43 +8403,43 @@
</span><span class="cx"> result->setEndHorizontalSize(horizontalSize);
</span><span class="cx"> result->setEndVerticalSize(verticalSize);
</span><span class="cx">
</span><del>- if (!parseGradientColorStops(args, result.get(), expectComma))
</del><ins>+ if (!parseGradientColorStops(*args, *result, expectComma))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> gradient = result.release();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseLinearGradient(CSSParserValueList* valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</del><ins>+bool CSSParser::parseLinearGradient(CSSParserValueList& valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSLinearGradient);
</span><span class="cx">
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue* a = args->current();
- if (!a)
</del><ins>+ CSSParserValue* argument = args->current();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> bool expectComma = false;
</span><span class="cx"> // Look for angle.
</span><del>- if (validUnit(a, FAngle, CSSStrictMode)) {
- result->setAngle(createPrimitiveNumericValue(a));
</del><ins>+ if (validUnit(*argument, FAngle, CSSStrictMode)) {
+ result->setAngle(createPrimitiveNumericValue(*argument));
</ins><span class="cx">
</span><span class="cx"> args->next();
</span><span class="cx"> expectComma = true;
</span><del>- } else if (a->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(a, "to")) {
</del><ins>+ } else if (argument->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(*argument, "to")) {
</ins><span class="cx"> // to [ [left | right] || [top | bottom] ]
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</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(a, isHorizontal);
</del><ins>+ location = valueFromSideKeyword(*argument, isHorizontal);
</ins><span class="cx"> if (!location)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -8462,11 +8448,11 @@
</span><span class="cx"> else
</span><span class="cx"> endY = location;
</span><span class="cx">
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- location = valueFromSideKeyword(a, isHorizontal);
</del><ins>+ location = valueFromSideKeyword(*argument, isHorizontal);
</ins><span class="cx"> if (location) {
</span><span class="cx"> if (isHorizontal) {
</span><span class="cx"> if (endX)
</span><span class="lines">@@ -8486,7 +8472,7 @@
</span><span class="cx"> result->setFirstY(endY.release());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (!parseGradientColorStops(args, result.get(), expectComma))
</del><ins>+ if (!parseGradientColorStops(*args, *result, expectComma))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (!result->stopCount())
</span><span class="lines">@@ -8496,16 +8482,16 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseRadialGradient(CSSParserValueList* valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</del><ins>+bool CSSParser::parseRadialGradient(CSSParserValueList& valueList, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
</span><span class="cx">
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- CSSParserValue* a = args->current();
- if (!a)
</del><ins>+ CSSParserValue* argument = args->current();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> bool expectComma = false;
</span><span class="lines">@@ -8520,14 +8506,14 @@
</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><del>- if (a->unit == CSSPrimitiveValue::CSS_IDENT) {
</del><ins>+ if (argument->unit == CSSPrimitiveValue::CSS_IDENT) {
</ins><span class="cx"> bool badIdent = false;
</span><del>- switch (a->id) {
</del><ins>+ switch (argument->id) {
</ins><span class="cx"> case CSSValueCircle:
</span><span class="cx"> case CSSValueEllipse:
</span><span class="cx"> if (shapeValue)
</span><span class="cx"> return false;
</span><del>- shapeValue = cssValuePool().createIdentifierValue(a->id);
</del><ins>+ shapeValue = cssValuePool().createIdentifierValue(argument->id);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSValueClosestSide:
</span><span class="cx"> case CSSValueClosestCorner:
</span><span class="lines">@@ -8535,7 +8521,7 @@
</span><span class="cx"> case CSSValueFarthestCorner:
</span><span class="cx"> if (sizeValue || horizontalSize)
</span><span class="cx"> return false;
</span><del>- sizeValue = cssValuePool().createIdentifierValue(a->id);
</del><ins>+ sizeValue = cssValuePool().createIdentifierValue(argument->id);
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> badIdent = true;
</span><span class="lines">@@ -8544,24 +8530,24 @@
</span><span class="cx"> if (badIdent)
</span><span class="cx"> break;
</span><span class="cx">
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><del>- } else if (validUnit(a, FLength | FPercent)) {
</del><ins>+ } else if (validUnit(*argument, FLength | FPercent)) {
</ins><span class="cx">
</span><span class="cx"> if (sizeValue || horizontalSize)
</span><span class="cx"> return false;
</span><del>- horizontalSize = createPrimitiveNumericValue(a);
</del><ins>+ horizontalSize = createPrimitiveNumericValue(*argument);
</ins><span class="cx">
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (validUnit(a, FLength | FPercent)) {
- verticalSize = createPrimitiveNumericValue(a);
</del><ins>+ if (validUnit(*argument, FLength | FPercent)) {
+ verticalSize = createPrimitiveNumericValue(*argument);
</ins><span class="cx"> ++i;
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> } else
</span><span class="lines">@@ -8590,17 +8576,17 @@
</span><span class="cx"> // at <position>
</span><span class="cx"> RefPtr<CSSValue> centerX;
</span><span class="cx"> RefPtr<CSSValue> centerY;
</span><del>- if (a->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(a, "at")) {
- a = args->next();
- if (!a)
</del><ins>+ if (argument->unit == CSSPrimitiveValue::CSS_IDENT && equalIgnoringCase(*argument, "at")) {
+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- parseFillPosition(args, centerX, centerY);
</del><ins>+ parseFillPosition(*args, centerX, centerY);
</ins><span class="cx"> if (!(centerX && centerY))
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- a = args->current();
- if (!a)
</del><ins>+ argument = args->current();
+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> result->setFirstX(downcast<CSSPrimitiveValue>(centerX.get()));
</span><span class="lines">@@ -8613,52 +8599,52 @@
</span><span class="cx"> if (shapeValue || sizeValue || horizontalSize || centerX || centerY)
</span><span class="cx"> expectComma = true;
</span><span class="cx">
</span><del>- if (!parseGradientColorStops(args, result.get(), expectComma))
</del><ins>+ if (!parseGradientColorStops(*args, *result, expectComma))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> gradient = result.release();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseGradientColorStops(CSSParserValueList* valueList, CSSGradientValue* gradient, bool expectComma)
</del><ins>+bool CSSParser::parseGradientColorStops(CSSParserValueList& valueList, CSSGradientValue& gradient, bool expectComma)
</ins><span class="cx"> {
</span><del>- CSSParserValue* a = valueList->current();
</del><ins>+ CSSParserValue* currentValue = 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 (a) {
</del><ins>+ while (currentValue) {
</ins><span class="cx"> // Look for the comma before the next stop.
</span><span class="cx"> if (expectComma) {
</span><del>- if (!isComma(a))
</del><ins>+ if (!isComma(currentValue))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- a = valueList->next();
- if (!a)
</del><ins>+ currentValue = valueList.next();
+ if (!currentValue)
</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, a);
</del><ins>+ stop.m_color = parseGradientColorOrKeyword(*this, *currentValue);
</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>- a = valueList->next();
</del><ins>+ currentValue = valueList.next();
</ins><span class="cx">
</span><span class="cx"> previousStopWasMidpoint = stop.isMidpoint;
</span><span class="cx">
</span><del>- if (a) {
- if (validUnit(a, FLength | FPercent)) {
- stop.m_position = createPrimitiveNumericValue(a);
- a = valueList->next();
</del><ins>+ if (currentValue) {
+ if (validUnit(*currentValue, FLength | FPercent)) {
+ stop.m_position = createPrimitiveNumericValue(*currentValue);
+ currentValue = valueList.next();
</ins><span class="cx"> } else if (stop.isMidpoint)
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- gradient->addStop(stop);
</del><ins>+ gradient.addStop(stop);
</ins><span class="cx"> expectComma = true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -8667,80 +8653,80 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // Must have 2 or more stops to be valid.
</span><del>- return gradient->stopCount() >= 2;
</del><ins>+ return gradient.stopCount() >= 2;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::isGeneratedImageValue(CSSParserValue* val) const
</del><ins>+bool CSSParser::isGeneratedImageValue(CSSParserValue& value) const
</ins><span class="cx"> {
</span><del>- if (val->unit != CSSParserValue::Function)
</del><ins>+ if (value.unit != CSSParserValue::Function)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- return equalIgnoringCase(val->function->name, "-webkit-gradient(")
- || equalIgnoringCase(val->function->name, "-webkit-linear-gradient(")
- || equalIgnoringCase(val->function->name, "linear-gradient(")
- || equalIgnoringCase(val->function->name, "-webkit-repeating-linear-gradient(")
- || equalIgnoringCase(val->function->name, "repeating-linear-gradient(")
- || equalIgnoringCase(val->function->name, "-webkit-radial-gradient(")
- || equalIgnoringCase(val->function->name, "radial-gradient(")
- || equalIgnoringCase(val->function->name, "-webkit-repeating-radial-gradient(")
- || equalIgnoringCase(val->function->name, "repeating-radial-gradient(")
- || equalIgnoringCase(val->function->name, "-webkit-canvas(")
- || equalIgnoringCase(val->function->name, "-webkit-cross-fade(")
- || equalIgnoringCase(val->function->name, "-webkit-filter(");
</del><ins>+ return equalIgnoringCase(value.function->name, "-webkit-gradient(")
+ || equalIgnoringCase(value.function->name, "-webkit-linear-gradient(")
+ || equalIgnoringCase(value.function->name, "linear-gradient(")
+ || equalIgnoringCase(value.function->name, "-webkit-repeating-linear-gradient(")
+ || equalIgnoringCase(value.function->name, "repeating-linear-gradient(")
+ || equalIgnoringCase(value.function->name, "-webkit-radial-gradient(")
+ || equalIgnoringCase(value.function->name, "radial-gradient(")
+ || equalIgnoringCase(value.function->name, "-webkit-repeating-radial-gradient(")
+ || equalIgnoringCase(value.function->name, "repeating-radial-gradient(")
+ || equalIgnoringCase(value.function->name, "-webkit-canvas(")
+ || equalIgnoringCase(value.function->name, "-webkit-cross-fade(")
+ || equalIgnoringCase(value.function->name, "-webkit-filter(");
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseGeneratedImage(CSSParserValueList* valueList, RefPtr<CSSValue>& value)
</del><ins>+bool CSSParser::parseGeneratedImage(CSSParserValueList& valueList, RefPtr<CSSValue>& value)
</ins><span class="cx"> {
</span><del>- CSSParserValue* val = valueList->current();
</del><ins>+ CSSParserValue& parserValue = *valueList.current();
</ins><span class="cx">
</span><del>- if (val->unit != CSSParserValue::Function)
</del><ins>+ if (parserValue.unit != CSSParserValue::Function)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-gradient("))
</ins><span class="cx"> return parseDeprecatedGradient(valueList, value);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-linear-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-linear-gradient("))
</ins><span class="cx"> return parseDeprecatedLinearGradient(valueList, value, NonRepeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "linear-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "linear-gradient("))
</ins><span class="cx"> return parseLinearGradient(valueList, value, NonRepeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-repeating-linear-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-repeating-linear-gradient("))
</ins><span class="cx"> return parseDeprecatedLinearGradient(valueList, value, Repeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "repeating-linear-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "repeating-linear-gradient("))
</ins><span class="cx"> return parseLinearGradient(valueList, value, Repeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-radial-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-radial-gradient("))
</ins><span class="cx"> return parseDeprecatedRadialGradient(valueList, value, NonRepeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "radial-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "radial-gradient("))
</ins><span class="cx"> return parseRadialGradient(valueList, value, NonRepeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-repeating-radial-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-repeating-radial-gradient("))
</ins><span class="cx"> return parseDeprecatedRadialGradient(valueList, value, Repeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "repeating-radial-gradient("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "repeating-radial-gradient("))
</ins><span class="cx"> return parseRadialGradient(valueList, value, Repeating);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-canvas("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-canvas("))
</ins><span class="cx"> return parseCanvas(valueList, value);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-cross-fade("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-cross-fade("))
</ins><span class="cx"> return parseCrossfade(valueList, value);
</span><span class="cx">
</span><del>- if (equalIgnoringCase(val->function->name, "-webkit-filter("))
</del><ins>+ if (equalIgnoringCase(parserValue.function->name, "-webkit-filter("))
</ins><span class="cx"> return parseFilterImage(valueList, value);
</span><span class="cx">
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFilterImage(CSSParserValueList* valueList, RefPtr<CSSValue>& filter)
</del><ins>+bool CSSParser::parseFilterImage(CSSParserValueList& valueList, RefPtr<CSSValue>& filter)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSFilterImageValue> result;
</span><span class="cx">
</span><span class="cx"> // Walk the arguments.
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args)
</span><span class="cx"> return false;
</span><span class="cx"> CSSParserValue* value = args->current();
</span><span class="lines">@@ -8751,7 +8737,7 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // The first argument is the image. It is a fill image.
</span><del>- if (!parseFillImage(args, imageValue)) {
</del><ins>+ if (!parseFillImage(*args, imageValue)) {
</ins><span class="cx"> if (value->unit == CSSPrimitiveValue::CSS_STRING)
</span><span class="cx"> imageValue = CSSImageValue::create(completeURL(value->string));
</span><span class="cx"> else
</span><span class="lines">@@ -8765,7 +8751,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> value = args->next();
</span><span class="cx">
</span><del>- if (!value || !parseFilter(args, filterValue))
</del><ins>+ if (!value || !parseFilter(*args, filterValue))
</ins><span class="cx"> return false;
</span><span class="cx"> value = args->next();
</span><span class="cx">
</span><span class="lines">@@ -8776,47 +8762,47 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseCrossfade(CSSParserValueList* valueList, RefPtr<CSSValue>& crossfade)
</del><ins>+bool CSSParser::parseCrossfade(CSSParserValueList& valueList, RefPtr<CSSValue>& crossfade)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<CSSCrossfadeValue> result;
</span><span class="cx">
</span><span class="cx"> // Walk the arguments.
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || args->size() != 5)
</span><span class="cx"> return false;
</span><del>- CSSParserValue* a = args->current();
</del><ins>+ CSSParserValue* argument = args->current();
</ins><span class="cx"> RefPtr<CSSValue> fromImageValue;
</span><span class="cx"> RefPtr<CSSValue> toImageValue;
</span><span class="cx">
</span><span class="cx"> // The first argument is the "from" image. It is a fill image.
</span><del>- if (!a || !parseFillImage(args, fromImageValue))
</del><ins>+ if (!argument || !parseFillImage(*args, fromImageValue))
</ins><span class="cx"> return false;
</span><del>- a = args->next();
</del><ins>+ argument = args->next();
</ins><span class="cx">
</span><span class="cx"> // Skip a comma
</span><del>- if (!isComma(a))
</del><ins>+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><del>- a = args->next();
</del><ins>+ argument = args->next();
</ins><span class="cx">
</span><span class="cx"> // The second argument is the "to" image. It is a fill image.
</span><del>- if (!a || !parseFillImage(args, toImageValue))
</del><ins>+ if (!argument || !parseFillImage(*args, toImageValue))
</ins><span class="cx"> return false;
</span><del>- a = args->next();
</del><ins>+ argument = args->next();
</ins><span class="cx">
</span><span class="cx"> // Skip a comma
</span><del>- if (!isComma(a))
</del><ins>+ if (!isComma(argument))
</ins><span class="cx"> return false;
</span><del>- a = args->next();
</del><ins>+ argument = args->next();
</ins><span class="cx">
</span><span class="cx"> // The third argument is the crossfade value. It is a percentage or a fractional number.
</span><span class="cx"> RefPtr<CSSPrimitiveValue> percentage;
</span><del>- if (!a)
</del><ins>+ if (!argument)
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (a->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
- percentage = cssValuePool().createValue(clampTo<double>(a->fValue / 100, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
- else if (a->unit == CSSPrimitiveValue::CSS_NUMBER)
- percentage = cssValuePool().createValue(clampTo<double>(a->fValue, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
</del><ins>+ if (argument->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
+ percentage = cssValuePool().createValue(clampTo<double>(argument->fValue / 100, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
+ else if (argument->unit == CSSPrimitiveValue::CSS_NUMBER)
+ percentage = cssValuePool().createValue(clampTo<double>(argument->fValue, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
</ins><span class="cx"> else
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -8828,10 +8814,10 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseCanvas(CSSParserValueList* valueList, RefPtr<CSSValue>& canvas)
</del><ins>+bool CSSParser::parseCanvas(CSSParserValueList& valueList, RefPtr<CSSValue>& canvas)
</ins><span class="cx"> {
</span><span class="cx"> // Walk the arguments.
</span><del>- CSSParserValueList* args = valueList->current()->function->args.get();
</del><ins>+ CSSParserValueList* args = valueList.current()->function->args.get();
</ins><span class="cx"> if (!args || args->size() != 1)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -8860,17 +8846,17 @@
</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 && validUnit(*value, FResolution | FNonNeg) && value->fValue > 0) {
+ list->append(createPrimitiveNumericValue(*value));
</ins><span class="cx"> haveResolution = true;
</span><span class="cx"> } else
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> value = m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> if (!list->length())
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> if (!haveFromImage && !haveResolution)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> return list.release();
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="lines">@@ -8878,29 +8864,29 @@
</span><span class="cx"> #if ENABLE(CSS_IMAGE_SET)
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseImageSet()
</span><span class="cx"> {
</span><del>- CSSParserValue* value = m_valueList->current();
- ASSERT(value->unit == CSSParserValue::Function);
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ ASSERT(value.unit == CSSParserValue::Function);
</ins><span class="cx">
</span><del>- CSSParserValueList* functionArgs = value->function->args.get();
</del><ins>+ CSSParserValueList* functionArgs = value.function->args.get();
</ins><span class="cx"> if (!functionArgs || !functionArgs->size() || !functionArgs->current())
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
</span><span class="cx"> CSSParserValue* arg = functionArgs->current();
</span><span class="cx"> while (arg) {
</span><span class="cx"> if (arg->unit != CSSPrimitiveValue::CSS_URI)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> imageSet->append(CSSImageValue::create(completeURL(arg->string)));
</span><span class="cx"> arg = functionArgs->next();
</span><span class="cx"> if (!arg || arg->unit != CSSPrimitiveValue::CSS_DIMENSION)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> double imageScaleFactor = 0;
</span><span class="cx"> const String& string = arg->string;
</span><span class="cx"> unsigned length = string.length();
</span><span class="cx"> if (!length)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> if (string.is8Bit()) {
</span><span class="cx"> const LChar* start = string.characters8();
</span><span class="cx"> parseDouble(start, start + length, 'x', imageScaleFactor);
</span><span class="lines">@@ -8909,7 +8895,7 @@
</span><span class="cx"> parseDouble(start, start + length, 'x', imageScaleFactor);
</span><span class="cx"> }
</span><span class="cx"> if (imageScaleFactor <= 0)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> imageSet->append(cssValuePool().createValue(imageScaleFactor, CSSPrimitiveValue::CSS_NUMBER));
</span><span class="cx">
</span><span class="cx"> // If there are no more arguments, we're done.
</span><span class="lines">@@ -8919,7 +8905,7 @@
</span><span class="cx">
</span><span class="cx"> // If there are more arguments, they should be after a comma.
</span><span class="cx"> if (!isComma(arg))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // Skip the comma and move on to the next argument.
</span><span class="cx"> arg = functionArgs->next();
</span><span class="lines">@@ -9191,13 +9177,13 @@
</span><span class="cx"> PassRefPtr<CSSValueList> CSSParser::parseTransform()
</span><span class="cx"> {
</span><span class="cx"> if (!m_valueList)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
</span><span class="cx"> for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
</span><del>- RefPtr<CSSValue> parsedTransformValue = parseTransformValue(value);
</del><ins>+ RefPtr<CSSValue> parsedTransformValue = parseTransformValue(*value);
</ins><span class="cx"> if (!parsedTransformValue)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> list->append(parsedTransformValue.releaseNonNull());
</span><span class="cx"> }
</span><span class="lines">@@ -9205,23 +9191,23 @@
</span><span class="cx"> return list.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CSSValue> CSSParser::parseTransformValue(CSSParserValue *value)
</del><ins>+PassRefPtr<CSSValue> CSSParser::parseTransformValue(CSSParserValue& value)
</ins><span class="cx"> {
</span><del>- if (value->unit != CSSParserValue::Function || !value->function)
- return 0;
</del><ins>+ if (value.unit != CSSParserValue::Function || !value.function)
+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // Every primitive requires at least one argument.
</span><del>- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx"> if (!args)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // See if the specified primitive is one we understand.
</span><del>- TransformOperationInfo info(value->function->name);
</del><ins>+ TransformOperationInfo info(value.function->name);
</ins><span class="cx"> if (info.unknown())
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> if (!info.hasCorrectArgCount(args->size()))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // The transform is a list of functional primitives that specify transform operations.
</span><span class="cx"> // We collect a list of WebKitCSSTransformValues, where each value specifies a single operation.
</span><span class="lines">@@ -9230,41 +9216,41 @@
</span><span class="cx"> RefPtr<WebKitCSSTransformValue> transformValue = WebKitCSSTransformValue::create(info.type());
</span><span class="cx">
</span><span class="cx"> // Snag our values.
</span><del>- CSSParserValue* a = args->current();
</del><ins>+ CSSParserValue* argument = args->current();
</ins><span class="cx"> unsigned argNumber = 0;
</span><del>- while (a) {
</del><ins>+ while (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(a, FAngle, CSSStrictMode))
- return 0;
</del><ins>+ if (!validUnit(*argument, FAngle, CSSStrictMode))
+ return nullptr;
</ins><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(a, FLength, CSSStrictMode))
- return 0;
</del><ins>+ if (!validUnit(*argument, FLength, CSSStrictMode))
+ return nullptr;
</ins><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(a, FLength, CSSStrictMode))
- return 0;
</del><ins>+ if (!validUnit(*argument, FLength, CSSStrictMode))
+ return nullptr;
</ins><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(a, FNumber | FLength | FNonNeg, CSSStrictMode))
- return 0;
- } else if (!validUnit(a, unit, CSSStrictMode))
- return 0;
</del><ins>+ if (!validUnit(*argument, FNumber | FLength | FNonNeg, CSSStrictMode))
+ return nullptr;
+ } else if (!validUnit(*argument, unit, CSSStrictMode))
+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> // Add the value to the current transform operation.
</span><del>- transformValue->append(createPrimitiveNumericValue(a));
</del><ins>+ transformValue->append(createPrimitiveNumericValue(*argument));
</ins><span class="cx">
</span><del>- a = args->next();
- if (!a)
</del><ins>+ argument = args->next();
+ if (!argument)
</ins><span class="cx"> break;
</span><del>- if (a->unit != CSSParserValue::Operator || a->iValue != ',')
- return 0;
- a = args->next();
</del><ins>+ if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
+ return nullptr;
+ argument = args->next();
</ins><span class="cx">
</span><del>- argNumber++;
</del><ins>+ ++argNumber;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return transformValue.release();
</span><span class="lines">@@ -9309,10 +9295,9 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<WebKitCSSFilterValue> CSSParser::parseBuiltinFilterArguments(CSSParserValueList* args, WebKitCSSFilterValue::FilterOperationType filterType)
</del><ins>+PassRefPtr<WebKitCSSFilterValue> CSSParser::parseBuiltinFilterArguments(CSSParserValueList& args, WebKitCSSFilterValue::FilterOperationType filterType)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<WebKitCSSFilterValue> filterValue = WebKitCSSFilterValue::create(filterType);
</span><del>- ASSERT(args);
</del><span class="cx">
</span><span class="cx"> switch (filterType) {
</span><span class="cx"> case WebKitCSSFilterValue::GrayscaleFilterOperation:
</span><span class="lines">@@ -9322,51 +9307,51 @@
</span><span class="cx"> case WebKitCSSFilterValue::OpacityFilterOperation:
</span><span class="cx"> case WebKitCSSFilterValue::ContrastFilterOperation: {
</span><span class="cx"> // One optional argument, 0-1 or 0%-100%, if missing use 100%.
</span><del>- if (args->size() > 1)
- return 0;
</del><ins>+ if (args.size() > 1)
+ return nullptr;
</ins><span class="cx">
</span><del>- if (args->size()) {
- CSSParserValue* value = args->current();
</del><ins>+ if (args.size()) {
+ CSSParserValue& value = *args.current();
</ins><span class="cx"> if (!validUnit(value, FNumber | FPercent | FNonNeg, CSSStrictMode))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- double amount = value->fValue;
</del><ins>+ double amount = 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 = value.unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0;
</ins><span class="cx"> if (amount > maxAllowed)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><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>(value.unit)));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case WebKitCSSFilterValue::BrightnessFilterOperation: {
</span><span class="cx"> // One optional argument, if missing use 100%.
</span><del>- if (args->size() > 1)
- return 0;
</del><ins>+ if (args.size() > 1)
+ return nullptr;
</ins><span class="cx">
</span><del>- if (args->size()) {
- CSSParserValue* value = args->current();
</del><ins>+ if (args.size()) {
+ CSSParserValue& value = *args.current();
</ins><span class="cx"> if (!validUnit(value, FNumber | FPercent, CSSStrictMode))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><del>- filterValue->append(cssValuePool().createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value->unit)));
</del><ins>+ filterValue->append(cssValuePool().createValue(value.fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value.unit)));
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case WebKitCSSFilterValue::HueRotateFilterOperation: {
</span><span class="cx"> // hue-rotate() takes one optional angle.
</span><del>- if (args->size() > 1)
- return 0;
</del><ins>+ if (args.size() > 1)
+ return nullptr;
</ins><span class="cx">
</span><del>- if (args->size()) {
- CSSParserValue* argument = args->current();
</del><ins>+ if (args.size()) {
+ CSSParserValue& argument = *args.current();
</ins><span class="cx"> if (!validUnit(argument, FAngle, CSSStrictMode))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> filterValue->append(createPrimitiveNumericValue(argument));
</span><span class="cx"> }
</span><span class="lines">@@ -9374,13 +9359,13 @@
</span><span class="cx"> }
</span><span class="cx"> case WebKitCSSFilterValue::BlurFilterOperation: {
</span><span class="cx"> // Blur takes a single length. Zero parameters are allowed.
</span><del>- if (args->size() > 1)
- return 0;
</del><ins>+ if (args.size() > 1)
+ return nullptr;
</ins><span class="cx">
</span><del>- if (args->size()) {
- CSSParserValue* argument = args->current();
</del><ins>+ if (args.size()) {
+ CSSParserValue& argument = *args.current();
</ins><span class="cx"> if (!validUnit(argument, FLength | FNonNeg, CSSStrictMode))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> filterValue->append(createPrimitiveNumericValue(argument));
</span><span class="cx"> }
</span><span class="lines">@@ -9390,7 +9375,7 @@
</span><span class="cx"> // drop-shadow() takes a single shadow.
</span><span class="cx"> RefPtr<CSSValueList> shadowValueList = parseShadow(args, CSSPropertyWebkitFilter);
</span><span class="cx"> if (!shadowValueList || shadowValueList->length() != 1)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> filterValue->append(*shadowValueList->itemWithoutBoundsCheck(0));
</span><span class="cx"> break;
</span><span class="lines">@@ -9401,14 +9386,11 @@
</span><span class="cx"> return filterValue.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFilter(CSSParserValueList* valueList, RefPtr<CSSValue>& result)
</del><ins>+bool CSSParser::parseFilter(CSSParserValueList& valueList, RefPtr<CSSValue>& result)
</ins><span class="cx"> {
</span><del>- if (!valueList)
- return false;
-
</del><span class="cx"> // The filter is a list of functional primitives that specify individual operations.
</span><span class="cx"> RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
</span><del>- for (auto value = valueList->current(); value; value = valueList->next()) {
</del><ins>+ for (auto value = valueList.current(); value; value = valueList.next()) {
</ins><span class="cx"> if (value->unit != CSSPrimitiveValue::CSS_URI && (value->unit != CSSParserValue::Function || !value->function))
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -9432,7 +9414,7 @@
</span><span class="cx"> if (!args)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- RefPtr<WebKitCSSFilterValue> filterValue = parseBuiltinFilterArguments(args, filterType);
</del><ins>+ RefPtr<WebKitCSSFilterValue> filterValue = parseBuiltinFilterArguments(*args, filterType);
</ins><span class="cx"> if (!filterValue)
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="lines">@@ -9550,20 +9532,20 @@
</span><span class="cx"> // parseTransformOriginShorthand advances the m_valueList pointer
</span><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitTransformOriginX: {
</span><del>- value = parseFillPositionX(m_valueList.get());
</del><ins>+ value = parseFillPositionX(*m_valueList);
</ins><span class="cx"> if (value)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyWebkitTransformOriginY: {
</span><del>- value = parseFillPositionY(m_valueList.get());
</del><ins>+ value = parseFillPositionY(*m_valueList);
</ins><span class="cx"> if (value)
</span><span class="cx"> m_valueList->next();
</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>+ if (validUnit(*m_valueList->current(), FLength))
+ value = createPrimitiveNumericValue(*m_valueList->current());
</ins><span class="cx"> if (value)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="lines">@@ -9589,16 +9571,16 @@
</span><span class="cx"> case CSSPropertyWebkitPerspectiveOrigin:
</span><span class="cx"> if (m_valueList->size() > 2)
</span><span class="cx"> return false;
</span><del>- parse2ValuesFillPosition(m_valueList.get(), value, value2);
</del><ins>+ parse2ValuesFillPosition(*m_valueList, value, value2);
</ins><span class="cx"> break;
</span><span class="cx"> case CSSPropertyWebkitPerspectiveOriginX: {
</span><del>- value = parseFillPositionX(m_valueList.get());
</del><ins>+ value = parseFillPositionX(*m_valueList);
</ins><span class="cx"> if (value)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case CSSPropertyWebkitPerspectiveOriginY: {
</span><del>- value = parseFillPositionY(m_valueList.get());
</del><ins>+ value = parseFillPositionY(*m_valueList);
</ins><span class="cx"> if (value)
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> break;
</span><span class="lines">@@ -9687,15 +9669,15 @@
</span><span class="cx"> // The text-underline-position property has sintax "auto | alphabetic | [ under || [ left | right ] ]".
</span><span class="cx"> // However, values 'left' and 'right' are not implemented yet, so we will parse sintax
</span><span class="cx"> // "auto | alphabetic | under" for now.
</span><del>- CSSParserValue* value = m_valueList->current();
- switch (value->id) {
</del><ins>+ CSSParserValue& value = *m_valueList->current();
+ switch (value.id) {
</ins><span class="cx"> case CSSValueAuto:
</span><span class="cx"> case CSSValueAlphabetic:
</span><span class="cx"> case CSSValueUnder:
</span><span class="cx"> if (m_valueList->next())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- addProperty(CSSPropertyWebkitTextUnderlinePosition, cssValuePool().createIdentifierValue(value->id), important);
</del><ins>+ addProperty(CSSPropertyWebkitTextUnderlinePosition, cssValuePool().createIdentifierValue(value.id), important);
</ins><span class="cx"> return true;
</span><span class="cx"> default:
</span><span class="cx"> break;
</span><span class="lines">@@ -9714,7 +9696,7 @@
</span><span class="cx"> if (value->unit == CSSPrimitiveValue::CSS_STRING) {
</span><span class="cx"> if (fill || shape || (valueListSize != 1 && !inShorthand()))
</span><span class="cx"> return false;
</span><del>- addProperty(CSSPropertyWebkitTextEmphasisStyle, createPrimitiveStringValue(value), important);
</del><ins>+ addProperty(CSSPropertyWebkitTextEmphasisStyle, createPrimitiveStringValue(*value), important);
</ins><span class="cx"> m_valueList->next();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -9819,8 +9801,8 @@
</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>+ if (!hasLengthOrPercentage && validUnit(*value, FLength | FPercent)) {
+ list->append(createPrimitiveNumericValue(*value));
</ins><span class="cx"> hasLengthOrPercentage = true;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(CSS3_TEXT)
</span><span class="lines">@@ -9833,13 +9815,13 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> else
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> value = m_valueList->next();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (!hasLengthOrPercentage)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> return list.release();
</span><span class="cx"> }
</span><span class="lines">@@ -9888,7 +9870,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool CSSParser::parseFontFeatureTag(CSSValueList* settings)
</del><ins>+bool CSSParser::parseFontFeatureTag(CSSValueList& settings)
</ins><span class="cx"> {
</span><span class="cx"> // Feature tag name consists of 4-letter characters.
</span><span class="cx"> static const unsigned tagNameLength = 4;
</span><span class="lines">@@ -9921,7 +9903,7 @@
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- settings->append(CSSFontFeatureValue::create(tag, tagValue));
</del><ins>+ settings.append(CSSFontFeatureValue::create(tag, tagValue));
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -9936,7 +9918,7 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
</span><span class="cx"> for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
</span><del>- if (!parseFontFeatureTag(settings.get()))
</del><ins>+ if (!parseFontFeatureTag(*settings))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // If the list isn't parsed fully, the current value should be comma.
</span><span class="lines">@@ -9996,16 +9978,16 @@
</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>+bool CSSParser::parseCalculation(CSSParserValue& value, CalculationPermittedValueRange range)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(isCalculation(value));
</span><span class="cx">
</span><del>- CSSParserValueList* args = value->function->args.get();
</del><ins>+ CSSParserValueList* args = value.function->args.get();
</ins><span class="cx"> if (!args || !args->size())
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> ASSERT(!m_parsedCalculation);
</span><del>- m_parsedCalculation = CSSCalcValue::create(value->function->name, *args, range);
</del><ins>+ m_parsedCalculation = CSSCalcValue::create(value.function->name, *args, range);
</ins><span class="cx">
</span><span class="cx"> if (!m_parsedCalculation)
</span><span class="cx"> return false;
</span><span class="lines">@@ -10241,7 +10223,7 @@
</span><span class="cx">
</span><span class="cx"> ++currentCharacter;
</span><span class="cx"> if (!isCSSEscape(*currentCharacter))
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> if (isASCIIHexDigit(*currentCharacter)) {
</span><span class="cx"> int length = 6;
</span><span class="lines">@@ -10344,7 +10326,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (UNLIKELY(*currentCharacter <= '\r' && (*currentCharacter == '\n' || (*currentCharacter | 0x1) == '\r'))) {
</span><span class="cx"> // String parsing is failed for character '\n', '\f' or '\r'.
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (LIKELY(currentCharacter[0] != '\\'))
</span><span class="lines">@@ -10356,7 +10338,7 @@
</span><span class="cx"> else {
</span><span class="cx"> currentCharacter = checkAndSkipEscape(currentCharacter);
</span><span class="cx"> if (!currentCharacter)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -10449,7 +10431,7 @@
</span><span class="cx"> UChar*& result16 = currentCharacter16();
</span><span class="cx"> UChar* start16 = result16;
</span><span class="cx"> int i = 0;
</span><del>- for (; i < result - start; i++)
</del><ins>+ for (; i < result - start; ++i)
</ins><span class="cx"> result16[i] = start[i];
</span><span class="cx">
</span><span class="cx"> result16 += i;
</span><span class="lines">@@ -10511,7 +10493,7 @@
</span><span class="cx"> UChar*& result16 = currentCharacter16();
</span><span class="cx"> UChar* start16 = result16;
</span><span class="cx"> int i = 0;
</span><del>- for (; i < result - start; i++)
</del><ins>+ for (; i < result - start; ++i)
</ins><span class="cx"> result16[i] = start[i];
</span><span class="cx">
</span><span class="cx"> result16 += i;
</span><span class="lines">@@ -11579,7 +11561,7 @@
</span><span class="cx"> {
</span><span class="cx"> if (!media || !m_allowImportRules) {
</span><span class="cx"> popRuleData();
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx"> RefPtr<StyleRuleImport> rule = StyleRuleImport::create(url, media);
</span><span class="cx"> processAndAddNewRuleToSourceTreeIfNeeded();
</span><span class="lines">@@ -11685,7 +11667,7 @@
</span><span class="cx"> PassRefPtr<CSSRuleSourceData> CSSParser::popRuleData()
</span><span class="cx"> {
</span><span class="cx"> if (!m_ruleSourceDataResult)
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx">
</span><span class="cx"> ASSERT(!m_currentRuleDataStack->isEmpty());
</span><span class="cx"> m_currentRuleData.clear();
</span><span class="lines">@@ -11773,7 +11755,7 @@
</span><span class="cx"> // See http://dev.w3.org/csswg/css3-fonts/#font-family-desc
</span><span class="cx"> clearProperties();
</span><span class="cx"> popRuleData();
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> RefPtr<StyleRuleFontFace> rule = StyleRuleFontFace::create(createStyleProperties());
</span><span class="lines">@@ -11890,7 +11872,7 @@
</span><span class="cx"> {
</span><span class="cx"> if (!cssRegionsEnabled() || !regionSelector || !rules) {
</span><span class="cx"> popRuleData();
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_allowImportRules = m_allowNamespaceDeclarations = false;
</span><span class="lines">@@ -11947,7 +11929,7 @@
</span><span class="cx"> // marked as CSSPrimitiveValue::CSS_UNKNOWN during parsing.
</span><span class="cx"> if (keys.valueAt(i)->unit == CSSPrimitiveValue::CSS_UNKNOWN) {
</span><span class="cx"> clearProperties();
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ASSERT(keys.valueAt(i)->unit == CSSPrimitiveValue::CSS_NUMBER);
</span><span class="lines">@@ -11957,7 +11939,7 @@
</span><span class="cx"> // "If a keyframe selector specifies negative percentage values
</span><span class="cx"> // or values higher than 100%, then the keyframe will be ignored."
</span><span class="cx"> clearProperties();
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx"> if (i != 0)
</span><span class="cx"> keyString.append(',');
</span><span class="lines">@@ -12207,7 +12189,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 && validUnit(*value, 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">@@ -12219,7 +12201,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 && validUnit(*value, 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></pre></div>
<a id="trunkSourceWebCorecssCSSParserh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.h (176718 => 176719)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.h 2014-12-03 13:32:01 UTC (rev 176718)
+++ trunk/Source/WebCore/css/CSSParser.h 2014-12-03 14:21:24 UTC (rev 176719)
</span><span class="lines">@@ -84,7 +84,7 @@
</span><span class="cx">
</span><span class="cx"> ~CSSParser();
</span><span class="cx">
</span><del>- void parseSheet(StyleSheetContents*, const String&, int startLineNumber = 0, RuleSourceDataList* = 0, bool = false);
</del><ins>+ void parseSheet(StyleSheetContents*, const String&, int startLineNumber = 0, RuleSourceDataList* = nullptr, bool = false);
</ins><span class="cx"> PassRefPtr<StyleRuleBase> parseRule(StyleSheetContents*, const String&);
</span><span class="cx"> PassRefPtr<StyleKeyframe> parseKeyframeRule(StyleSheetContents*, const String&);
</span><span class="cx"> bool parseSupportsCondition(const String&);
</span><span class="lines">@@ -92,7 +92,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, CSSParserValue&);
</ins><span class="cx"> bool parseDeclaration(MutableStyleProperties*, const String&, PassRefPtr<CSSRuleSourceData>, StyleSheetContents* contextStyleSheet);
</span><span class="cx"> static PassRef<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, Element*);
</span><span class="cx"> std::unique_ptr<MediaQuery> parseMediaQuery(const String&);
</span><span class="lines">@@ -113,22 +113,22 @@
</span><span class="cx"> bool parseQuotes(CSSPropertyID, bool important);
</span><span class="cx"> bool parseAlt(CSSPropertyID, bool important);
</span><span class="cx">
</span><del>- PassRefPtr<CSSValue> parseAttr(CSSParserValueList* args);
</del><ins>+ PassRefPtr<CSSValue> parseAttr(CSSParserValueList& args);
</ins><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> parseBackgroundColor();
</span><span class="cx">
</span><del>- bool parseFillImage(CSSParserValueList*, RefPtr<CSSValue>&);
</del><ins>+ bool parseFillImage(CSSParserValueList&, RefPtr<CSSValue>&);
</ins><span class="cx">
</span><span class="cx"> enum FillPositionFlag { InvalidFillPosition = 0, AmbiguousFillPosition = 1, XFillPosition = 2, YFillPosition = 4 };
</span><span class="cx"> enum FillPositionParsingMode { ResolveValuesAsPercent = 0, ResolveValuesAsKeyword = 1 };
</span><del>- PassRefPtr<CSSPrimitiveValue> parseFillPositionComponent(CSSParserValueList*, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode = ResolveValuesAsPercent);
- PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList*);
- PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList*);
- void parse2ValuesFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
- bool isPotentialPositionValue(CSSParserValue*);
- void parseFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
- void parse3ValuesFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&, PassRefPtr<CSSPrimitiveValue>, PassRefPtr<CSSPrimitiveValue>);
- void parse4ValuesFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&, PassRefPtr<CSSPrimitiveValue>, PassRefPtr<CSSPrimitiveValue>);
</del><ins>+ PassRefPtr<CSSPrimitiveValue> parseFillPositionComponent(CSSParserValueList&, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode = ResolveValuesAsPercent);
+ PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList&);
+ PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList&);
+ void parse2ValuesFillPosition(CSSParserValueList&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ bool isPotentialPositionValue(CSSParserValue&);
+ void parseFillPosition(CSSParserValueList&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
+ void parse3ValuesFillPosition(CSSParserValueList&, RefPtr<CSSValue>&, RefPtr<CSSValue>&, PassRefPtr<CSSPrimitiveValue>, PassRefPtr<CSSPrimitiveValue>);
+ void parse4ValuesFillPosition(CSSParserValueList&, RefPtr<CSSValue>&, RefPtr<CSSValue>&, PassRefPtr<CSSPrimitiveValue>, PassRefPtr<CSSPrimitiveValue>);
</ins><span class="cx">
</span><span class="cx"> void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
</span><span class="cx"> PassRefPtr<CSSValue> parseFillSize(CSSPropertyID, bool &allowComma);
</span><span class="lines">@@ -150,7 +150,7 @@
</span><span class="cx"> PassRefPtr<CSSValue> parseAnimationTimingFunction();
</span><span class="cx">
</span><span class="cx"> bool parseTransformOriginShorthand(RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
</span><del>- bool parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result);
</del><ins>+ bool parseCubicBezierTimingFunctionValue(CSSParserValueList& args, double& result);
</ins><span class="cx"> bool parseAnimationProperty(CSSPropertyID, RefPtr<CSSValue>&, AnimationParseContext&);
</span><span class="cx"> bool parseTransitionShorthand(CSSPropertyID, bool important);
</span><span class="cx"> bool parseAnimationShorthand(CSSPropertyID, bool important);
</span><span class="lines">@@ -166,7 +166,7 @@
</span><span class="cx"> PassRefPtr<CSSValue> parseGridTrackList();
</span><span class="cx"> bool parseGridTrackRepeatFunction(CSSValueList&);
</span><span class="cx"> PassRefPtr<CSSValue> parseGridTrackSize(CSSParserValueList& inputList);
</span><del>- PassRefPtr<CSSPrimitiveValue> parseGridBreadth(CSSParserValue*);
</del><ins>+ PassRefPtr<CSSPrimitiveValue> parseGridBreadth(CSSParserValue&);
</ins><span class="cx"> bool parseGridTemplateAreasRow(NamedGridAreaMap&, const unsigned, unsigned&);
</span><span class="cx"> PassRefPtr<CSSValue> parseGridTemplateAreas();
</span><span class="cx"> bool parseGridLineNames(CSSParserValueList&, CSSValueList&, CSSGridLineNamesValue* = nullptr);
</span><span class="lines">@@ -185,26 +185,22 @@
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> parseBasicShapeAndOrBox(CSSPropertyID propId);
</span><span class="cx"> PassRefPtr<CSSPrimitiveValue> parseBasicShape();
</span><del>- PassRefPtr<CSSPrimitiveValue> parseShapeRadius(CSSParserValue*);
- PassRefPtr<CSSBasicShape> parseBasicShapeRectangle(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseBasicShapeCircle(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseDeprecatedBasicShapeCircle(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseBasicShapeEllipse(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseDeprecatedBasicShapeEllipse(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseBasicShapePolygon(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseBasicShapeInsetRectangle(CSSParserValueList*);
- PassRefPtr<CSSBasicShape> parseBasicShapeInset(CSSParserValueList*);
</del><ins>+ PassRefPtr<CSSPrimitiveValue> parseShapeRadius(CSSParserValue&);
+ PassRefPtr<CSSBasicShape> parseBasicShapeCircle(CSSParserValueList&);
+ PassRefPtr<CSSBasicShape> parseBasicShapeEllipse(CSSParserValueList&);
+ PassRefPtr<CSSBasicShape> parseBasicShapePolygon(CSSParserValueList&);
+ PassRefPtr<CSSBasicShape> parseBasicShapeInset(CSSParserValueList&);
</ins><span class="cx">
</span><span class="cx"> bool parseFont(bool important);
</span><span class="cx"> PassRefPtr<CSSValueList> parseFontFamily();
</span><span class="cx">
</span><span class="cx"> bool parseCounter(CSSPropertyID, int defaultValue, bool important);
</span><del>- PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList* args, bool counters);
</del><ins>+ PassRefPtr<CSSValue> parseCounterContent(CSSParserValueList& args, bool counters);
</ins><span class="cx">
</span><del>- bool parseColorParameters(CSSParserValue*, int* colorValues, bool parseAlpha);
- bool parseHSLParameters(CSSParserValue*, double* colorValues, bool parseAlpha);
- PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);
- bool parseColorFromValue(CSSParserValue*, RGBA32&);
</del><ins>+ bool parseColorParameters(CSSParserValue&, int* colorValues, bool parseAlpha);
+ bool parseHSLParameters(CSSParserValue&, double* colorValues, bool parseAlpha);
+ PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = nullptr);
+ bool parseColorFromValue(CSSParserValue&, RGBA32&);
</ins><span class="cx"> void parseSelector(const String&, CSSSelectorList&);
</span><span class="cx">
</span><span class="cx"> template<typename StringType>
</span><span class="lines">@@ -224,7 +220,7 @@
</span><span class="cx"> PassRefPtr<CSSValue> parsePaintOrder();
</span><span class="cx">
</span><span class="cx"> // CSS3 Parsing Routines (for properties specific to CSS3)
</span><del>- PassRefPtr<CSSValueList> parseShadow(CSSParserValueList*, CSSPropertyID);
</del><ins>+ PassRefPtr<CSSValueList> parseShadow(CSSParserValueList&, CSSPropertyID);
</ins><span class="cx"> bool parseBorderImage(CSSPropertyID, RefPtr<CSSValue>&, bool important = false);
</span><span class="cx"> bool parseBorderImageRepeat(RefPtr<CSSValue>&);
</span><span class="cx"> bool parseBorderImageSlice(CSSPropertyID, RefPtr<CSSBorderImageSliceValue>&);
</span><span class="lines">@@ -236,19 +232,19 @@
</span><span class="cx">
</span><span class="cx"> bool parseReflect(CSSPropertyID, bool important);
</span><span class="cx">
</span><del>- bool parseFlex(CSSParserValueList* args, bool important);
</del><ins>+ bool parseFlex(CSSParserValueList& args, bool important);
</ins><span class="cx">
</span><span class="cx"> // Image generators
</span><del>- bool parseCanvas(CSSParserValueList*, RefPtr<CSSValue>&);
</del><ins>+ bool parseCanvas(CSSParserValueList&, RefPtr<CSSValue>&);
</ins><span class="cx">
</span><del>- bool parseDeprecatedGradient(CSSParserValueList*, RefPtr<CSSValue>&);
- bool parseDeprecatedLinearGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
- bool parseDeprecatedRadialGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
- bool parseLinearGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
- bool parseRadialGradient(CSSParserValueList*, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
- bool parseGradientColorStops(CSSParserValueList*, CSSGradientValue*, bool expectComma);
</del><ins>+ bool parseDeprecatedGradient(CSSParserValueList&, RefPtr<CSSValue>&);
+ bool parseDeprecatedLinearGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
+ bool parseDeprecatedRadialGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
+ bool parseLinearGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
+ bool parseRadialGradient(CSSParserValueList&, RefPtr<CSSValue>&, CSSGradientRepeat repeating);
+ bool parseGradientColorStops(CSSParserValueList&, CSSGradientValue&, bool expectComma);
</ins><span class="cx">
</span><del>- bool parseCrossfade(CSSParserValueList*, RefPtr<CSSValue>&);
</del><ins>+ bool parseCrossfade(CSSParserValueList&, RefPtr<CSSValue>&);
</ins><span class="cx">
</span><span class="cx"> #if ENABLE(CSS_IMAGE_RESOLUTION)
</span><span class="cx"> PassRefPtr<CSSValue> parseImageResolution();
</span><span class="lines">@@ -258,10 +254,10 @@
</span><span class="cx"> PassRefPtr<CSSValue> parseImageSet();
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- bool parseFilterImage(CSSParserValueList*, RefPtr<CSSValue>&);
</del><ins>+ bool parseFilterImage(CSSParserValueList&, RefPtr<CSSValue>&);
</ins><span class="cx">
</span><del>- bool parseFilter(CSSParserValueList*, RefPtr<CSSValue>&);
- PassRefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList*, WebKitCSSFilterValue::FilterOperationType);
</del><ins>+ bool parseFilter(CSSParserValueList&, RefPtr<CSSValue>&);
+ PassRefPtr<WebKitCSSFilterValue> parseBuiltinFilterArguments(CSSParserValueList&, WebKitCSSFilterValue::FilterOperationType);
</ins><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValue> parseClipPath();
</span><span class="cx">
</span><span class="lines">@@ -269,7 +265,7 @@
</span><span class="cx"> static bool isCompositeOperator(CSSValueID);
</span><span class="cx">
</span><span class="cx"> PassRefPtr<CSSValueList> parseTransform();
</span><del>- PassRefPtr<CSSValue> parseTransformValue(CSSParserValue*);
</del><ins>+ PassRefPtr<CSSValue> parseTransformValue(CSSParserValue&);
</ins><span class="cx"> bool parseTransformOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, CSSPropertyID& propId3, RefPtr<CSSValue>&, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
</span><span class="cx"> bool parsePerspectiveOrigin(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
</span><span class="cx">
</span><span class="lines">@@ -284,9 +280,9 @@
</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>+ bool parseCalculation(CSSParserValue&, CalculationPermittedValueRange);
</ins><span class="cx">
</span><del>- bool parseFontFeatureTag(CSSValueList*);
</del><ins>+ bool parseFontFeatureTag(CSSValueList&);
</ins><span class="cx"> bool parseFontFeatureSettings(bool important);
</span><span class="cx">
</span><span class="cx"> bool cssRegionsEnabled() const;
</span><span class="lines">@@ -406,13 +402,13 @@
</span><span class="cx"> PassRefPtr<StyleRuleBase> createViewportRule();
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- PassRef<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
- PassRef<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
</del><ins>+ PassRef<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue&);
+ PassRef<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue&);
</ins><span class="cx">
</span><span class="cx"> static URL completeURL(const CSSParserContext&, const String& url);
</span><span class="cx">
</span><span class="cx"> Location currentLocation();
</span><del>- static bool isCalculation(CSSParserValue*);
</del><ins>+ static bool isCalculation(CSSParserValue&);
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> bool is8BitSource() { return m_is8BitSource; }
</span><span class="lines">@@ -500,18 +496,18 @@
</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 validWidth(CSSParserValue&);
+ bool validHeight(CSSParserValue&);
</ins><span class="cx">
</span><span class="cx"> void deleteFontFaceOnlyValues();
</span><span class="cx">
</span><del>- bool isGeneratedImageValue(CSSParserValue*) const;
- bool parseGeneratedImage(CSSParserValueList*, RefPtr<CSSValue>&);
</del><ins>+ bool isGeneratedImageValue(CSSParserValue&) const;
+ bool parseGeneratedImage(CSSParserValueList&, RefPtr<CSSValue>&);
</ins><span class="cx">
</span><span class="cx"> bool parseValue(MutableStyleProperties*, CSSPropertyID, const String&, bool important, StyleSheetContents* contextStyleSheet);
</span><span class="cx"> PassRef<ImmutableStyleProperties> parseDeclaration(const String&, StyleSheetContents* contextStyleSheet);
</span><span class="cx">
</span><del>- PassRefPtr<CSSBasicShape> parseInsetRoundedCorners(PassRefPtr<CSSBasicShapeInset>, CSSParserValueList*);
</del><ins>+ PassRefPtr<CSSBasicShape> parseInsetRoundedCorners(PassRefPtr<CSSBasicShapeInset>, CSSParserValueList&);
</ins><span class="cx">
</span><span class="cx"> enum SizeParameterType {
</span><span class="cx"> None,
</span><span class="lines">@@ -523,7 +519,7 @@
</span><span class="cx">
</span><span class="cx"> bool parsePage(CSSPropertyID propId, bool important);
</span><span class="cx"> bool parseSize(CSSPropertyID propId, bool important);
</span><del>- SizeParameterType parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType);
</del><ins>+ SizeParameterType parseSizeParameter(CSSValueList& parsedValues, CSSParserValue&, SizeParameterType prevParamType);
</ins><span class="cx">
</span><span class="cx"> #if ENABLE(CSS_SCROLL_SNAP)
</span><span class="cx"> bool parseNonElementSnapPoints(CSSPropertyID propId, bool important);
</span><span class="lines">@@ -531,8 +527,8 @@
</span><span class="cx"> bool parseScrollSnapCoordinate(CSSPropertyID propId, bool important);
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- bool parseFontFaceSrcURI(CSSValueList*);
- bool parseFontFaceSrcLocal(CSSValueList*);
</del><ins>+ bool parseFontFaceSrcURI(CSSValueList&);
+ bool parseFontFaceSrcLocal(CSSValueList&);
</ins><span class="cx">
</span><span class="cx"> bool parseColor(const String&);
</span><span class="cx">
</span><span class="lines">@@ -615,12 +611,12 @@
</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 validCalculationUnit(CSSParserValue&, Units, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
</ins><span class="cx">
</span><del>- bool shouldAcceptUnitLessValues(CSSParserValue*, Units, CSSParserMode);
</del><ins>+ bool shouldAcceptUnitLessValues(CSSParserValue&, Units, CSSParserMode);
</ins><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 validUnit(CSSParserValue& value, Units unitflags, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue) { return validUnit(value, unitflags, m_context.mode, releaseCalc); }
+ bool validUnit(CSSParserValue&, Units, CSSParserMode, ReleaseParsedCalcValueCondition releaseCalc = DoNotReleaseParsedCalcValue);
</ins><span class="cx">
</span><span class="cx"> bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
</span><span class="cx"> int colorIntFromValue(CSSParserValue&);
</span></span></pre></div>
<a id="trunkSourceWebCorecssSVGCSSParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SVGCSSParser.cpp (176718 => 176719)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SVGCSSParser.cpp 2014-12-03 13:32:01 UTC (rev 176718)
+++ trunk/Source/WebCore/css/SVGCSSParser.cpp 2014-12-03 14:21:24 UTC (rev 176719)
</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 = validUnit(*value, FLength | FPercent, SVGAttributeMode);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyDominantBaseline:
</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 = validUnit(*value, 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 && validUnit(*value, FNumber | FPercent, SVGAttributeMode));
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyShapeRendering:
</span><span class="lines">@@ -192,7 +192,7 @@
</span><span class="cx"> else if (value->unit == CSSPrimitiveValue::CSS_URI) {
</span><span class="cx"> RGBA32 c = Color::transparent;
</span><span class="cx"> if (m_valueList->next()) {
</span><del>- if (parseColorFromValue(m_valueList->current(), c))
</del><ins>+ if (parseColorFromValue(*m_valueList->current(), c))
</ins><span class="cx"> parsedValue = SVGPaint::createURIAndColor(value->string, c);
</span><span class="cx"> else if (m_valueList->current()->id == CSSValueNone)
</span><span class="cx"> parsedValue = SVGPaint::createURIAndNone(value->string);
</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 = validUnit(*value, 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,7 +250,7 @@
</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 = validUnit(*value, FLength, SVGAttributeMode);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case CSSPropertyClipPath: // <uri> | none | inherit
</span><span class="lines">@@ -267,7 +267,7 @@
</span><span class="cx"> if (id == CSSValueNone)
</span><span class="cx"> valid_primitive = true;
</span><span class="cx"> else {
</span><del>- RefPtr<CSSValueList> shadowValueList = parseShadow(m_valueList.get(), propId);
</del><ins>+ RefPtr<CSSValueList> shadowValueList = parseShadow(*m_valueList, propId);
</ins><span class="cx"> if (shadowValueList) {
</span><span class="cx"> addProperty(propId, shadowValueList.release(), important);
</span><span class="cx"> m_valueList->next();
</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 && validUnit(*value, 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">@@ -324,7 +324,7 @@
</span><span class="cx"> parsedValue = CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
</span><span class="cx"> else if (value->unit >= CSSParserValue::Q_EMS)
</span><span class="cx"> parsedValue = CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
</span><del>- if (isCalculation(value))
</del><ins>+ if (isCalculation(*value))
</ins><span class="cx"> parsedValue = CSSPrimitiveValue::create(m_parsedCalculation.release());
</span><span class="cx"> m_valueList->next();
</span><span class="cx"> }
</span><span class="lines">@@ -341,7 +341,7 @@
</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>+ valid_primitive = validUnit(*value, FLength | FPercent | FNonNeg, SVGAttributeMode);
</ins><span class="cx"> if (!valid_primitive)
</span><span class="cx"> break;
</span><span class="cx"> if (value->id != 0)
</span><span class="lines">@@ -360,7 +360,7 @@
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseSVGPaint()
</span><span class="cx"> {
</span><span class="cx"> RGBA32 c = Color::transparent;
</span><del>- if (!parseColorFromValue(m_valueList->current(), c))
</del><ins>+ if (!parseColorFromValue(*m_valueList->current(), c))
</ins><span class="cx"> return SVGPaint::createUnknown();
</span><span class="cx"> return SVGPaint::createColor(Color(c));
</span><span class="cx"> }
</span><span class="lines">@@ -368,7 +368,7 @@
</span><span class="cx"> PassRefPtr<CSSValue> CSSParser::parseSVGColor()
</span><span class="cx"> {
</span><span class="cx"> RGBA32 c = Color::transparent;
</span><del>- if (!parseColorFromValue(m_valueList->current(), c))
</del><ins>+ if (!parseColorFromValue(*m_valueList->current(), c))
</ins><span class="cx"> return 0;
</span><span class="cx"> return SVGColor::createFromColor(Color(c));
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssSourceSizeListcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SourceSizeList.cpp (176718 => 176719)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SourceSizeList.cpp 2014-12-03 13:32:01 UTC (rev 176718)
+++ trunk/Source/WebCore/css/SourceSizeList.cpp 2014-12-03 14:21:24 UTC (rev 176719)
</span><span class="lines">@@ -50,7 +50,7 @@
</span><span class="cx"> static unsigned computeLength(CSSParserValue& value, RenderStyle& style, RenderView* view)
</span><span class="cx"> {
</span><span class="cx"> CSSToLengthConversionData conversionData(&style, &style, view);
</span><del>- if (CSSParser::isCalculation(&value)) {
</del><ins>+ if (CSSParser::isCalculation(value)) {
</ins><span class="cx"> CSSParserValueList* args = value.function->args.get();
</span><span class="cx"> if (args && args->size()) {
</span><span class="cx"> RefPtr<CSSCalcValue> calcValue = CSSCalcValue::create(value.function->name, *args, CalculationRangeNonNegative);
</span></span></pre>
</div>
</div>
</body>
</html>