7c8bd1b77e474fa839c059f0251ae173a8f3f53f
[WebKit-https.git] / Source / WebCore / css / CSSParser.cpp
1 /*
2  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
4  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
5  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
6  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
7  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "CSSParser.h"
27
28 #include "CSSAspectRatioValue.h"
29 #include "CSSBorderImageValue.h"
30 #include "CSSCanvasValue.h"
31 #include "CSSCharsetRule.h"
32 #include "CSSCrossfadeValue.h"
33 #include "CSSCursorImageValue.h"
34 #include "CSSFlexValue.h"
35 #include "CSSFontFaceRule.h"
36 #include "CSSFontFaceSrcValue.h"
37 #include "CSSFunctionValue.h"
38 #include "CSSGradientValue.h"
39 #include "CSSImageValue.h"
40 #include "CSSImportRule.h"
41 #include "CSSInheritedValue.h"
42 #include "CSSInitialValue.h"
43 #include "CSSLineBoxContainValue.h"
44 #include "CSSMediaRule.h"
45 #include "CSSMutableStyleDeclaration.h"
46 #include "CSSPageRule.h"
47 #include "CSSPrimitiveValue.h"
48 #include "CSSProperty.h"
49 #include "CSSPropertyNames.h"
50 #include "CSSPropertySourceData.h"
51 #include "CSSReflectValue.h"
52 #include "CSSRuleList.h"
53 #include "CSSSelector.h"
54 #include "CSSStyleRule.h"
55 #include "CSSStyleSheet.h"
56 #include "CSSTimingFunctionValue.h"
57 #include "CSSUnicodeRangeValue.h"
58 #include "CSSValueKeywords.h"
59 #include "CSSValueList.h"
60 #include "CSSValuePool.h"
61 #include "CSSWrapShapes.h"
62 #include "Counter.h"
63 #include "Document.h"
64 #include "FloatConversion.h"
65 #include "FontFamilyValue.h"
66 #include "FontFeatureValue.h"
67 #include "FontValue.h"
68 #include "HTMLParserIdioms.h"
69 #include "HashTools.h"
70 #include "MediaList.h"
71 #include "MediaQueryExp.h"
72 #include "Page.h"
73 #include "Pair.h"
74 #include "Rect.h"
75 #include "RenderTheme.h"
76 #include "ShadowValue.h"
77 #if ENABLE(CSS_FILTERS)
78 #include "WebKitCSSFilterValue.h"
79 #endif
80 #include "WebKitCSSKeyframeRule.h"
81 #include "WebKitCSSKeyframesRule.h"
82 #include "WebKitCSSRegionRule.h"
83 #include "WebKitCSSTransformValue.h"
84 #if ENABLE(CSS_SHADERS)
85 #include "WebKitCSSShaderValue.h"
86 #endif
87 #include <limits.h>
88 #include <wtf/HexNumber.h>
89 #include <wtf/dtoa.h>
90 #include <wtf/text/StringBuffer.h>
91 #include <wtf/text/StringBuilder.h>
92
93 #if ENABLE(DASHBOARD_SUPPORT)
94 #include "DashboardRegion.h"
95 #endif
96
97 #define YYDEBUG 0
98
99 #if YYDEBUG > 0
100 extern int cssyydebug;
101 #endif
102
103 extern int cssyyparse(void* parser);
104
105 using namespace std;
106 using namespace WTF;
107
108 namespace {
109
110 enum PropertyType {
111     PropertyExplicit,
112     PropertyImplicit
113 };
114
115 class ImplicitScope {
116     WTF_MAKE_NONCOPYABLE(ImplicitScope);
117 public:
118     ImplicitScope(WebCore::CSSParser* parser, PropertyType propertyType)
119         : m_parser(parser)
120     {
121         m_parser->m_implicitShorthand = propertyType == PropertyImplicit;
122     }
123
124     ~ImplicitScope()
125     {
126         m_parser->m_implicitShorthand = false;
127     }
128
129 private:
130     WebCore::CSSParser* m_parser;
131 };
132
133 } // namespace
134
135 namespace WebCore {
136
137 static const unsigned INVALID_NUM_PARSED_PROPERTIES = UINT_MAX;
138 static const double MAX_SCALE = 1000000;
139
140 static bool equal(const CSSParserString& a, const char* b)
141 {
142     for (int i = 0; i < a.length; ++i) {
143         if (!b[i])
144             return false;
145         if (a.characters[i] != b[i])
146             return false;
147     }
148     return !b[a.length];
149 }
150
151 static bool equalIgnoringCase(const CSSParserString& a, const char* b)
152 {
153     for (int i = 0; i < a.length; ++i) {
154         if (!b[i])
155             return false;
156         ASSERT(!isASCIIUpper(b[i]));
157         if (toASCIILower(a.characters[i]) != b[i])
158             return false;
159     }
160     return !b[a.length];
161 }
162
163 static bool hasPrefix(const char* string, unsigned length, const char* prefix)
164 {
165     for (unsigned i = 0; i < length; ++i) {
166         if (!prefix[i])
167             return true;
168         if (string[i] != prefix[i])
169             return false;
170     }
171     return false;
172 }
173
174 inline void CSSParser::ensureCSSValuePool()
175 {
176     if (!m_cssValuePool)
177         m_cssValuePool = CSSValuePool::create();
178 }
179
180 // FIXME: Can m_parsedProperties just be a Vector?
181     
182 CSSParser::CSSParser(bool strictParsing)
183     : m_strict(strictParsing)
184     , m_important(false)
185     , m_id(0)
186     , m_styleSheet(0)
187     , m_parsedProperties(static_cast<CSSProperty**>(fastMalloc(32 * sizeof(CSSProperty*))))
188     , m_numParsedProperties(0)
189     , m_maxParsedProperties(32)
190     , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES)
191     , m_inParseShorthand(0)
192     , m_currentShorthand(0)
193     , m_implicitShorthand(false)
194     , m_hasFontFaceOnlyValues(false)
195     , m_hadSyntacticallyValidCSSRule(false)
196     , m_defaultNamespace(starAtom)
197     , m_inStyleRuleOrDeclaration(false)
198     , m_selectorListRange(0, 0)
199     , m_ruleBodyRange(0, 0)
200     , m_propertyRange(UINT_MAX, UINT_MAX)
201     , m_ruleRangeMap(0)
202     , m_currentRuleData(0)
203     , yy_start(1)
204     , m_lineNumber(0)
205     , m_lastSelectorLineNumber(0)
206     , m_allowImportRules(true)
207     , m_allowNamespaceDeclarations(true)
208 {
209 #if YYDEBUG > 0
210     cssyydebug = 1;
211 #endif
212     CSSPropertySourceData::init();
213 }
214
215 CSSParser::~CSSParser()
216 {
217     clearProperties();
218     fastFree(m_parsedProperties);
219
220     fastDeleteAllValues(m_floatingSelectors);
221     deleteAllValues(m_floatingSelectorVectors);
222     deleteAllValues(m_floatingValueLists);
223     deleteAllValues(m_floatingFunctions);
224 }
225
226 void CSSParserString::lower()
227 {
228     // FIXME: If we need Unicode lowercasing here, then we probably want the real kind
229     // that can potentially change the length of the string rather than the character
230     // by character kind. If we don't need Unicode lowercasing, it would be good to
231     // simplify this function.
232
233     if (charactersAreAllASCII(characters, length)) {
234         // Fast case for all-ASCII.
235         for (int i = 0; i < length; i++)
236             characters[i] = toASCIILower(characters[i]);
237     } else {
238         for (int i = 0; i < length; i++)
239             characters[i] = Unicode::toLower(characters[i]);
240     }
241 }
242
243 void CSSParser::setupParser(const char* prefix, const String& string, const char* suffix)
244 {
245     int length = string.length() + strlen(prefix) + strlen(suffix) + 2;
246
247     m_data = adoptArrayPtr(new UChar[length]);
248     for (unsigned i = 0; i < strlen(prefix); i++)
249         m_data[i] = prefix[i];
250
251     memcpy(m_data.get() + strlen(prefix), string.characters(), string.length() * sizeof(UChar));
252
253     unsigned start = strlen(prefix) + string.length();
254     unsigned end = start + strlen(suffix);
255     for (unsigned i = start; i < end; i++)
256         m_data[i] = suffix[i - start];
257
258     m_data[length - 1] = 0;
259     m_data[length - 2] = 0;
260
261     yy_hold_char = 0;
262     yyleng = 0;
263     yytext = m_data.get();
264     yy_c_buf_p = yytext;
265     yy_hold_char = *yy_c_buf_p;
266     resetRuleBodyMarks();
267 }
268
269 void CSSParser::parseSheet(CSSStyleSheet* sheet, const String& string, int startLineNumber, StyleRuleRangeMap* ruleRangeMap)
270 {
271     setStyleSheet(sheet);
272     m_defaultNamespace = starAtom; // Reset the default namespace.
273     m_ruleRangeMap = ruleRangeMap;
274     if (ruleRangeMap) {
275         m_currentRuleData = CSSRuleSourceData::create();
276         m_currentRuleData->styleSourceData = CSSStyleSourceData::create();
277     }
278
279     m_lineNumber = startLineNumber;
280     setupParser("", string, "");
281     cssyyparse(this);
282     m_ruleRangeMap = 0;
283     m_currentRuleData = 0;
284     m_rule = 0;
285 }
286
287 PassRefPtr<CSSRule> CSSParser::parseRule(CSSStyleSheet* sheet, const String& string)
288 {
289     setStyleSheet(sheet);
290     m_allowNamespaceDeclarations = false;
291     setupParser("@-webkit-rule{", string, "} ");
292     cssyyparse(this);
293     return m_rule.release();
294 }
295
296 PassRefPtr<WebKitCSSKeyframeRule> CSSParser::parseKeyframeRule(CSSStyleSheet *sheet, const String &string)
297 {
298     setStyleSheet(sheet);
299     setupParser("@-webkit-keyframe-rule{ ", string, "} ");
300     cssyyparse(this);
301     return m_keyframe.release();
302 }
303
304 static inline bool isColorPropertyID(int propertyId)
305 {
306     switch (propertyId) {
307     case CSSPropertyColor:
308     case CSSPropertyBackgroundColor:
309     case CSSPropertyBorderBottomColor:
310     case CSSPropertyBorderLeftColor:
311     case CSSPropertyBorderRightColor:
312     case CSSPropertyBorderTopColor:
313     case CSSPropertyOutlineColor:
314     case CSSPropertyTextLineThroughColor:
315     case CSSPropertyTextOverlineColor:
316     case CSSPropertyTextUnderlineColor:
317     case CSSPropertyWebkitBorderAfterColor:
318     case CSSPropertyWebkitBorderBeforeColor:
319     case CSSPropertyWebkitBorderEndColor:
320     case CSSPropertyWebkitBorderStartColor:
321     case CSSPropertyWebkitColumnRuleColor:
322     case CSSPropertyWebkitTextEmphasisColor:
323     case CSSPropertyWebkitTextFillColor:
324     case CSSPropertyWebkitTextStrokeColor:
325         return true;
326     default:
327         return false;
328     }
329 }
330
331 static bool parseColorValue(CSSMutableStyleDeclaration* declaration, int propertyId, const String& string, bool important, bool strict, CSSStyleSheet* contextStyleSheet = 0)
332 {
333     if (!string.length())
334         return false;
335     if (!isColorPropertyID(propertyId))
336         return false;
337     CSSParserString cssString;
338     cssString.characters = const_cast<UChar*>(string.characters());
339     cssString.length = string.length();
340     int valueID = cssValueKeywordID(cssString);
341     bool validPrimitive = false;
342     if (valueID == CSSValueWebkitText)
343         validPrimitive = true;
344     else if (valueID == CSSValueCurrentcolor)
345         validPrimitive = true;
346     else if ((valueID >= CSSValueAqua && valueID <= CSSValueWindowtext) || valueID == CSSValueMenu
347              || (valueID >= CSSValueWebkitFocusRingColor && valueID < CSSValueWebkitText && !strict)) {
348         validPrimitive = true;
349     }
350
351     CSSStyleSheet* styleSheet = contextStyleSheet ? contextStyleSheet : declaration->parentStyleSheet();
352     if (!styleSheet)
353         return false;
354     Document* document = styleSheet->findDocument();
355     if (!document)
356         return false;
357     if (validPrimitive) {
358         CSSProperty property(propertyId, document->cssValuePool()->createIdentifierValue(valueID), important);
359         declaration->addParsedProperty(property);
360         return true;
361     }
362     RGBA32 color;
363     if (!CSSParser::fastParseColor(color, string, strict && string[0] != '#'))
364         return false;
365     CSSProperty property(propertyId, document->cssValuePool()->createColorValue(color), important);
366     declaration->addParsedProperty(property);
367     return true;
368 }
369
370 static inline bool isSimpleLengthPropertyID(int propertyId, bool& acceptsNegativeNumbers)
371 {
372     switch (propertyId) {
373     case CSSPropertyFontSize:
374     case CSSPropertyHeight:
375     case CSSPropertyWidth:
376     case CSSPropertyMinHeight:
377     case CSSPropertyMinWidth:
378     case CSSPropertyPaddingBottom:
379     case CSSPropertyPaddingLeft:
380     case CSSPropertyPaddingRight:
381     case CSSPropertyPaddingTop:
382     case CSSPropertyWebkitLogicalWidth:
383     case CSSPropertyWebkitLogicalHeight:
384     case CSSPropertyWebkitMinLogicalWidth:
385     case CSSPropertyWebkitMinLogicalHeight:
386     case CSSPropertyWebkitPaddingAfter:
387     case CSSPropertyWebkitPaddingBefore:
388     case CSSPropertyWebkitPaddingEnd:
389     case CSSPropertyWebkitPaddingStart:
390     case CSSPropertyWebkitWrapMargin:
391     case CSSPropertyWebkitWrapPadding:
392         acceptsNegativeNumbers = false;
393         return true;
394     case CSSPropertyBottom:
395     case CSSPropertyLeft:
396     case CSSPropertyMarginBottom:
397     case CSSPropertyMarginLeft:
398     case CSSPropertyMarginRight:
399     case CSSPropertyMarginTop:
400     case CSSPropertyRight:
401     case CSSPropertyTextIndent:
402     case CSSPropertyTop:
403     case CSSPropertyWebkitMarginAfter:
404     case CSSPropertyWebkitMarginBefore:
405     case CSSPropertyWebkitMarginEnd:
406     case CSSPropertyWebkitMarginStart:
407         acceptsNegativeNumbers = true;
408         return true;
409     default:
410         return false;
411     }
412 }
413
414 static bool parseSimpleLengthValue(CSSMutableStyleDeclaration* declaration, int propertyId, const String& string, bool important, bool strict, CSSStyleSheet* contextStyleSheet = 0)
415 {
416     const UChar* characters = string.characters();
417     unsigned length = string.length();
418     if (!characters || !length)
419         return false;
420     bool acceptsNegativeNumbers;
421     if (!isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
422         return false;
423
424     CSSPrimitiveValue::UnitTypes unit = CSSPrimitiveValue::CSS_NUMBER;
425     if (length > 2 && (characters[length - 2] | 0x20) == 'p' && (characters[length - 1] | 0x20) == 'x') {
426         length -= 2;
427         unit = CSSPrimitiveValue::CSS_PX;
428     } else if (length > 1 && characters[length - 1] == '%') {
429         length -= 1;
430         unit = CSSPrimitiveValue::CSS_PERCENTAGE;
431     }
432
433     // We rely on charactersToDouble for validation as well. The function
434     // will set "ok" to "false" if the entire passed-in character range does
435     // not represent a double.
436     bool ok;
437     double number = charactersToDouble(characters, length, &ok);
438     if (!ok)
439         return false;
440     if (unit == CSSPrimitiveValue::CSS_NUMBER) {
441         if (number && strict)
442             return false;
443         unit = CSSPrimitiveValue::CSS_PX;
444     }
445     if (number < 0 && !acceptsNegativeNumbers)
446         return false;
447
448     CSSStyleSheet* styleSheet = contextStyleSheet ? contextStyleSheet : declaration->parentStyleSheet();
449     if (!styleSheet)
450         return false;
451     Document* document = styleSheet->findDocument();
452     if (!document)
453         return false;
454     CSSProperty property(propertyId, document->cssValuePool()->createValue(number, unit), important);
455     declaration->addParsedProperty(property);
456     return true;
457 }
458
459 bool CSSParser::parseMappedAttributeValue(CSSMappedAttributeDeclaration* declaration, StyledElement* element, int propertyId, const String& value)
460 {
461     ASSERT(declaration);
462     ASSERT(element);
463     ASSERT(element->document());
464     CSSStyleSheet* elementSheet = element->document()->elementSheet();
465     if (parseSimpleLengthValue(declaration, propertyId, value, false, false, elementSheet))
466         return true;
467     if (parseColorValue(declaration, propertyId, value, false, false, elementSheet))
468         return true;
469     CSSParser parser(false);
470     return parser.parseValue(declaration, propertyId, value, false, elementSheet);
471 }
472
473 bool CSSParser::parseValue(CSSMutableStyleDeclaration* declaration, int propertyId, const String& string, bool important, bool strict)
474 {
475     if (parseSimpleLengthValue(declaration, propertyId, string, important, strict))
476         return true;
477     if (parseColorValue(declaration, propertyId, string, important, strict))
478         return true;
479     CSSParser parser(strict);
480     return parser.parseValue(declaration, propertyId, string, important);
481 }
482
483 bool CSSParser::parseValue(CSSMutableStyleDeclaration* declaration, int propertyId, const String& string, bool important, CSSStyleSheet* contextStyleSheet)
484 {
485     if (contextStyleSheet)
486         setStyleSheet(contextStyleSheet);
487     else
488         setStyleSheet(declaration->parentStyleSheet());
489
490     setupParser("@-webkit-value{", string, "} ");
491
492     m_id = propertyId;
493     m_important = important;
494
495     cssyyparse(this);
496
497     m_rule = 0;
498
499     bool ok = false;
500     if (m_hasFontFaceOnlyValues)
501         deleteFontFaceOnlyValues();
502     if (m_numParsedProperties) {
503         ok = true;
504         declaration->addParsedProperties(m_parsedProperties, m_numParsedProperties);
505         clearProperties();
506     }
507
508     return ok;
509 }
510
511 // The color will only be changed when string contains a valid CSS color, so callers
512 // can set it to a default color and ignore the boolean result.
513 bool CSSParser::parseColor(RGBA32& color, const String& string, bool strict)
514 {
515     // First try creating a color specified by name, rgba(), rgb() or "#" syntax.
516     if (fastParseColor(color, string, strict))
517         return true;
518
519     CSSParser parser(true);
520
521     // In case the fast-path parser didn't understand the color, try the full parser.
522     if (!parser.parseColor(string))
523         return false;
524
525     CSSValue* value = parser.m_parsedProperties[0]->value();
526     if (!value->isPrimitiveValue())
527         return false;
528
529     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
530     if (primitiveValue->primitiveType() != CSSPrimitiveValue::CSS_RGBCOLOR)
531         return false;
532
533     color = primitiveValue->getRGBA32Value();
534     return true;
535 }
536
537 bool CSSParser::parseColor(const String& string)
538 {
539     // This function may be called without a stylesheet set on the parser, so we need to
540     // make sure that we have a CSSValuePool or we'll crash below cssyyparse().
541     ensureCSSValuePool();
542
543     setupParser("@-webkit-decls{color:", string, "} ");
544     cssyyparse(this);
545     m_rule = 0;
546
547     return (m_numParsedProperties && m_parsedProperties[0]->m_id == CSSPropertyColor);
548 }
549
550 bool CSSParser::parseSystemColor(RGBA32& color, const String& string, Document* document)
551 {
552     if (!document || !document->page())
553         return false;
554
555     CSSParserString cssColor;
556     cssColor.characters = const_cast<UChar*>(string.characters());
557     cssColor.length = string.length();
558     int id = cssValueKeywordID(cssColor);
559     if (id <= 0)
560         return false;
561
562     color = document->page()->theme()->systemColor(id).rgb();
563     return true;
564 }
565
566 void CSSParser::parseSelector(const String& string, Document* doc, CSSSelectorList& selectorList)
567 {
568     RefPtr<CSSStyleSheet> dummyStyleSheet = CSSStyleSheet::create(doc);
569
570     setStyleSheet(dummyStyleSheet.get());
571     m_selectorListForParseSelector = &selectorList;
572
573     setupParser("@-webkit-selector{", string, "}");
574
575     cssyyparse(this);
576
577     m_selectorListForParseSelector = 0;
578
579     // The style sheet will be deleted right away, so it won't outlive the document.
580     ASSERT(dummyStyleSheet->hasOneRef());
581 }
582
583 bool CSSParser::parseDeclaration(CSSMutableStyleDeclaration* declaration, const String& string, RefPtr<CSSStyleSourceData>* styleSourceData, CSSStyleSheet* contextStyleSheet)
584 {
585     // Length of the "@-webkit-decls{" prefix.
586     static const unsigned prefixLength = 15;
587
588     if (contextStyleSheet)
589         setStyleSheet(contextStyleSheet);
590     else
591         setStyleSheet(declaration->parentStyleSheet());
592     if (styleSourceData) {
593         m_currentRuleData = CSSRuleSourceData::create();
594         m_currentRuleData->styleSourceData = CSSStyleSourceData::create();
595         m_inStyleRuleOrDeclaration = true;
596     }
597
598     setupParser("@-webkit-decls{", string, "} ");
599     cssyyparse(this);
600     m_rule = 0;
601
602     bool ok = false;
603     if (m_hasFontFaceOnlyValues)
604         deleteFontFaceOnlyValues();
605     if (m_numParsedProperties) {
606         ok = true;
607         declaration->addParsedProperties(m_parsedProperties, m_numParsedProperties);
608         clearProperties();
609     }
610
611     if (m_currentRuleData) {
612         m_currentRuleData->styleSourceData->styleBodyRange.start = 0;
613         m_currentRuleData->styleSourceData->styleBodyRange.end = string.length();
614         for (Vector<CSSPropertySourceData>::iterator it = m_currentRuleData->styleSourceData->propertyData.begin(), endIt = m_currentRuleData->styleSourceData->propertyData.end(); it != endIt; ++it) {
615             (*it).range.start -= prefixLength;
616             (*it).range.end -= prefixLength;
617         }
618     }
619
620     if (styleSourceData) {
621         *styleSourceData = m_currentRuleData->styleSourceData.release();
622         m_currentRuleData = 0;
623         m_inStyleRuleOrDeclaration = false;
624     }
625     return ok;
626 }
627
628 bool CSSParser::parseMediaQuery(MediaList* queries, const String& string)
629 {
630     if (string.isEmpty())
631         return true;
632
633     ASSERT(!m_mediaQuery);
634
635     // can't use { because tokenizer state switches from mediaquery to initial state when it sees { token.
636     // instead insert one " " (which is WHITESPACE in CSSGrammar.y)
637     setupParser("@-webkit-mediaquery ", string, "} ");
638     cssyyparse(this);
639
640     bool ok = false;
641     if (m_mediaQuery) {
642         ok = true;
643         queries->appendMediaQuery(m_mediaQuery.release());
644     }
645
646     return ok;
647 }
648
649 void CSSParser::addProperty(int propId, PassRefPtr<CSSValue> value, bool important, bool implicit)
650 {
651     OwnPtr<CSSProperty> prop(adoptPtr(new CSSProperty(propId, value, important, m_currentShorthand, m_implicitShorthand || implicit)));
652     if (m_numParsedProperties >= m_maxParsedProperties) {
653         if (m_numParsedProperties > (UINT_MAX / sizeof(CSSProperty*)) - 32)
654             CRASH();  // Avoid inconsistencies with rollbackLastProperties.
655         m_maxParsedProperties += 32;
656         m_parsedProperties = static_cast<CSSProperty**>(fastRealloc(m_parsedProperties,
657             m_maxParsedProperties * sizeof(CSSProperty*)));
658     }
659     m_parsedProperties[m_numParsedProperties++] = prop.leakPtr();
660 }
661
662 void CSSParser::rollbackLastProperties(int num)
663 {
664     ASSERT(num >= 0);
665     ASSERT(m_numParsedProperties >= static_cast<unsigned>(num));
666
667     for (int i = 0; i < num; ++i)
668         delete m_parsedProperties[--m_numParsedProperties];
669 }
670
671 void CSSParser::clearProperties()
672 {
673     for (unsigned i = 0; i < m_numParsedProperties; i++)
674         delete m_parsedProperties[i];
675     m_numParsedProperties = 0;
676     m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES;
677     m_hasFontFaceOnlyValues = false;
678 }
679
680 void CSSParser::setStyleSheet(CSSStyleSheet* styleSheet)
681 {
682     m_styleSheet = styleSheet;
683     Document* document = findDocument();
684     m_cssValuePool = document ? document->cssValuePool() : CSSValuePool::create();
685 }
686
687 Document* CSSParser::findDocument() const
688 {
689     if (!m_styleSheet)
690         return 0;
691     return m_styleSheet->findDocument();
692 }
693
694 bool CSSParser::validUnit(CSSParserValue* value, Units unitflags, bool strict)
695 {
696     bool b = false;
697     switch (value->unit) {
698     case CSSPrimitiveValue::CSS_NUMBER:
699         b = (unitflags & FNumber);
700         if (!b && ((unitflags & (FLength | FAngle | FTime)) && (value->fValue == 0 || !strict))) {
701             value->unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX :
702                           ((unitflags & FAngle) ? CSSPrimitiveValue::CSS_DEG : CSSPrimitiveValue::CSS_MS);
703             b = true;
704         }
705         if (!b && (unitflags & FInteger) && value->isInt)
706             b = true;
707         break;
708     case CSSPrimitiveValue::CSS_PERCENTAGE:
709         b = (unitflags & FPercent);
710         break;
711     case CSSParserValue::Q_EMS:
712     case CSSPrimitiveValue::CSS_EMS:
713     case CSSPrimitiveValue::CSS_REMS:
714     case CSSPrimitiveValue::CSS_EXS:
715     case CSSPrimitiveValue::CSS_PX:
716     case CSSPrimitiveValue::CSS_CM:
717     case CSSPrimitiveValue::CSS_MM:
718     case CSSPrimitiveValue::CSS_IN:
719     case CSSPrimitiveValue::CSS_PT:
720     case CSSPrimitiveValue::CSS_PC:
721         b = (unitflags & FLength);
722         break;
723     case CSSPrimitiveValue::CSS_MS:
724     case CSSPrimitiveValue::CSS_S:
725         b = (unitflags & FTime);
726         break;
727     case CSSPrimitiveValue::CSS_DEG:
728     case CSSPrimitiveValue::CSS_RAD:
729     case CSSPrimitiveValue::CSS_GRAD:
730     case CSSPrimitiveValue::CSS_TURN:
731         b = (unitflags & FAngle);
732         break;
733     case CSSPrimitiveValue::CSS_HZ:
734     case CSSPrimitiveValue::CSS_KHZ:
735     case CSSPrimitiveValue::CSS_DIMENSION:
736     default:
737         break;
738     }
739     if (b && unitflags & FNonNeg && value->fValue < 0)
740         b = false;
741     return b;
742 }
743
744 inline PassRefPtr<CSSPrimitiveValue> CSSParser::createPrimitiveNumericValue(CSSParserValue* value)
745 {
746     ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
747            || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_REMS));
748     return cssValuePool()->createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value->unit));
749 }
750
751 inline PassRefPtr<CSSPrimitiveValue> CSSParser::createPrimitiveStringValue(CSSParserValue* value)
752 {
753     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
754     return cssValuePool()->createValue(value->string, CSSPrimitiveValue::CSS_STRING);
755 }
756
757 static int unitFromString(CSSParserValue* value)
758 {
759     if (value->unit != CSSPrimitiveValue::CSS_IDENT || value->id)
760         return 0;
761
762     if (equal(value->string, "em"))
763         return CSSPrimitiveValue::CSS_EMS;
764     if (equal(value->string, "rem"))
765         return CSSPrimitiveValue::CSS_REMS;
766     if (equal(value->string, "ex"))
767         return CSSPrimitiveValue::CSS_EXS;
768     if (equal(value->string, "px"))
769         return CSSPrimitiveValue::CSS_PX;
770     if (equal(value->string, "cm"))
771         return CSSPrimitiveValue::CSS_CM;
772     if (equal(value->string, "mm"))
773         return CSSPrimitiveValue::CSS_MM;
774     if (equal(value->string, "in"))
775         return CSSPrimitiveValue::CSS_IN;
776     if (equal(value->string, "pt"))
777         return CSSPrimitiveValue::CSS_PT;
778     if (equal(value->string, "pc"))
779         return CSSPrimitiveValue::CSS_PC;
780     if (equal(value->string, "deg"))
781         return CSSPrimitiveValue::CSS_DEG;
782     if (equal(value->string, "rad"))
783         return CSSPrimitiveValue::CSS_RAD;
784     if (equal(value->string, "grad"))
785         return CSSPrimitiveValue::CSS_GRAD;
786     if (equal(value->string, "turn"))
787         return CSSPrimitiveValue::CSS_TURN;
788     if (equal(value->string, "ms"))
789         return CSSPrimitiveValue::CSS_MS;
790     if (equal(value->string, "s"))
791         return CSSPrimitiveValue::CSS_S;
792     if (equal(value->string, "Hz"))
793         return CSSPrimitiveValue::CSS_HZ;
794     if (equal(value->string, "kHz"))
795         return CSSPrimitiveValue::CSS_KHZ;
796
797     return 0;
798 }
799
800 void CSSParser::checkForOrphanedUnits()
801 {
802     if (m_strict || inShorthand())
803         return;
804
805     // The purpose of this code is to implement the WinIE quirk that allows unit types to be separated from their numeric values
806     // by whitespace, so e.g., width: 20 px instead of width:20px.  This is invalid CSS, so we don't do this in strict mode.
807     CSSParserValue* numericVal = 0;
808     unsigned size = m_valueList->size();
809     for (unsigned i = 0; i < size; i++) {
810         CSSParserValue* value = m_valueList->valueAt(i);
811
812         if (numericVal) {
813             // Change the unit type of the numeric val to match.
814             int unit = unitFromString(value);
815             if (unit) {
816                 numericVal->unit = unit;
817                 numericVal = 0;
818
819                 // Now delete the bogus unit value.
820                 m_valueList->deleteValueAt(i);
821                 i--; // We're safe even though |i| is unsigned, since we only hit this code if we had a previous numeric value (so |i| is always > 0 here).
822                 size--;
823                 continue;
824             }
825         }
826
827         numericVal = (value->unit == CSSPrimitiveValue::CSS_NUMBER) ? value : 0;
828     }
829 }
830
831 inline PassRefPtr<CSSPrimitiveValue> CSSParser::parseValidPrimitive(int id, CSSParserValue* value)
832 {
833     if (id)
834         return cssValuePool()->createIdentifierValue(id);
835     if (value->unit == CSSPrimitiveValue::CSS_STRING)
836         return createPrimitiveStringValue(value);
837     if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
838         return createPrimitiveNumericValue(value);
839     if (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_REMS)
840         return createPrimitiveNumericValue(value);
841     if (value->unit >= CSSParserValue::Q_EMS)
842         return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
843     return 0;
844 }
845
846 bool CSSParser::parseValue(int propId, bool important)
847 {
848     if (!m_valueList)
849         return false;
850
851     CSSParserValue* value = m_valueList->current();
852
853     if (!value)
854         return false;
855
856     int id = value->id;
857
858     // In quirks mode, we will look for units that have been incorrectly separated from the number they belong to
859     // by a space.  We go ahead and associate the unit with the number even though it is invalid CSS.
860     checkForOrphanedUnits();
861
862     int num = inShorthand() ? 1 : m_valueList->size();
863
864     if (id == CSSValueInherit) {
865         if (num != 1)
866             return false;
867         addProperty(propId, cssValuePool()->createInheritedValue(), important);
868         return true;
869     }
870     else if (id == CSSValueInitial) {
871         if (num != 1)
872             return false;
873         addProperty(propId, cssValuePool()->createExplicitInitialValue(), important);
874         return true;
875     }
876
877     bool validPrimitive = false;
878     RefPtr<CSSValue> parsedValue;
879
880     switch (static_cast<CSSPropertyID>(propId)) {
881         /* The comment to the left defines all valid value of this properties as defined
882          * in CSS 2, Appendix F. Property index
883          */
884
885         /* All the CSS properties are not supported by the renderer at the moment.
886          * Note that all the CSS2 Aural properties are only checked, if CSS_AURAL is defined
887          * (see parseAuralValues). As we don't support them at all this seems reasonable.
888          */
889
890     case CSSPropertySize:                 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
891         return parseSize(propId, important);
892
893     case CSSPropertyQuotes:               // [<string> <string>]+ | none | inherit
894         if (id)
895             validPrimitive = true;
896         else
897             return parseQuotes(propId, important);
898         break;
899     case CSSPropertyUnicodeBidi: // normal | embed | bidi-override | isolate | plaintext | inherit
900         if (id == CSSValueNormal
901             || id == CSSValueEmbed
902             || id == CSSValueBidiOverride
903             || id == CSSValueWebkitIsolate
904             || id == CSSValueWebkitPlaintext)
905             validPrimitive = true;
906         break;
907
908     case CSSPropertyPosition:             // static | relative | absolute | fixed | inherit
909         if (id == CSSValueStatic
910             || id == CSSValueRelative
911             || id == CSSValueAbsolute
912             || id == CSSValueFixed)
913             validPrimitive = true;
914         break;
915
916     case CSSPropertyPageBreakAfter:       // auto | always | avoid | left | right | inherit
917     case CSSPropertyPageBreakBefore:
918     case CSSPropertyWebkitColumnBreakAfter:
919     case CSSPropertyWebkitColumnBreakBefore:
920     case CSSPropertyWebkitRegionBreakAfter:
921     case CSSPropertyWebkitRegionBreakBefore:
922         if (id == CSSValueAuto
923             || id == CSSValueAlways
924             || id == CSSValueAvoid
925             || id == CSSValueLeft
926             || id == CSSValueRight)
927             validPrimitive = true;
928         break;
929
930     case CSSPropertyPageBreakInside:     // avoid | auto | inherit
931     case CSSPropertyWebkitColumnBreakInside:
932     case CSSPropertyWebkitRegionBreakInside:
933         if (id == CSSValueAuto || id == CSSValueAvoid)
934             validPrimitive = true;
935         break;
936
937     case CSSPropertyEmptyCells:          // show | hide | inherit
938         if (id == CSSValueShow
939             || id == CSSValueHide)
940             validPrimitive = true;
941         break;
942
943     case CSSPropertyContent:              // [ <string> | <uri> | <counter> | attr(X) | open-quote |
944         // close-quote | no-open-quote | no-close-quote ]+ | inherit
945         return parseContent(propId, important);
946
947     case CSSPropertyWhiteSpace:          // normal | pre | nowrap | inherit
948         if (id == CSSValueNormal
949             || id == CSSValuePre
950             || id == CSSValuePreWrap
951             || id == CSSValuePreLine
952             || id == CSSValueNowrap)
953             validPrimitive = true;
954         break;
955
956     case CSSPropertyClip:                 // <shape> | auto | inherit
957         if (id == CSSValueAuto)
958             validPrimitive = true;
959         else if (value->unit == CSSParserValue::Function)
960             return parseShape(propId, important);
961         break;
962
963     /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
964      * correctly and allows optimization in WebCore::applyRule(..)
965      */
966     case CSSPropertyCaptionSide:         // top | bottom | left | right | inherit
967         if (id == CSSValueLeft || id == CSSValueRight ||
968             id == CSSValueTop || id == CSSValueBottom)
969             validPrimitive = true;
970         break;
971
972     case CSSPropertyBorderCollapse:      // collapse | separate | inherit
973         if (id == CSSValueCollapse || id == CSSValueSeparate)
974             validPrimitive = true;
975         break;
976
977     case CSSPropertyVisibility:           // visible | hidden | collapse | inherit
978         if (id == CSSValueVisible || id == CSSValueHidden || id == CSSValueCollapse)
979             validPrimitive = true;
980         break;
981
982     case CSSPropertyOverflow: {
983         ShorthandScope scope(this, propId);
984         if (num != 1 || !parseValue(CSSPropertyOverflowX, important))
985             return false;
986         CSSValue* value = m_parsedProperties[m_numParsedProperties - 1]->value();
987         addProperty(CSSPropertyOverflowY, value, important);
988         return true;
989     }
990     case CSSPropertyOverflowX:
991     case CSSPropertyOverflowY:           // visible | hidden | scroll | auto | marquee | overlay | inherit
992         if (id == CSSValueVisible || id == CSSValueHidden || id == CSSValueScroll || id == CSSValueAuto ||
993             id == CSSValueOverlay || id == CSSValueWebkitMarquee)
994             validPrimitive = true;
995         break;
996
997     case CSSPropertyListStylePosition:  // inside | outside | inherit
998         if (id == CSSValueInside || id == CSSValueOutside)
999             validPrimitive = true;
1000         break;
1001
1002     case CSSPropertyListStyleType:
1003         // See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in
1004         // for the list of supported list-style-types.
1005         if ((id >= CSSValueDisc && id <= CSSValueKatakanaIroha) || id == CSSValueNone)
1006             validPrimitive = true;
1007         break;
1008
1009     case CSSPropertyDisplay:
1010         // inline | block | list-item | run-in | inline-block | table |
1011         // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
1012         // table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none | inherit
1013         // -webkit-flexbox | -webkit-inline-flexbox | -webkit-grid | -webkit-inline-grid
1014         if ((id >= CSSValueInline && id <= CSSValueWebkitInlineFlexbox) || id == CSSValueNone)
1015             validPrimitive = true;
1016 #if ENABLE(CSS_GRID_LAYOUT)
1017         if (id == CSSValueWebkitGrid || id == CSSValueWebkitInlineGrid)
1018             validPrimitive = true;
1019 #endif
1020         break;
1021
1022     case CSSPropertyDirection:            // ltr | rtl | inherit
1023         if (id == CSSValueLtr || id == CSSValueRtl)
1024             validPrimitive = true;
1025         break;
1026
1027     case CSSPropertyTextTransform:       // capitalize | uppercase | lowercase | none | inherit
1028         if ((id >= CSSValueCapitalize && id <= CSSValueLowercase) || id == CSSValueNone)
1029             validPrimitive = true;
1030         break;
1031
1032     case CSSPropertyFloat:                // left | right | none | positioned | center (for buggy CSS, maps to none)
1033         if (id == CSSValueLeft || id == CSSValueRight
1034             || id == CSSValueNone || id == CSSValueCenter || id == CSSValueWebkitPositioned)
1035             validPrimitive = true;
1036         break;
1037
1038     case CSSPropertyClear:                // none | left | right | both | inherit
1039         if (id == CSSValueNone || id == CSSValueLeft
1040             || id == CSSValueRight || id == CSSValueBoth)
1041             validPrimitive = true;
1042         break;
1043
1044     case CSSPropertyTextAlign:
1045         // left | right | center | justify | webkit_left | webkit_right | webkit_center | webkit_match_parent |
1046         // start | end | <string> | inherit
1047         if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd
1048             || value->unit == CSSPrimitiveValue::CSS_STRING)
1049             validPrimitive = true;
1050         break;
1051
1052     case CSSPropertyOutlineStyle:        // (<border-style> except hidden) | auto | inherit
1053         if (id == CSSValueAuto || id == CSSValueNone || (id >= CSSValueInset && id <= CSSValueDouble))
1054             validPrimitive = true;
1055         break;
1056
1057     case CSSPropertyBorderTopStyle:     //// <border-style> | inherit
1058     case CSSPropertyBorderRightStyle:   //   Defined as:    none | hidden | dotted | dashed |
1059     case CSSPropertyBorderBottomStyle:  //   solid | double | groove | ridge | inset | outset
1060     case CSSPropertyBorderLeftStyle:
1061     case CSSPropertyWebkitBorderStartStyle:
1062     case CSSPropertyWebkitBorderEndStyle:
1063     case CSSPropertyWebkitBorderBeforeStyle:
1064     case CSSPropertyWebkitBorderAfterStyle:
1065     case CSSPropertyWebkitColumnRuleStyle:
1066         if (id >= CSSValueNone && id <= CSSValueDouble)
1067             validPrimitive = true;
1068         break;
1069
1070     case CSSPropertyFontWeight:  // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
1071         return parseFontWeight(important);
1072
1073     case CSSPropertyBorderSpacing: {
1074         const int properties[2] = { CSSPropertyWebkitBorderHorizontalSpacing,
1075                                     CSSPropertyWebkitBorderVerticalSpacing };
1076         if (num == 1) {
1077             ShorthandScope scope(this, CSSPropertyBorderSpacing);
1078             if (!parseValue(properties[0], important))
1079                 return false;
1080             CSSValue* value = m_parsedProperties[m_numParsedProperties-1]->value();
1081             addProperty(properties[1], value, important);
1082             return true;
1083         }
1084         else if (num == 2) {
1085             ShorthandScope scope(this, CSSPropertyBorderSpacing);
1086             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
1087                 return false;
1088             return true;
1089         }
1090         return false;
1091     }
1092     case CSSPropertyWebkitBorderHorizontalSpacing:
1093     case CSSPropertyWebkitBorderVerticalSpacing:
1094         validPrimitive = validUnit(value, FLength | FNonNeg, m_strict);
1095         break;
1096     case CSSPropertyOutlineColor:        // <color> | invert | inherit
1097         // Outline color has "invert" as additional keyword.
1098         // Also, we want to allow the special focus color even in strict parsing mode.
1099         if (id == CSSValueInvert || id == CSSValueWebkitFocusRingColor) {
1100             validPrimitive = true;
1101             break;
1102         }
1103         /* nobreak */
1104     case CSSPropertyBackgroundColor: // <color> | inherit
1105     case CSSPropertyBorderTopColor: // <color> | inherit
1106     case CSSPropertyBorderRightColor:
1107     case CSSPropertyBorderBottomColor:
1108     case CSSPropertyBorderLeftColor:
1109     case CSSPropertyWebkitBorderStartColor:
1110     case CSSPropertyWebkitBorderEndColor:
1111     case CSSPropertyWebkitBorderBeforeColor:
1112     case CSSPropertyWebkitBorderAfterColor:
1113     case CSSPropertyColor: // <color> | inherit
1114     case CSSPropertyTextLineThroughColor: // CSS3 text decoration colors
1115     case CSSPropertyTextUnderlineColor:
1116     case CSSPropertyTextOverlineColor:
1117     case CSSPropertyWebkitColumnRuleColor:
1118     case CSSPropertyWebkitTextEmphasisColor:
1119     case CSSPropertyWebkitTextFillColor:
1120     case CSSPropertyWebkitTextStrokeColor:
1121         if (id == CSSValueWebkitText)
1122             validPrimitive = true; // Always allow this, even when strict parsing is on,
1123                                     // since we use this in our UA sheets.
1124         else if (id == CSSValueCurrentcolor)
1125             validPrimitive = true;
1126         else if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu ||
1127              (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && !m_strict)) {
1128             validPrimitive = true;
1129         } else {
1130             parsedValue = parseColor();
1131             if (parsedValue)
1132                 m_valueList->next();
1133         }
1134         break;
1135
1136     case CSSPropertyCursor: {
1137         // [<uri>,]*  [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
1138         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize |
1139         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help |
1140         // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | -webkit-zoom-in
1141         // -webkit-zoom-out | all-scroll | -webkit-grab | -webkit-grabbing ] ] | inherit
1142         RefPtr<CSSValueList> list;
1143         while (value && value->unit == CSSPrimitiveValue::CSS_URI) {
1144             if (!list)
1145                 list = CSSValueList::createCommaSeparated();
1146             String uri = value->string;
1147             Vector<int> coords;
1148             value = m_valueList->next();
1149             while (value && value->unit == CSSPrimitiveValue::CSS_NUMBER) {
1150                 coords.append(int(value->fValue));
1151                 value = m_valueList->next();
1152             }
1153             IntPoint hotSpot(-1, -1);
1154             int nrcoords = coords.size();
1155             if (nrcoords > 0 && nrcoords != 2)
1156                 return false;
1157             if (nrcoords == 2)
1158                 hotSpot = IntPoint(coords[0], coords[1]);
1159
1160             if (!uri.isNull() && m_styleSheet) {
1161                 // FIXME: The completeURL call should be done when using the CSSCursorImageValue,
1162                 // not when creating it.
1163                 list->append(CSSCursorImageValue::create(m_styleSheet->completeURL(uri), hotSpot));
1164             }
1165
1166             if ((m_strict && !value) || (value && !(value->unit == CSSParserValue::Operator && value->iValue == ',')))
1167                 return false;
1168             value = m_valueList->next(); // comma
1169         }
1170         if (list) {
1171             if (!value) { // no value after url list (MSIE 5 compatibility)
1172                 if (list->length() != 1)
1173                     return false;
1174             } else if (!m_strict && value->id == CSSValueHand) // MSIE 5 compatibility :/
1175                 list->append(cssValuePool()->createIdentifierValue(CSSValuePointer));
1176             else if (value && ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitGrabbing) || value->id == CSSValueCopy || value->id == CSSValueNone))
1177                 list->append(cssValuePool()->createIdentifierValue(value->id));
1178             m_valueList->next();
1179             parsedValue = list.release();
1180             break;
1181         }
1182         id = value->id;
1183         if (!m_strict && value->id == CSSValueHand) { // MSIE 5 compatibility :/
1184             id = CSSValuePointer;
1185             validPrimitive = true;
1186         } else if ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitGrabbing) || value->id == CSSValueCopy || value->id == CSSValueNone)
1187             validPrimitive = true;
1188         break;
1189     }
1190
1191     case CSSPropertyBackgroundAttachment:
1192     case CSSPropertyBackgroundClip:
1193     case CSSPropertyWebkitBackgroundClip:
1194     case CSSPropertyWebkitBackgroundComposite:
1195     case CSSPropertyBackgroundImage:
1196     case CSSPropertyBackgroundOrigin:
1197     case CSSPropertyWebkitBackgroundOrigin:
1198     case CSSPropertyBackgroundPosition:
1199     case CSSPropertyBackgroundPositionX:
1200     case CSSPropertyBackgroundPositionY:
1201     case CSSPropertyBackgroundSize:
1202     case CSSPropertyWebkitBackgroundSize:
1203     case CSSPropertyBackgroundRepeat:
1204     case CSSPropertyBackgroundRepeatX:
1205     case CSSPropertyBackgroundRepeatY:
1206     case CSSPropertyWebkitMaskAttachment:
1207     case CSSPropertyWebkitMaskClip:
1208     case CSSPropertyWebkitMaskComposite:
1209     case CSSPropertyWebkitMaskImage:
1210     case CSSPropertyWebkitMaskOrigin:
1211     case CSSPropertyWebkitMaskPosition:
1212     case CSSPropertyWebkitMaskPositionX:
1213     case CSSPropertyWebkitMaskPositionY:
1214     case CSSPropertyWebkitMaskSize:
1215     case CSSPropertyWebkitMaskRepeat:
1216     case CSSPropertyWebkitMaskRepeatX:
1217     case CSSPropertyWebkitMaskRepeatY: {
1218         RefPtr<CSSValue> val1;
1219         RefPtr<CSSValue> val2;
1220         int propId1, propId2;
1221         bool result = false;
1222         if (parseFillProperty(propId, propId1, propId2, val1, val2)) {
1223             OwnPtr<ShorthandScope> shorthandScope;
1224             if (propId == CSSPropertyBackgroundPosition ||
1225                 propId == CSSPropertyBackgroundRepeat ||
1226                 propId == CSSPropertyWebkitMaskPosition ||
1227                 propId == CSSPropertyWebkitMaskRepeat) {
1228                 shorthandScope = adoptPtr(new ShorthandScope(this, propId));
1229             }
1230             addProperty(propId1, val1.release(), important);
1231             if (val2)
1232                 addProperty(propId2, val2.release(), important);
1233             result = true;
1234         }
1235         m_implicitShorthand = false;
1236         return result;
1237     }
1238     case CSSPropertyListStyleImage:     // <uri> | none | inherit
1239     case CSSPropertyBorderImageSource:
1240     case CSSPropertyWebkitMaskBoxImageSource:
1241         if (id == CSSValueNone) {
1242             parsedValue = CSSImageValue::create();
1243             m_valueList->next();
1244         } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
1245             if (m_styleSheet) {
1246                 // FIXME: The completeURL call should be done when using the CSSImageValue,
1247                 // not when creating it.
1248                 parsedValue = CSSImageValue::create(m_styleSheet->completeURL(value->string));
1249                 m_valueList->next();
1250             }
1251         } else if (isGeneratedImageValue(value)) {
1252             if (parseGeneratedImage(m_valueList.get(), parsedValue))
1253                 m_valueList->next();
1254             else
1255                 return false;
1256         }
1257         break;
1258
1259     case CSSPropertyWebkitTextStrokeWidth:
1260     case CSSPropertyOutlineWidth:        // <border-width> | inherit
1261     case CSSPropertyBorderTopWidth:     //// <border-width> | inherit
1262     case CSSPropertyBorderRightWidth:   //   Which is defined as
1263     case CSSPropertyBorderBottomWidth:  //   thin | medium | thick | <length>
1264     case CSSPropertyBorderLeftWidth:
1265     case CSSPropertyWebkitBorderStartWidth:
1266     case CSSPropertyWebkitBorderEndWidth:
1267     case CSSPropertyWebkitBorderBeforeWidth:
1268     case CSSPropertyWebkitBorderAfterWidth:
1269     case CSSPropertyWebkitColumnRuleWidth:
1270         if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
1271             validPrimitive = true;
1272         else
1273             validPrimitive = validUnit(value, FLength | FNonNeg, m_strict);
1274         break;
1275
1276     case CSSPropertyLetterSpacing:       // normal | <length> | inherit
1277     case CSSPropertyWordSpacing:         // normal | <length> | inherit
1278         if (id == CSSValueNormal)
1279             validPrimitive = true;
1280         else
1281             validPrimitive = validUnit(value, FLength, m_strict);
1282         break;
1283
1284     case CSSPropertyWordBreak:          // normal | break-all | break-word (this is a custom extension)
1285         if (id == CSSValueNormal || id == CSSValueBreakAll || id == CSSValueBreakWord)
1286             validPrimitive = true;
1287         break;
1288
1289     case CSSPropertyWordWrap:           // normal | break-word
1290         if (id == CSSValueNormal || id == CSSValueBreakWord)
1291             validPrimitive = true;
1292         break;
1293     case CSSPropertySpeak:           // none | normal | spell-out | digits | literal-punctuation | no-punctuation | inherit
1294         if (id == CSSValueNone || id == CSSValueNormal || id == CSSValueSpellOut || id == CSSValueDigits
1295             || id == CSSValueLiteralPunctuation || id == CSSValueNoPunctuation)
1296             validPrimitive = true;
1297         break;
1298
1299     case CSSPropertyTextIndent:          // <length> | <percentage> | inherit
1300         validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict));
1301         break;
1302
1303     case CSSPropertyPaddingTop:          //// <padding-width> | inherit
1304     case CSSPropertyPaddingRight:        //   Which is defined as
1305     case CSSPropertyPaddingBottom:       //   <length> | <percentage>
1306     case CSSPropertyPaddingLeft:         ////
1307     case CSSPropertyWebkitPaddingStart:
1308     case CSSPropertyWebkitPaddingEnd:
1309     case CSSPropertyWebkitPaddingBefore:
1310     case CSSPropertyWebkitPaddingAfter:
1311         validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg, m_strict));
1312         break;
1313
1314     case CSSPropertyMaxHeight:           // <length> | <percentage> | none | inherit
1315     case CSSPropertyMaxWidth:            // <length> | <percentage> | none | inherit
1316     case CSSPropertyWebkitMaxLogicalWidth:
1317     case CSSPropertyWebkitMaxLogicalHeight:
1318         if (id == CSSValueNone || id == CSSValueIntrinsic || id == CSSValueMinIntrinsic) {
1319             validPrimitive = true;
1320             break;
1321         }
1322         /* nobreak */
1323     case CSSPropertyMinHeight:           // <length> | <percentage> | inherit
1324     case CSSPropertyMinWidth:            // <length> | <percentage> | inherit
1325     case CSSPropertyWebkitMinLogicalWidth:
1326     case CSSPropertyWebkitMinLogicalHeight:
1327         if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic)
1328             validPrimitive = true;
1329         else
1330             validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg, m_strict));
1331         break;
1332
1333     case CSSPropertyFontSize:
1334         // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
1335         if (id >= CSSValueXxSmall && id <= CSSValueLarger)
1336             validPrimitive = true;
1337         else
1338             validPrimitive = (validUnit(value, FLength | FPercent | FNonNeg, m_strict));
1339         break;
1340
1341     case CSSPropertyFontStyle:           // normal | italic | oblique | inherit
1342         return parseFontStyle(important);
1343
1344     case CSSPropertyFontVariant:         // normal | small-caps | inherit
1345         return parseFontVariant(important);
1346
1347     case CSSPropertyVerticalAlign:
1348         // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
1349         // <percentage> | <length> | inherit
1350
1351         if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle)
1352             validPrimitive = true;
1353         else
1354             validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict));
1355         break;
1356
1357     case CSSPropertyHeight:               // <length> | <percentage> | auto | inherit
1358     case CSSPropertyWidth:                // <length> | <percentage> | auto | inherit
1359     case CSSPropertyWebkitLogicalWidth:
1360     case CSSPropertyWebkitLogicalHeight:
1361         if (id == CSSValueAuto || id == CSSValueIntrinsic || id == CSSValueMinIntrinsic)
1362             validPrimitive = true;
1363         else if (!id && validUnit(value, FLength | FPercent | FNonNeg, m_strict))
1364             // ### handle multilength case where we allow relative units
1365             validPrimitive = true;
1366         else if (value->unit == CSSParserValue::Function)
1367             return parseFlex(propId, important);
1368         break;
1369
1370     case CSSPropertyBottom:               // <length> | <percentage> | auto | inherit
1371     case CSSPropertyLeft:                 // <length> | <percentage> | auto | inherit
1372     case CSSPropertyRight:                // <length> | <percentage> | auto | inherit
1373     case CSSPropertyTop:                  // <length> | <percentage> | auto | inherit
1374     case CSSPropertyMarginTop:           //// <margin-width> | inherit
1375     case CSSPropertyMarginRight:         //   Which is defined as
1376     case CSSPropertyMarginBottom:        //   <length> | <percentage> | auto | inherit
1377     case CSSPropertyMarginLeft:          ////
1378     case CSSPropertyWebkitMarginStart:
1379     case CSSPropertyWebkitMarginEnd:
1380     case CSSPropertyWebkitMarginBefore:
1381     case CSSPropertyWebkitMarginAfter:
1382         if (id == CSSValueAuto)
1383             validPrimitive = true;
1384         else
1385             validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict));
1386         break;
1387
1388     case CSSPropertyZIndex:              // auto | <integer> | inherit
1389         if (id == CSSValueAuto) {
1390             validPrimitive = true;
1391             break;
1392         }
1393         /* nobreak */
1394     case CSSPropertyOrphans:              // <integer> | inherit
1395     case CSSPropertyWidows:               // <integer> | inherit
1396         // ### not supported later on
1397         validPrimitive = (!id && validUnit(value, FInteger, false));
1398         break;
1399
1400     case CSSPropertyLineHeight:          // normal | <number> | <length> | <percentage> | inherit
1401         if (id == CSSValueNormal)
1402             validPrimitive = true;
1403         else
1404             validPrimitive = (!id && validUnit(value, FNumber | FLength | FPercent | FNonNeg, m_strict));
1405         break;
1406     case CSSPropertyCounterIncrement:    // [ <identifier> <integer>? ]+ | none | inherit
1407         if (id != CSSValueNone)
1408             return parseCounter(propId, 1, important);
1409         validPrimitive = true;
1410         break;
1411     case CSSPropertyCounterReset:        // [ <identifier> <integer>? ]+ | none | inherit
1412         if (id != CSSValueNone)
1413             return parseCounter(propId, 0, important);
1414         validPrimitive = true;
1415         break;
1416     case CSSPropertyFontFamily:
1417         // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
1418     {
1419         parsedValue = parseFontFamily();
1420         break;
1421     }
1422
1423     case CSSPropertyTextDecoration:
1424     case CSSPropertyWebkitTextDecorationsInEffect:
1425         // none | [ underline || overline || line-through || blink ] | inherit
1426         if (id == CSSValueNone) {
1427             validPrimitive = true;
1428         } else {
1429             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1430             bool isValid = true;
1431             while (isValid && value) {
1432                 switch (value->id) {
1433                 case CSSValueBlink:
1434                     break;
1435                 case CSSValueUnderline:
1436                 case CSSValueOverline:
1437                 case CSSValueLineThrough:
1438                     list->append(cssValuePool()->createIdentifierValue(value->id));
1439                     break;
1440                 default:
1441                     isValid = false;
1442                 }
1443                 value = m_valueList->next();
1444             }
1445             if (list->length() && isValid) {
1446                 parsedValue = list.release();
1447                 m_valueList->next();
1448             }
1449         }
1450         break;
1451
1452     case CSSPropertyZoom:          // normal | reset | document | <number> | <percentage> | inherit
1453         if (id == CSSValueNormal || id == CSSValueReset || id == CSSValueDocument)
1454             validPrimitive = true;
1455         else
1456             validPrimitive = (!id && validUnit(value, FNumber | FPercent | FNonNeg, true));
1457         break;
1458
1459     case CSSPropertyTableLayout:         // auto | fixed | inherit
1460         if (id == CSSValueAuto || id == CSSValueFixed)
1461             validPrimitive = true;
1462         break;
1463
1464     case CSSPropertySrc:  // Only used within @font-face, so cannot use inherit | initial or be !important.  This is a list of urls or local references.
1465         return parseFontFaceSrc();
1466
1467     case CSSPropertyUnicodeRange:
1468         return parseFontFaceUnicodeRange();
1469
1470     /* CSS3 properties */
1471     case CSSPropertyWebkitAppearance:
1472         if ((id >= CSSValueCheckbox && id <= CSSValueTextarea) || id == CSSValueNone)
1473             validPrimitive = true;
1474         break;
1475
1476     case CSSPropertyBorderImage:
1477     case CSSPropertyWebkitBorderImage:
1478     case CSSPropertyWebkitMaskBoxImage: {
1479         RefPtr<CSSValue> result;
1480         if (parseBorderImage(propId, result)) {
1481             addProperty(propId, result, important);
1482             return true;
1483         }
1484         break;
1485     }
1486     case CSSPropertyBorderImageOutset:
1487     case CSSPropertyWebkitMaskBoxImageOutset: {
1488         RefPtr<CSSPrimitiveValue> result;
1489         if (parseBorderImageOutset(result)) {
1490             addProperty(propId, result, important);
1491             return true;
1492         }
1493         break;
1494     }
1495     case CSSPropertyBorderImageRepeat:
1496     case CSSPropertyWebkitMaskBoxImageRepeat: {
1497         RefPtr<CSSValue> result;
1498         if (parseBorderImageRepeat(result)) {
1499             addProperty(propId, result, important);
1500             return true;
1501         }
1502         break;
1503     }
1504     case CSSPropertyBorderImageSlice:
1505     case CSSPropertyWebkitMaskBoxImageSlice: {
1506         RefPtr<CSSBorderImageSliceValue> result;
1507         if (parseBorderImageSlice(propId, result)) {
1508             addProperty(propId, result, important);
1509             return true;
1510         }
1511         break;
1512     }
1513     case CSSPropertyBorderImageWidth:
1514     case CSSPropertyWebkitMaskBoxImageWidth: {
1515         RefPtr<CSSPrimitiveValue> result;
1516         if (parseBorderImageWidth(result)) {
1517             addProperty(propId, result, important);
1518             return true;
1519         }
1520         break;
1521     }
1522     case CSSPropertyBorderTopRightRadius:
1523     case CSSPropertyBorderTopLeftRadius:
1524     case CSSPropertyBorderBottomLeftRadius:
1525     case CSSPropertyBorderBottomRightRadius: {
1526         if (num != 1 && num != 2)
1527             return false;
1528         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg, m_strict);
1529         if (!validPrimitive)
1530             return false;
1531         RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
1532         RefPtr<CSSPrimitiveValue> parsedValue2;
1533         if (num == 2) {
1534             value = m_valueList->next();
1535             validPrimitive = validUnit(value, FLength | FPercent | FNonNeg, m_strict);
1536             if (!validPrimitive)
1537                 return false;
1538             parsedValue2 = createPrimitiveNumericValue(value);
1539         } else
1540             parsedValue2 = parsedValue1;
1541
1542         RefPtr<Pair> pair = Pair::create(parsedValue1.release(), parsedValue2.release());
1543         RefPtr<CSSPrimitiveValue> val = cssValuePool()->createValue(pair.release());
1544         addProperty(propId, val.release(), important);
1545         return true;
1546     }
1547     case CSSPropertyWebkitAspectRatio:
1548         return parseAspectRatio(important);
1549     case CSSPropertyBorderRadius:
1550     case CSSPropertyWebkitBorderRadius:
1551         return parseBorderRadius(propId, important);
1552     case CSSPropertyOutlineOffset:
1553         validPrimitive = validUnit(value, FLength | FPercent, m_strict);
1554         break;
1555     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
1556     case CSSPropertyBoxShadow:
1557     case CSSPropertyWebkitBoxShadow:
1558         if (id == CSSValueNone)
1559             validPrimitive = true;
1560         else {
1561             RefPtr<CSSValueList> shadowValueList = parseShadow(m_valueList.get(), propId);
1562             if (shadowValueList) {
1563                 addProperty(propId, shadowValueList.release(), important);
1564                 m_valueList->next();
1565                 return true;
1566             }
1567             return false;
1568         }
1569         break;
1570     case CSSPropertyWebkitBoxReflect:
1571         if (id == CSSValueNone)
1572             validPrimitive = true;
1573         else
1574             return parseReflect(propId, important);
1575         break;
1576     case CSSPropertyOpacity:
1577         validPrimitive = validUnit(value, FNumber, m_strict);
1578         break;
1579     case CSSPropertyWebkitBoxAlign:
1580         if (id == CSSValueStretch || id == CSSValueStart || id == CSSValueEnd ||
1581             id == CSSValueCenter || id == CSSValueBaseline)
1582             validPrimitive = true;
1583         break;
1584     case CSSPropertyWebkitBoxDirection:
1585         if (id == CSSValueNormal || id == CSSValueReverse)
1586             validPrimitive = true;
1587         break;
1588     case CSSPropertyWebkitBoxLines:
1589         if (id == CSSValueSingle || id == CSSValueMultiple)
1590             validPrimitive = true;
1591         break;
1592     case CSSPropertyWebkitBoxOrient:
1593         if (id == CSSValueHorizontal || id == CSSValueVertical ||
1594             id == CSSValueInlineAxis || id == CSSValueBlockAxis)
1595             validPrimitive = true;
1596         break;
1597     case CSSPropertyWebkitBoxPack:
1598         if (id == CSSValueStart || id == CSSValueEnd ||
1599             id == CSSValueCenter || id == CSSValueJustify)
1600             validPrimitive = true;
1601         break;
1602     case CSSPropertyWebkitBoxFlex:
1603         validPrimitive = validUnit(value, FNumber, m_strict);
1604         break;
1605     case CSSPropertyWebkitBoxFlexGroup:
1606     case CSSPropertyWebkitBoxOrdinalGroup:
1607         validPrimitive = validUnit(value, FInteger | FNonNeg, true);
1608         break;
1609     case CSSPropertyBoxSizing:
1610         validPrimitive = id == CSSValueBorderBox || id == CSSValueContentBox;
1611         break;
1612     case CSSPropertyWebkitColorCorrection:
1613         validPrimitive = id == CSSValueSrgb || id == CSSValueDefault;
1614         break;
1615 #if ENABLE(CSS_FILTERS)
1616     case CSSPropertyWebkitFilter:
1617         if (id == CSSValueNone)
1618             validPrimitive = true;
1619         else {
1620             RefPtr<CSSValue> val = parseFilter();
1621             if (val) {
1622                 addProperty(propId, val, important);
1623                 return true;
1624             }
1625             return false;
1626         }
1627         break;
1628 #endif
1629     case CSSPropertyWebkitFlexOrder:
1630         if (validUnit(value, FInteger, true)) {
1631             // 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.
1632             parsedValue = cssValuePool()->createValue(max(static_cast<double>(std::numeric_limits<int>::min() + 2), value->fValue),
1633                                                              static_cast<CSSPrimitiveValue::UnitTypes>(value->unit));
1634             m_valueList->next();
1635         }
1636         break;
1637     case CSSPropertyWebkitFlexPack:
1638         validPrimitive = id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueJustify;
1639         break;
1640     case CSSPropertyWebkitFlexItemAlign:
1641         validPrimitive = id == CSSValueAuto || id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueBaseline || id == CSSValueStretch;
1642         break;
1643     case CSSPropertyWebkitFlexDirection:
1644         validPrimitive = id == CSSValueRow || id == CSSValueRowReverse || id == CSSValueColumn || id == CSSValueColumnReverse;
1645         break;
1646     case CSSPropertyWebkitFlexWrap:
1647         validPrimitive = id == CSSValueNowrap || id == CSSValueWrap || id == CSSValueWrapReverse;
1648         break;
1649     case CSSPropertyWebkitMarquee: {
1650         const int properties[5] = { CSSPropertyWebkitMarqueeDirection, CSSPropertyWebkitMarqueeIncrement,
1651                                     CSSPropertyWebkitMarqueeRepetition,
1652                                     CSSPropertyWebkitMarqueeStyle, CSSPropertyWebkitMarqueeSpeed };
1653         return parseShorthand(propId, properties, 5, important);
1654     }
1655     case CSSPropertyWebkitMarqueeDirection:
1656         if (id == CSSValueForwards || id == CSSValueBackwards || id == CSSValueAhead ||
1657             id == CSSValueReverse || id == CSSValueLeft || id == CSSValueRight || id == CSSValueDown ||
1658             id == CSSValueUp || id == CSSValueAuto)
1659             validPrimitive = true;
1660         break;
1661     case CSSPropertyWebkitMarqueeIncrement:
1662         if (id == CSSValueSmall || id == CSSValueLarge || id == CSSValueMedium)
1663             validPrimitive = true;
1664         else
1665             validPrimitive = validUnit(value, FLength | FPercent, m_strict);
1666         break;
1667     case CSSPropertyWebkitMarqueeStyle:
1668         if (id == CSSValueNone || id == CSSValueSlide || id == CSSValueScroll || id == CSSValueAlternate)
1669             validPrimitive = true;
1670         break;
1671     case CSSPropertyWebkitMarqueeRepetition:
1672         if (id == CSSValueInfinite)
1673             validPrimitive = true;
1674         else
1675             validPrimitive = validUnit(value, FInteger | FNonNeg, m_strict);
1676         break;
1677     case CSSPropertyWebkitMarqueeSpeed:
1678         if (id == CSSValueNormal || id == CSSValueSlow || id == CSSValueFast)
1679             validPrimitive = true;
1680         else
1681             validPrimitive = validUnit(value, FTime | FInteger | FNonNeg, m_strict);
1682         break;
1683     case CSSPropertyWebkitFlowInto:
1684         return parseFlowThread(propId, important);
1685     case CSSPropertyWebkitFlowFrom:
1686         return parseRegionThread(propId, important);
1687     case CSSPropertyWebkitRegionOverflow:
1688         if (id == CSSValueAuto || id == CSSValueBreak)
1689             validPrimitive = true;
1690         break;
1691
1692     case CSSPropertyWebkitUserDrag: // auto | none | element
1693         if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueElement)
1694             validPrimitive = true;
1695         break;
1696     case CSSPropertyWebkitUserModify: // read-only | read-write
1697         if (id == CSSValueReadOnly || id == CSSValueReadWrite || id == CSSValueReadWritePlaintextOnly)
1698             validPrimitive = true;
1699         break;
1700     case CSSPropertyWebkitUserSelect: // auto | none | text
1701         if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueText)
1702             validPrimitive = true;
1703         break;
1704     case CSSPropertyTextOverflow: // clip | ellipsis
1705         if (id == CSSValueClip || id == CSSValueEllipsis)
1706             validPrimitive = true;
1707         break;
1708     case CSSPropertyWebkitTransform:
1709         if (id == CSSValueNone)
1710             validPrimitive = true;
1711         else {
1712             PassRefPtr<CSSValue> val = parseTransform();
1713             if (val) {
1714                 addProperty(propId, val, important);
1715                 return true;
1716             }
1717             return false;
1718         }
1719         break;
1720     case CSSPropertyWebkitTransformOrigin:
1721     case CSSPropertyWebkitTransformOriginX:
1722     case CSSPropertyWebkitTransformOriginY:
1723     case CSSPropertyWebkitTransformOriginZ: {
1724         RefPtr<CSSValue> val1;
1725         RefPtr<CSSValue> val2;
1726         RefPtr<CSSValue> val3;
1727         int propId1, propId2, propId3;
1728         if (parseTransformOrigin(propId, propId1, propId2, propId3, val1, val2, val3)) {
1729             addProperty(propId1, val1.release(), important);
1730             if (val2)
1731                 addProperty(propId2, val2.release(), important);
1732             if (val3)
1733                 addProperty(propId3, val3.release(), important);
1734             return true;
1735         }
1736         return false;
1737     }
1738     case CSSPropertyWebkitTransformStyle:
1739         if (value->id == CSSValueFlat || value->id == CSSValuePreserve3d)
1740             validPrimitive = true;
1741         break;
1742     case CSSPropertyWebkitBackfaceVisibility:
1743         if (value->id == CSSValueVisible || value->id == CSSValueHidden)
1744             validPrimitive = true;
1745         break;
1746     case CSSPropertyWebkitPrintColorAdjust:
1747         if (value->id == CSSValueExact || value->id == CSSValueEconomy)
1748             validPrimitive = true;
1749         break;
1750     case CSSPropertyWebkitPerspective:
1751         if (id == CSSValueNone)
1752             validPrimitive = true;
1753         else {
1754             // Accepting valueless numbers is a quirk of the -webkit prefixed version of the property.
1755             if (validUnit(value, FNumber | FLength | FNonNeg, m_strict)) {
1756                 RefPtr<CSSValue> val = createPrimitiveNumericValue(value);
1757                 if (val) {
1758                     addProperty(propId, val.release(), important);
1759                     return true;
1760                 }
1761                 return false;
1762             }
1763         }
1764         break;
1765     case CSSPropertyWebkitPerspectiveOrigin:
1766     case CSSPropertyWebkitPerspectiveOriginX:
1767     case CSSPropertyWebkitPerspectiveOriginY: {
1768         RefPtr<CSSValue> val1;
1769         RefPtr<CSSValue> val2;
1770         int propId1, propId2;
1771         if (parsePerspectiveOrigin(propId, propId1, propId2, val1, val2)) {
1772             addProperty(propId1, val1.release(), important);
1773             if (val2)
1774                 addProperty(propId2, val2.release(), important);
1775             return true;
1776         }
1777         return false;
1778     }
1779     case CSSPropertyWebkitAnimationDelay:
1780     case CSSPropertyWebkitAnimationDirection:
1781     case CSSPropertyWebkitAnimationDuration:
1782     case CSSPropertyWebkitAnimationFillMode:
1783     case CSSPropertyWebkitAnimationName:
1784     case CSSPropertyWebkitAnimationPlayState:
1785     case CSSPropertyWebkitAnimationIterationCount:
1786     case CSSPropertyWebkitAnimationTimingFunction:
1787     case CSSPropertyWebkitTransitionDelay:
1788     case CSSPropertyWebkitTransitionDuration:
1789     case CSSPropertyWebkitTransitionTimingFunction:
1790     case CSSPropertyWebkitTransitionProperty: {
1791         RefPtr<CSSValue> val;
1792         if (parseAnimationProperty(propId, val)) {
1793             addProperty(propId, val.release(), important);
1794             return true;
1795         }
1796         return false;
1797     }
1798 #if ENABLE(CSS_GRID_LAYOUT)
1799     case CSSPropertyWebkitGridColumns:
1800     case CSSPropertyWebkitGridRows:
1801         return parseGridTrackList(propId, important);
1802 #endif
1803     case CSSPropertyWebkitMarginCollapse: {
1804         const int properties[2] = { CSSPropertyWebkitMarginBeforeCollapse,
1805             CSSPropertyWebkitMarginAfterCollapse };
1806         if (num == 1) {
1807             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
1808             if (!parseValue(properties[0], important))
1809                 return false;
1810             CSSValue* value = m_parsedProperties[m_numParsedProperties-1]->value();
1811             addProperty(properties[1], value, important);
1812             return true;
1813         }
1814         else if (num == 2) {
1815             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
1816             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
1817                 return false;
1818             return true;
1819         }
1820         return false;
1821     }
1822     case CSSPropertyWebkitMarginBeforeCollapse:
1823     case CSSPropertyWebkitMarginAfterCollapse:
1824     case CSSPropertyWebkitMarginTopCollapse:
1825     case CSSPropertyWebkitMarginBottomCollapse:
1826         if (id == CSSValueCollapse || id == CSSValueSeparate || id == CSSValueDiscard)
1827             validPrimitive = true;
1828         break;
1829     case CSSPropertyTextLineThroughMode:
1830     case CSSPropertyTextOverlineMode:
1831     case CSSPropertyTextUnderlineMode:
1832         if (id == CSSValueContinuous || id == CSSValueSkipWhiteSpace)
1833             validPrimitive = true;
1834         break;
1835     case CSSPropertyTextLineThroughStyle:
1836     case CSSPropertyTextOverlineStyle:
1837     case CSSPropertyTextUnderlineStyle:
1838         if (id == CSSValueNone || id == CSSValueSolid || id == CSSValueDouble ||
1839             id == CSSValueDashed || id == CSSValueDotDash || id == CSSValueDotDotDash ||
1840             id == CSSValueWave)
1841             validPrimitive = true;
1842         break;
1843     case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision
1844         if (id == CSSValueAuto || id == CSSValueOptimizespeed || id == CSSValueOptimizelegibility
1845             || id == CSSValueGeometricprecision)
1846             validPrimitive = true;
1847         break;
1848     case CSSPropertyTextLineThroughWidth:
1849     case CSSPropertyTextOverlineWidth:
1850     case CSSPropertyTextUnderlineWidth:
1851         if (id == CSSValueAuto || id == CSSValueNormal || id == CSSValueThin ||
1852             id == CSSValueMedium || id == CSSValueThick)
1853             validPrimitive = true;
1854         else
1855             validPrimitive = !id && validUnit(value, FNumber | FLength | FPercent, m_strict);
1856         break;
1857     case CSSPropertyResize: // none | both | horizontal | vertical | auto
1858         if (id == CSSValueNone || id == CSSValueBoth || id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueAuto)
1859             validPrimitive = true;
1860         break;
1861     case CSSPropertyWebkitColumnCount:
1862         if (id == CSSValueAuto)
1863             validPrimitive = true;
1864         else
1865             validPrimitive = !id && validUnit(value, FInteger | FNonNeg, false);
1866         break;
1867     case CSSPropertyWebkitColumnGap:         // normal | <length>
1868         if (id == CSSValueNormal)
1869             validPrimitive = true;
1870         else
1871             validPrimitive = validUnit(value, FLength | FNonNeg, m_strict);
1872         break;
1873     case CSSPropertyWebkitColumnAxis:
1874         if (id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueAuto)
1875             validPrimitive = true;
1876         break;
1877     case CSSPropertyWebkitColumnSpan:        // all | 1
1878         if (id == CSSValueAll)
1879             validPrimitive = true;
1880         else
1881             validPrimitive = validUnit(value, FNumber | FNonNeg, m_strict) && value->fValue == 1;
1882         break;
1883     case CSSPropertyWebkitColumnWidth:         // auto | <length>
1884         if (id == CSSValueAuto)
1885             validPrimitive = true;
1886         else // Always parse this property in strict mode, since it would be ambiguous otherwise when used in the 'columns' shorthand property.
1887             validPrimitive = validUnit(value, FLength, true);
1888         break;
1889     case CSSPropertyPointerEvents:
1890         // none | visiblePainted | visibleFill | visibleStroke | visible |
1891         // painted | fill | stroke | auto | all | inherit
1892         if (id == CSSValueVisible || id == CSSValueNone || id == CSSValueAll || id == CSSValueAuto ||
1893             (id >= CSSValueVisiblepainted && id <= CSSValueStroke))
1894             validPrimitive = true;
1895         break;
1896     case CSSPropertyImageRendering: // auto | optimizeContrast
1897         if (id == CSSValueAuto || id == CSSValueWebkitOptimizeContrast)
1898             validPrimitive = true;
1899         break;
1900     // End of CSS3 properties
1901
1902     // Apple specific properties.  These will never be standardized and are purely to
1903     // support custom WebKit-based Apple applications.
1904     case CSSPropertyWebkitLineClamp:
1905         // When specifying number of lines, don't allow 0 as a valid value
1906         // When specifying either type of unit, require non-negative integers
1907         validPrimitive = (!id && (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE || value->fValue) && validUnit(value, FInteger | FPercent | FNonNeg, false));
1908         break;
1909     case CSSPropertyWebkitTextSizeAdjust:
1910         if (id == CSSValueAuto || id == CSSValueNone)
1911             validPrimitive = true;
1912         break;
1913     case CSSPropertyWebkitRtlOrdering:
1914         if (id == CSSValueLogical || id == CSSValueVisual)
1915             validPrimitive = true;
1916         break;
1917
1918     case CSSPropertyWebkitFontSizeDelta:           // <length>
1919         validPrimitive = validUnit(value, FLength, m_strict);
1920         break;
1921
1922     case CSSPropertyWebkitNbspMode:     // normal | space
1923         if (id == CSSValueNormal || id == CSSValueSpace)
1924             validPrimitive = true;
1925         break;
1926
1927     case CSSPropertyWebkitLineBreak:   // normal | after-white-space
1928         if (id == CSSValueNormal || id == CSSValueAfterWhiteSpace)
1929             validPrimitive = true;
1930         break;
1931
1932     case CSSPropertyWebkitMatchNearestMailBlockquoteColor:   // normal | match
1933         if (id == CSSValueNormal || id == CSSValueMatch)
1934             validPrimitive = true;
1935         break;
1936
1937     case CSSPropertyWebkitHighlight:
1938         if (id == CSSValueNone || value->unit == CSSPrimitiveValue::CSS_STRING)
1939             validPrimitive = true;
1940         break;
1941
1942     case CSSPropertyWebkitHyphens:
1943         if (id == CSSValueNone || id == CSSValueManual || id == CSSValueAuto)
1944             validPrimitive = true;
1945         break;
1946
1947     case CSSPropertyWebkitHyphenateCharacter:
1948         if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
1949             validPrimitive = true;
1950         break;
1951
1952     case CSSPropertyWebkitHyphenateLimitBefore:
1953     case CSSPropertyWebkitHyphenateLimitAfter:
1954         if (id == CSSValueAuto || validUnit(value, FInteger | FNonNeg, true))
1955             validPrimitive = true;
1956         break;
1957
1958     case CSSPropertyWebkitHyphenateLimitLines:
1959         if (id == CSSValueNoLimit || validUnit(value, FInteger | FNonNeg, true))
1960             validPrimitive = true;
1961         break;
1962
1963     case CSSPropertyWebkitLineGrid:
1964         if (id == CSSValueNone)
1965             validPrimitive = true;
1966         else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
1967             String lineGridValue = String(value->string);
1968             if (!lineGridValue.isEmpty()) {
1969                 addProperty(propId, cssValuePool()->createValue(lineGridValue, CSSPrimitiveValue::CSS_STRING), important);
1970                 return true;
1971             }
1972         }
1973         break;
1974     case CSSPropertyWebkitLineGridSnap:
1975         if (id == CSSValueNone || id == CSSValueBaseline || id == CSSValueBounds)
1976             validPrimitive = true;
1977         break;
1978     case CSSPropertyWebkitLocale:
1979         if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
1980             validPrimitive = true;
1981         break;
1982
1983     case CSSPropertyWebkitBorderFit:
1984         if (id == CSSValueBorder || id == CSSValueLines)
1985             validPrimitive = true;
1986         break;
1987
1988     case CSSPropertyWebkitTextSecurity:
1989         // disc | circle | square | none | inherit
1990         if (id == CSSValueDisc || id == CSSValueCircle || id == CSSValueSquare|| id == CSSValueNone)
1991             validPrimitive = true;
1992         break;
1993
1994     case CSSPropertyWebkitFontSmoothing:
1995         if (id == CSSValueAuto || id == CSSValueNone
1996             || id == CSSValueAntialiased || id == CSSValueSubpixelAntialiased)
1997             validPrimitive = true;
1998         break;
1999
2000 #if ENABLE(DASHBOARD_SUPPORT)
2001     case CSSPropertyWebkitDashboardRegion: // <dashboard-region> | <dashboard-region>
2002         if (value->unit == CSSParserValue::Function || id == CSSValueNone)
2003             return parseDashboardRegions(propId, important);
2004         break;
2005 #endif
2006     // End Apple-specific properties
2007
2008 #if ENABLE(TOUCH_EVENTS)
2009     case CSSPropertyWebkitTapHighlightColor:
2010         if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu
2011             || (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && !m_strict)) {
2012             validPrimitive = true;
2013         } else {
2014             parsedValue = parseColor();
2015             if (parsedValue)
2016                 m_valueList->next();
2017         }
2018         break;
2019 #endif
2020         /* shorthand properties */
2021     case CSSPropertyBackground: {
2022         // Position must come before color in this array because a plain old "0" is a legal color
2023         // in quirks mode but it's usually the X coordinate of a position.
2024         // FIXME: Add CSSPropertyBackgroundSize to the shorthand.
2025         const int properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat,
2026                                    CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin,
2027                                    CSSPropertyBackgroundClip, CSSPropertyBackgroundColor };
2028         return parseFillShorthand(propId, properties, 7, important);
2029     }
2030     case CSSPropertyWebkitMask: {
2031         const int properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat,
2032                                    CSSPropertyWebkitMaskAttachment, CSSPropertyWebkitMaskPosition,
2033                                    CSSPropertyWebkitMaskOrigin, CSSPropertyWebkitMaskClip };
2034         return parseFillShorthand(propId, properties, 6, important);
2035     }
2036     case CSSPropertyBorder:
2037         // [ 'border-width' || 'border-style' || <color> ] | inherit
2038     {
2039         const int properties[3] = { CSSPropertyBorderWidth, CSSPropertyBorderStyle,
2040                                     CSSPropertyBorderColor };
2041         if (parseShorthand(propId, properties, 3, important)) {
2042             // The CSS3 Borders and Backgrounds specification says that border also resets border-image. It's as
2043             // though a value of none was specified for the image.
2044             addProperty(CSSPropertyBorderImage, cssValuePool()->createImplicitInitialValue(), important);
2045             return true;
2046         }
2047         return false;
2048     }
2049     case CSSPropertyBorderTop:
2050         // [ 'border-top-width' || 'border-style' || <color> ] | inherit
2051     {
2052         const int properties[3] = { CSSPropertyBorderTopWidth, CSSPropertyBorderTopStyle,
2053                                     CSSPropertyBorderTopColor};
2054         return parseShorthand(propId, properties, 3, important);
2055     }
2056     case CSSPropertyBorderRight:
2057         // [ 'border-right-width' || 'border-style' || <color> ] | inherit
2058     {
2059         const int properties[3] = { CSSPropertyBorderRightWidth, CSSPropertyBorderRightStyle,
2060                                     CSSPropertyBorderRightColor };
2061         return parseShorthand(propId, properties, 3, important);
2062     }
2063     case CSSPropertyBorderBottom:
2064         // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit
2065     {
2066         const int properties[3] = { CSSPropertyBorderBottomWidth, CSSPropertyBorderBottomStyle,
2067                                     CSSPropertyBorderBottomColor };
2068         return parseShorthand(propId, properties, 3, important);
2069     }
2070     case CSSPropertyBorderLeft:
2071         // [ 'border-left-width' || 'border-style' || <color> ] | inherit
2072     {
2073         const int properties[3] = { CSSPropertyBorderLeftWidth, CSSPropertyBorderLeftStyle,
2074                                     CSSPropertyBorderLeftColor };
2075         return parseShorthand(propId, properties, 3, important);
2076     }
2077     case CSSPropertyWebkitBorderStart:
2078     {
2079         const int properties[3] = { CSSPropertyWebkitBorderStartWidth, CSSPropertyWebkitBorderStartStyle,
2080             CSSPropertyWebkitBorderStartColor };
2081         return parseShorthand(propId, properties, 3, important);
2082     }
2083     case CSSPropertyWebkitBorderEnd:
2084     {
2085         const int properties[3] = { CSSPropertyWebkitBorderEndWidth, CSSPropertyWebkitBorderEndStyle,
2086             CSSPropertyWebkitBorderEndColor };
2087         return parseShorthand(propId, properties, 3, important);
2088     }
2089     case CSSPropertyWebkitBorderBefore:
2090     {
2091         const int properties[3] = { CSSPropertyWebkitBorderBeforeWidth, CSSPropertyWebkitBorderBeforeStyle,
2092             CSSPropertyWebkitBorderBeforeColor };
2093         return parseShorthand(propId, properties, 3, important);
2094     }
2095     case CSSPropertyWebkitBorderAfter:
2096     {
2097         const int properties[3] = { CSSPropertyWebkitBorderAfterWidth, CSSPropertyWebkitBorderAfterStyle,
2098             CSSPropertyWebkitBorderAfterColor };
2099         return parseShorthand(propId, properties, 3, important);
2100     }
2101     case CSSPropertyOutline:
2102         // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit
2103     {
2104         const int properties[3] = { CSSPropertyOutlineWidth, CSSPropertyOutlineStyle,
2105                                     CSSPropertyOutlineColor };
2106         return parseShorthand(propId, properties, 3, important);
2107     }
2108     case CSSPropertyBorderColor:
2109         // <color>{1,4} | inherit
2110     {
2111         const int properties[4] = { CSSPropertyBorderTopColor, CSSPropertyBorderRightColor,
2112                                     CSSPropertyBorderBottomColor, CSSPropertyBorderLeftColor };
2113         return parse4Values(propId, properties, important);
2114     }
2115     case CSSPropertyBorderWidth:
2116         // <border-width>{1,4} | inherit
2117     {
2118         const int properties[4] = { CSSPropertyBorderTopWidth, CSSPropertyBorderRightWidth,
2119                                     CSSPropertyBorderBottomWidth, CSSPropertyBorderLeftWidth };
2120         return parse4Values(propId, properties, important);
2121     }
2122     case CSSPropertyBorderStyle:
2123         // <border-style>{1,4} | inherit
2124     {
2125         const int properties[4] = { CSSPropertyBorderTopStyle, CSSPropertyBorderRightStyle,
2126                                     CSSPropertyBorderBottomStyle, CSSPropertyBorderLeftStyle };
2127         return parse4Values(propId, properties, important);
2128     }
2129     case CSSPropertyMargin:
2130         // <margin-width>{1,4} | inherit
2131     {
2132         const int properties[4] = { CSSPropertyMarginTop, CSSPropertyMarginRight,
2133                                     CSSPropertyMarginBottom, CSSPropertyMarginLeft };
2134         return parse4Values(propId, properties, important);
2135     }
2136     case CSSPropertyPadding:
2137         // <padding-width>{1,4} | inherit
2138     {
2139         const int properties[4] = { CSSPropertyPaddingTop, CSSPropertyPaddingRight,
2140                                     CSSPropertyPaddingBottom, CSSPropertyPaddingLeft };
2141         return parse4Values(propId, properties, important);
2142     }
2143     case CSSPropertyWebkitFlexFlow:
2144     {
2145         const int properties[] = { CSSPropertyWebkitFlexDirection, CSSPropertyWebkitFlexWrap };
2146         return parseShorthand(propId, properties, 2, important);
2147     }
2148     case CSSPropertyFont:
2149         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
2150         // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit
2151         if (id >= CSSValueCaption && id <= CSSValueStatusBar)
2152             validPrimitive = true;
2153         else
2154             return parseFont(important);
2155         break;
2156     case CSSPropertyListStyle:
2157     {
2158         const int properties[3] = { CSSPropertyListStyleType, CSSPropertyListStylePosition,
2159                                     CSSPropertyListStyleImage };
2160         return parseShorthand(propId, properties, 3, important);
2161     }
2162     case CSSPropertyWebkitColumns: {
2163         const int properties[2] = { CSSPropertyWebkitColumnWidth, CSSPropertyWebkitColumnCount };
2164         return parseShorthand(propId, properties, 2, important);
2165     }
2166     case CSSPropertyWebkitColumnRule: {
2167         const int properties[3] = { CSSPropertyWebkitColumnRuleWidth, CSSPropertyWebkitColumnRuleStyle,
2168                                     CSSPropertyWebkitColumnRuleColor };
2169         return parseShorthand(propId, properties, 3, important);
2170     }
2171     case CSSPropertyWebkitTextStroke: {
2172         const int properties[2] = { CSSPropertyWebkitTextStrokeWidth, CSSPropertyWebkitTextStrokeColor };
2173         return parseShorthand(propId, properties, 2, important);
2174     }
2175     case CSSPropertyWebkitAnimation:
2176         return parseAnimationShorthand(important);
2177     case CSSPropertyWebkitTransition:
2178         return parseTransitionShorthand(important);
2179     case CSSPropertyInvalid:
2180         return false;
2181     case CSSPropertyPage:
2182         return parsePage(propId, important);
2183     case CSSPropertyFontStretch:
2184     case CSSPropertyTextLineThrough:
2185     case CSSPropertyTextOverline:
2186     case CSSPropertyTextUnderline:
2187         return false;
2188     // CSS Text Layout Module Level 3: Vertical writing support
2189     case CSSPropertyWebkitWritingMode:
2190         if (id >= CSSValueHorizontalTb && id <= CSSValueHorizontalBt)
2191             validPrimitive = true;
2192         break;
2193
2194     case CSSPropertyWebkitTextCombine:
2195         if (id == CSSValueNone || id == CSSValueHorizontal)
2196             validPrimitive = true;
2197         break;
2198
2199     case CSSPropertyWebkitTextEmphasis: {
2200         const int properties[] = { CSSPropertyWebkitTextEmphasisStyle, CSSPropertyWebkitTextEmphasisColor };
2201         return parseShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);
2202     }
2203
2204     case CSSPropertyWebkitTextEmphasisPosition:
2205         if (id == CSSValueOver || id == CSSValueUnder)
2206             validPrimitive = true;
2207         break;
2208
2209     case CSSPropertyWebkitTextEmphasisStyle:
2210         return parseTextEmphasisStyle(important);
2211
2212     case CSSPropertyWebkitTextOrientation:
2213         // FIXME: For now just support upright and vertical-right.
2214         if (id == CSSValueVerticalRight || id == CSSValueUpright)
2215             validPrimitive = true;
2216         break;
2217
2218     case CSSPropertyWebkitLineBoxContain:
2219         if (id == CSSValueNone)
2220             validPrimitive = true;
2221         else
2222             return parseLineBoxContain(important);
2223         break;
2224     case CSSPropertyWebkitFontFeatureSettings:
2225         if (id == CSSValueNormal)
2226             validPrimitive = true;
2227         else
2228             return parseFontFeatureSettings(important);
2229         break;
2230
2231     case CSSPropertyWebkitFontKerning:
2232         if (id == CSSValueAuto || id == CSSValueNormal || id == CSSValueNone)
2233             validPrimitive = true;
2234         break;
2235
2236     case CSSPropertyWebkitWrapShapeInside:
2237     case CSSPropertyWebkitWrapShapeOutside:
2238         if (id == CSSValueAuto)
2239             validPrimitive = true;
2240         else if (value->unit == CSSParserValue::Function)
2241             return parseWrapShape((propId == CSSPropertyWebkitWrapShapeInside), important);
2242         break;
2243     case CSSPropertyWebkitWrapFlow:
2244         if (id == CSSValueAuto || id == CSSValueBoth || id == CSSValueLeft || id == CSSValueRight || id == CSSValueMaximum || id == CSSValueClear)
2245             validPrimitive = true;
2246         break;
2247
2248     case CSSPropertyWebkitWrapThrough:
2249         if (id == CSSValueWrap || id == CSSValueNone)
2250             validPrimitive = true;
2251         break;
2252     case CSSPropertyWebkitWrapMargin:
2253     case CSSPropertyWebkitWrapPadding:
2254         validPrimitive = (!id && validUnit(value, FLength | FNonNeg, m_strict));
2255         break;
2256     case CSSPropertyWebkitWrap: {
2257         const int properties[] = { CSSPropertyWebkitWrapFlow, CSSPropertyWebkitWrapMargin, CSSPropertyWebkitWrapPadding };
2258         return parseShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);
2259     }
2260 #if ENABLE(SVG)
2261     default:
2262         return parseSVGValue(propId, important);
2263 #endif
2264     }
2265
2266     if (validPrimitive) {
2267         parsedValue = parseValidPrimitive(id, value);
2268         m_valueList->next();
2269     }
2270     if (parsedValue) {
2271         if (!m_valueList->current() || inShorthand()) {
2272             addProperty(propId, parsedValue.release(), important);
2273             return true;
2274         }
2275     }
2276     return false;
2277 }
2278
2279 void CSSParser::addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval)
2280 {
2281     if (lval) {
2282         if (lval->isValueList())
2283             static_cast<CSSValueList*>(lval.get())->append(rval);
2284         else {
2285             PassRefPtr<CSSValue> oldlVal(lval.release());
2286             PassRefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
2287             list->append(oldlVal);
2288             list->append(rval);
2289             lval = list;
2290         }
2291     }
2292     else
2293         lval = rval;
2294 }
2295
2296 static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtr<CSSValue>& cssValue, CSSValuePool* cssValuePool)
2297 {
2298     if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox
2299         || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) {
2300         cssValue = cssValuePool->createIdentifierValue(parserValue->id);
2301         return true;
2302     }
2303     return false;
2304 }
2305
2306 const int cMaxFillProperties = 9;
2307
2308 bool CSSParser::parseFillShorthand(int propId, const int* properties, int numProperties, bool important)
2309 {
2310     ASSERT(numProperties <= cMaxFillProperties);
2311     if (numProperties > cMaxFillProperties)
2312         return false;
2313
2314     ShorthandScope scope(this, propId);
2315
2316     bool parsedProperty[cMaxFillProperties] = { false };
2317     RefPtr<CSSValue> values[cMaxFillProperties];
2318     RefPtr<CSSValue> clipValue;
2319     RefPtr<CSSValue> positionYValue;
2320     RefPtr<CSSValue> repeatYValue;
2321     bool foundClip = false;
2322     int i;
2323
2324     while (m_valueList->current()) {
2325         CSSParserValue* val = m_valueList->current();
2326         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
2327             // We hit the end.  Fill in all remaining values with the initial value.
2328             m_valueList->next();
2329             for (i = 0; i < numProperties; ++i) {
2330                 if (properties[i] == CSSPropertyBackgroundColor && parsedProperty[i])
2331                     // Color is not allowed except as the last item in a list for backgrounds.
2332                     // Reject the entire property.
2333                     return false;
2334
2335                 if (!parsedProperty[i] && properties[i] != CSSPropertyBackgroundColor) {
2336                     addFillValue(values[i], cssValuePool()->createImplicitInitialValue());
2337                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
2338                         addFillValue(positionYValue, cssValuePool()->createImplicitInitialValue());
2339                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
2340                         addFillValue(repeatYValue, cssValuePool()->createImplicitInitialValue());
2341                     if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) {
2342                         // If background-origin wasn't present, then reset background-clip also.
2343                         addFillValue(clipValue, cssValuePool()->createImplicitInitialValue());
2344                     }
2345                 }
2346                 parsedProperty[i] = false;
2347             }
2348             if (!m_valueList->current())
2349                 break;
2350         }
2351
2352         bool found = false;
2353         for (i = 0; !found && i < numProperties; ++i) {
2354             if (!parsedProperty[i]) {
2355                 RefPtr<CSSValue> val1;
2356                 RefPtr<CSSValue> val2;
2357                 int propId1, propId2;
2358                 CSSParserValue* parserValue = m_valueList->current();
2359                 if (parseFillProperty(properties[i], propId1, propId2, val1, val2)) {
2360                     parsedProperty[i] = found = true;
2361                     addFillValue(values[i], val1.release());
2362                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
2363                         addFillValue(positionYValue, val2.release());
2364                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
2365                         addFillValue(repeatYValue, val2.release());
2366                     if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
2367                         // Reparse the value as a clip, and see if we succeed.
2368                         if (parseBackgroundClip(parserValue, val1, cssValuePool()))
2369                             addFillValue(clipValue, val1.release()); // The property parsed successfully.
2370                         else
2371                             addFillValue(clipValue, cssValuePool()->createImplicitInitialValue()); // Some value was used for origin that is not supported by clip. Just reset clip instead.
2372                     }
2373                     if (properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) {
2374                         // Update clipValue
2375                         addFillValue(clipValue, val1.release());
2376                         foundClip = true;
2377                     }
2378                 }
2379             }
2380         }
2381
2382         // if we didn't find at least one match, this is an
2383         // invalid shorthand and we have to ignore it
2384         if (!found)
2385             return false;
2386     }
2387
2388     // Fill in any remaining properties with the initial value.
2389     for (i = 0; i < numProperties; ++i) {
2390         if (!parsedProperty[i]) {
2391             addFillValue(values[i], cssValuePool()->createImplicitInitialValue());
2392             if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
2393                 addFillValue(positionYValue, cssValuePool()->createImplicitInitialValue());
2394             if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
2395                 addFillValue(repeatYValue, cssValuePool()->createImplicitInitialValue());
2396             if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) {
2397                 // If background-origin wasn't present, then reset background-clip also.
2398                 addFillValue(clipValue, cssValuePool()->createImplicitInitialValue());
2399             }
2400         }
2401     }
2402
2403     // Now add all of the properties we found.
2404     for (i = 0; i < numProperties; i++) {
2405         if (properties[i] == CSSPropertyBackgroundPosition) {
2406             addProperty(CSSPropertyBackgroundPositionX, values[i].release(), important);
2407             // it's OK to call positionYValue.release() since we only see CSSPropertyBackgroundPosition once
2408             addProperty(CSSPropertyBackgroundPositionY, positionYValue.release(), important);
2409         } else if (properties[i] == CSSPropertyWebkitMaskPosition) {
2410             addProperty(CSSPropertyWebkitMaskPositionX, values[i].release(), important);
2411             // it's OK to call positionYValue.release() since we only see CSSPropertyWebkitMaskPosition once
2412             addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release(), important);
2413         } else if (properties[i] == CSSPropertyBackgroundRepeat) {
2414             addProperty(CSSPropertyBackgroundRepeatX, values[i].release(), important);
2415             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
2416             addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release(), important);
2417         } else if (properties[i] == CSSPropertyWebkitMaskRepeat) {
2418             addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release(), important);
2419             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
2420             addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release(), important);
2421         } else if ((properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) && !foundClip)
2422             // Value is already set while updating origin
2423             continue;
2424         else
2425             addProperty(properties[i], values[i].release(), important);
2426
2427         // Add in clip values when we hit the corresponding origin property.
2428         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
2429             addProperty(CSSPropertyBackgroundClip, clipValue.release(), important);
2430         else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip)
2431             addProperty(CSSPropertyWebkitMaskClip, clipValue.release(), important);
2432     }
2433
2434     return true;
2435 }
2436
2437 void CSSParser::addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval)
2438 {
2439     if (lval) {
2440         if (lval->isValueList())
2441             static_cast<CSSValueList*>(lval.get())->append(rval);
2442         else {
2443             PassRefPtr<CSSValue> oldVal(lval.release());
2444             PassRefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
2445             list->append(oldVal);
2446             list->append(rval);
2447             lval = list;
2448         }
2449     }
2450     else
2451         lval = rval;
2452 }
2453
2454 bool CSSParser::parseAnimationShorthand(bool important)
2455 {
2456     const int properties[] = {  CSSPropertyWebkitAnimationName,
2457                                 CSSPropertyWebkitAnimationDuration,
2458                                 CSSPropertyWebkitAnimationTimingFunction,
2459                                 CSSPropertyWebkitAnimationDelay,
2460                                 CSSPropertyWebkitAnimationIterationCount,
2461                                 CSSPropertyWebkitAnimationDirection,
2462                                 CSSPropertyWebkitAnimationFillMode };
2463     const int numProperties = WTF_ARRAY_LENGTH(properties);
2464
2465     ShorthandScope scope(this, CSSPropertyWebkitAnimation);
2466
2467     bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary
2468     RefPtr<CSSValue> values[numProperties];
2469
2470     int i;
2471     while (m_valueList->current()) {
2472         CSSParserValue* val = m_valueList->current();
2473         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
2474             // We hit the end.  Fill in all remaining values with the initial value.
2475             m_valueList->next();
2476             for (i = 0; i < numProperties; ++i) {
2477                 if (!parsedProperty[i])
2478                     addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2479                 parsedProperty[i] = false;
2480             }
2481             if (!m_valueList->current())
2482                 break;
2483         }
2484
2485         bool found = false;
2486         for (i = 0; !found && i < numProperties; ++i) {
2487             if (!parsedProperty[i]) {
2488                 RefPtr<CSSValue> val;
2489                 if (parseAnimationProperty(properties[i], val)) {
2490                     parsedProperty[i] = found = true;
2491                     addAnimationValue(values[i], val.release());
2492                 }
2493             }
2494         }
2495
2496         // if we didn't find at least one match, this is an
2497         // invalid shorthand and we have to ignore it
2498         if (!found)
2499             return false;
2500     }
2501
2502     // Fill in any remaining properties with the initial value.
2503     for (i = 0; i < numProperties; ++i) {
2504         if (!parsedProperty[i])
2505             addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2506     }
2507
2508     // Now add all of the properties we found.
2509     for (i = 0; i < numProperties; i++)
2510         addProperty(properties[i], values[i].release(), important);
2511
2512     return true;
2513 }
2514
2515 bool CSSParser::parseTransitionShorthand(bool important)
2516 {
2517     const int properties[] = { CSSPropertyWebkitTransitionProperty,
2518                                CSSPropertyWebkitTransitionDuration,
2519                                CSSPropertyWebkitTransitionTimingFunction,
2520                                CSSPropertyWebkitTransitionDelay };
2521     const int numProperties = WTF_ARRAY_LENGTH(properties);
2522
2523     ShorthandScope scope(this, CSSPropertyWebkitTransition);
2524
2525     bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary
2526     RefPtr<CSSValue> values[numProperties];
2527
2528     int i;
2529     while (m_valueList->current()) {
2530         CSSParserValue* val = m_valueList->current();
2531         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
2532             // We hit the end.  Fill in all remaining values with the initial value.
2533             m_valueList->next();
2534             for (i = 0; i < numProperties; ++i) {
2535                 if (!parsedProperty[i])
2536                     addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2537                 parsedProperty[i] = false;
2538             }
2539             if (!m_valueList->current())
2540                 break;
2541         }
2542
2543         bool found = false;
2544         for (i = 0; !found && i < numProperties; ++i) {
2545             if (!parsedProperty[i]) {
2546                 RefPtr<CSSValue> val;
2547                 if (parseAnimationProperty(properties[i], val)) {
2548                     parsedProperty[i] = found = true;
2549                     addAnimationValue(values[i], val.release());
2550                 }
2551             }
2552         }
2553
2554         // if we didn't find at least one match, this is an
2555         // invalid shorthand and we have to ignore it
2556         if (!found)
2557             return false;
2558     }
2559
2560     // Fill in any remaining properties with the initial value.
2561     for (i = 0; i < numProperties; ++i) {
2562         if (!parsedProperty[i])
2563             addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2564     }
2565
2566     // Now add all of the properties we found.
2567     for (i = 0; i < numProperties; i++)
2568         addProperty(properties[i], values[i].release(), important);
2569
2570     return true;
2571 }
2572
2573 bool CSSParser::parseShorthand(int propId, const int *properties, int numProperties, bool important)
2574 {
2575     // We try to match as many properties as possible
2576     // We set up an array of booleans to mark which property has been found,
2577     // and we try to search for properties until it makes no longer any sense.
2578     ShorthandScope scope(this, propId);
2579
2580     bool found = false;
2581     bool fnd[6]; // Trust me ;)
2582     for (int i = 0; i < numProperties; i++)
2583         fnd[i] = false;
2584
2585     while (m_valueList->current()) {
2586         found = false;
2587         for (int propIndex = 0; !found && propIndex < numProperties; ++propIndex) {
2588             if (!fnd[propIndex]) {
2589                 if (parseValue(properties[propIndex], important))
2590                     fnd[propIndex] = found = true;
2591             }
2592         }
2593
2594         // if we didn't find at least one match, this is an
2595         // invalid shorthand and we have to ignore it
2596         if (!found)
2597             return false;
2598     }
2599
2600     // Fill in any remaining properties with the initial value.
2601     ImplicitScope implicitScope(this, PropertyImplicit);
2602     for (int i = 0; i < numProperties; ++i) {
2603         if (!fnd[i])
2604             addProperty(properties[i], cssValuePool()->createImplicitInitialValue(), important);
2605     }
2606
2607     return true;
2608 }
2609
2610 bool CSSParser::parse4Values(int propId, const int *properties,  bool important)
2611 {
2612     /* From the CSS 2 specs, 8.3
2613      * If there is only one value, it applies to all sides. If there are two values, the top and
2614      * bottom margins are set to the first value and the right and left margins are set to the second.
2615      * If there are three values, the top is set to the first value, the left and right are set to the
2616      * second, and the bottom is set to the third. If there are four values, they apply to the top,
2617      * right, bottom, and left, respectively.
2618      */
2619
2620     int num = inShorthand() ? 1 : m_valueList->size();
2621
2622     ShorthandScope scope(this, propId);
2623
2624     // the order is top, right, bottom, left
2625     switch (num) {
2626         case 1: {
2627             if (!parseValue(properties[0], important))
2628                 return false;
2629             CSSValue *value = m_parsedProperties[m_numParsedProperties-1]->value();
2630             ImplicitScope implicitScope(this, PropertyImplicit);
2631             addProperty(properties[1], value, important);
2632             addProperty(properties[2], value, important);
2633             addProperty(properties[3], value, important);
2634             break;
2635         }
2636         case 2: {
2637             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
2638                 return false;
2639             CSSValue *value = m_parsedProperties[m_numParsedProperties-2]->value();
2640             ImplicitScope implicitScope(this, PropertyImplicit);
2641             addProperty(properties[2], value, important);
2642             value = m_parsedProperties[m_numParsedProperties-2]->value();
2643             addProperty(properties[3], value, important);
2644             break;
2645         }
2646         case 3: {
2647             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
2648                 return false;
2649             CSSValue *value = m_parsedProperties[m_numParsedProperties-2]->value();
2650             ImplicitScope implicitScope(this, PropertyImplicit);
2651             addProperty(properties[3], value, important);
2652             break;
2653         }
2654         case 4: {
2655             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
2656                 !parseValue(properties[2], important) || !parseValue(properties[3], important))
2657                 return false;
2658             break;
2659         }
2660         default: {
2661             return false;
2662         }
2663     }
2664
2665     return true;
2666 }
2667
2668 // auto | <identifier>
2669 bool CSSParser::parsePage(int propId, bool important)
2670 {
2671     ASSERT(propId == CSSPropertyPage);
2672
2673     if (m_valueList->size() != 1)
2674         return false;
2675
2676     CSSParserValue* value = m_valueList->current();
2677     if (!value)
2678         return false;
2679
2680     if (value->id == CSSValueAuto) {
2681         addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important);
2682         return true;
2683     } else if (value->id == 0 && value->unit == CSSPrimitiveValue::CSS_IDENT) {
2684         addProperty(propId, createPrimitiveStringValue(value), important);
2685         return true;
2686     }
2687     return false;
2688 }
2689
2690 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
2691 bool CSSParser::parseSize(int propId, bool important)
2692 {
2693     ASSERT(propId == CSSPropertySize);
2694
2695     if (m_valueList->size() > 2)
2696         return false;
2697
2698     CSSParserValue* value = m_valueList->current();
2699     if (!value)
2700         return false;
2701
2702     RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
2703
2704     // First parameter.
2705     SizeParameterType paramType = parseSizeParameter(parsedValues.get(), value, None);
2706     if (paramType == None)
2707         return false;
2708
2709     // Second parameter, if any.
2710     value = m_valueList->next();
2711     if (value) {
2712         paramType = parseSizeParameter(parsedValues.get(), value, paramType);
2713         if (paramType == None)
2714             return false;
2715     }
2716
2717     addProperty(propId, parsedValues.release(), important);
2718     return true;
2719 }
2720
2721 CSSParser::SizeParameterType CSSParser::parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType)
2722 {
2723     switch (value->id) {
2724     case CSSValueAuto:
2725         if (prevParamType == None) {
2726             parsedValues->append(cssValuePool()->createIdentifierValue(value->id));
2727             return Auto;
2728         }
2729         return None;
2730     case CSSValueLandscape:
2731     case CSSValuePortrait:
2732         if (prevParamType == None || prevParamType == PageSize) {
2733             parsedValues->append(cssValuePool()->createIdentifierValue(value->id));
2734             return Orientation;
2735         }
2736         return None;
2737     case CSSValueA3:
2738     case CSSValueA4:
2739     case CSSValueA5:
2740     case CSSValueB4:
2741     case CSSValueB5:
2742     case CSSValueLedger:
2743     case CSSValueLegal:
2744     case CSSValueLetter:
2745         if (prevParamType == None || prevParamType == Orientation) {
2746             // Normalize to Page Size then Orientation order by prepending.
2747             // This is not specified by the CSS3 Paged Media specification, but for simpler processing later (CSSStyleSelector::applyPageSizeProperty).
2748             parsedValues->prepend(cssValuePool()->createIdentifierValue(value->id));
2749             return PageSize;
2750         }
2751         return None;
2752     case 0:
2753         if (validUnit(value, FLength | FNonNeg, m_strict) && (prevParamType == None || prevParamType == Length)) {
2754             parsedValues->append(createPrimitiveNumericValue(value));
2755             return Length;
2756         }
2757         return None;
2758     default:
2759         return None;
2760     }
2761 }
2762
2763 // [ <string> <string> ]+ | inherit | none
2764 // inherit and none are handled in parseValue.
2765 bool CSSParser::parseQuotes(int propId, bool important)
2766 {
2767     RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
2768     while (CSSParserValue* val = m_valueList->current()) {
2769         RefPtr<CSSValue> parsedValue;
2770         if (val->unit == CSSPrimitiveValue::CSS_STRING)
2771             parsedValue = CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_STRING);
2772         else
2773             break;
2774         values->append(parsedValue.release());
2775         m_valueList->next();
2776     }
2777     if (values->length()) {
2778         addProperty(propId, values.release(), important);
2779         m_valueList->next();
2780         return true;
2781     }
2782     return false;
2783 }
2784
2785 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
2786 // in CSS 2.1 this got somewhat reduced:
2787 // [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
2788 bool CSSParser::parseContent(int propId, bool important)
2789 {
2790     RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
2791
2792     while (CSSParserValue* val = m_valueList->current()) {
2793         RefPtr<CSSValue> parsedValue;
2794         if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) {
2795             // url
2796             // FIXME: The completeURL call should be done when using the CSSImageValue,
2797             // not when creating it.
2798             parsedValue = CSSImageValue::create(m_styleSheet->completeURL(val->string));
2799         } else if (val->unit == CSSParserValue::Function) {
2800             // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
2801             CSSParserValueList* args = val->function->args.get();
2802             if (!args)
2803                 return false;
2804             if (equalIgnoringCase(val->function->name, "attr(")) {
2805                 parsedValue = parseAttr(args);
2806                 if (!parsedValue)
2807                     return false;
2808             } else if (equalIgnoringCase(val->function->name, "counter(")) {
2809                 parsedValue = parseCounterContent(args, false);
2810                 if (!parsedValue)
2811                     return false;
2812             } else if (equalIgnoringCase(val->function->name, "counters(")) {
2813                 parsedValue = parseCounterContent(args, true);
2814                 if (!parsedValue)
2815                     return false;
2816             } else if (isGeneratedImageValue(val)) {
2817                 if (!parseGeneratedImage(m_valueList.get(), parsedValue))
2818                     return false;
2819             } else
2820                 return false;
2821         } else if (val->unit == CSSPrimitiveValue::CSS_IDENT) {
2822             // open-quote
2823             // close-quote
2824             // no-open-quote
2825             // no-close-quote
2826             // inherit
2827             // FIXME: These are not yet implemented (http://bugs.webkit.org/show_bug.cgi?id=6503).
2828             // none
2829             // normal
2830             switch (val->id) {
2831             case CSSValueOpenQuote:
2832             case CSSValueCloseQuote:
2833             case CSSValueNoOpenQuote:
2834             case CSSValueNoCloseQuote:
2835             case CSSValueNone:
2836             case CSSValueNormal:
2837                 parsedValue = cssValuePool()->createIdentifierValue(val->id);
2838             }
2839         } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
2840             parsedValue = createPrimitiveStringValue(val);
2841         }
2842         if (!parsedValue)
2843             break;
2844         values->append(parsedValue.release());
2845         m_valueList->next();
2846     }
2847
2848     if (values->length()) {
2849         addProperty(propId, values.release(), important);
2850         m_valueList->next();
2851         return true;
2852     }
2853
2854     return false;
2855 }
2856
2857 PassRefPtr<CSSValue> CSSParser::parseAttr(CSSParserValueList* args)
2858 {
2859     if (args->size() != 1)
2860         return 0;
2861
2862     CSSParserValue* a = args->current();
2863
2864     if (a->unit != CSSPrimitiveValue::CSS_IDENT)
2865         return 0;
2866
2867     String attrName = a->string;
2868     // CSS allows identifiers with "-" at the start, like "-webkit-mask-image".
2869     // But HTML attribute names can't have those characters, and we should not
2870     // even parse them inside attr().
2871     if (attrName[0] == '-')
2872         return 0;
2873
2874     Document* document = findDocument();
2875     if (document && document->isHTMLDocument())
2876         attrName = attrName.lower();
2877
2878     return cssValuePool()->createValue(attrName, CSSPrimitiveValue::CSS_ATTR);
2879 }
2880
2881 PassRefPtr<CSSValue> CSSParser::parseBackgroundColor()
2882 {
2883     int id = m_valueList->current()->id;
2884     if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor ||
2885         (id >= CSSValueGrey && id < CSSValueWebkitText && !m_strict))
2886         return cssValuePool()->createIdentifierValue(id);
2887     return parseColor();
2888 }
2889
2890 bool CSSParser::parseFillImage(CSSParserValueList* valueList, RefPtr<CSSValue>& value)
2891 {
2892     if (valueList->current()->id == CSSValueNone) {
2893         value = CSSImageValue::create();
2894         return true;
2895     }
2896     if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
2897         // FIXME: The completeURL call should be done when using the CSSImageValue,
2898         // not when creating it.
2899         if (m_styleSheet)
2900             value = CSSImageValue::create(m_styleSheet->completeURL(valueList->current()->string));
2901         return true;
2902     }
2903
2904     if (isGeneratedImageValue(valueList->current()))
2905         return parseGeneratedImage(valueList, value);
2906
2907     return false;
2908 }
2909
2910 PassRefPtr<CSSValue> CSSParser::parseFillPositionX(CSSParserValueList* valueList)
2911 {
2912     int id = valueList->current()->id;
2913     if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
2914         int percent = 0;
2915         if (id == CSSValueRight)
2916             percent = 100;
2917         else if (id == CSSValueCenter)
2918             percent = 50;
2919         return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
2920     }
2921     if (validUnit(valueList->current(), FPercent | FLength, m_strict))
2922         return createPrimitiveNumericValue(valueList->current());
2923     return 0;
2924 }
2925
2926 PassRefPtr<CSSValue> CSSParser::parseFillPositionY(CSSParserValueList* valueList)
2927 {
2928     int id = valueList->current()->id;
2929     if (id == CSSValueTop || id == CSSValueBottom || id == CSSValueCenter) {
2930         int percent = 0;
2931         if (id == CSSValueBottom)
2932             percent = 100;
2933         else if (id == CSSValueCenter)
2934             percent = 50;
2935         return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
2936     }
2937     if (validUnit(valueList->current(), FPercent | FLength, m_strict))
2938         return createPrimitiveNumericValue(valueList->current());
2939     return 0;
2940 }
2941
2942 PassRefPtr<CSSValue> CSSParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag)
2943 {
2944     int id = valueList->current()->id;
2945     if (id == CSSValueLeft || id == CSSValueTop || id == CSSValueRight || id == CSSValueBottom || id == CSSValueCenter) {
2946         int percent = 0;
2947         if (id == CSSValueLeft || id == CSSValueRight) {
2948             if (cumulativeFlags & XFillPosition)
2949                 return 0;
2950             cumulativeFlags |= XFillPosition;
2951             individualFlag = XFillPosition;
2952             if (id == CSSValueRight)
2953                 percent = 100;
2954         }
2955         else if (id == CSSValueTop || id == CSSValueBottom) {
2956             if (cumulativeFlags & YFillPosition)
2957                 return 0;
2958             cumulativeFlags |= YFillPosition;
2959             individualFlag = YFillPosition;
2960             if (id == CSSValueBottom)
2961                 percent = 100;
2962         } else if (id == CSSValueCenter) {
2963             // Center is ambiguous, so we're not sure which position we've found yet, an x or a y.
2964             percent = 50;
2965             cumulativeFlags |= AmbiguousFillPosition;
2966             individualFlag = AmbiguousFillPosition;
2967         }
2968         return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
2969     }
2970     if (validUnit(valueList->current(), FPercent | FLength, m_strict)) {
2971         if (!cumulativeFlags) {
2972             cumulativeFlags |= XFillPosition;
2973             individualFlag = XFillPosition;
2974         } else if (cumulativeFlags & (XFillPosition | AmbiguousFillPosition)) {
2975             cumulativeFlags |= YFillPosition;
2976             individualFlag = YFillPosition;
2977         } else
2978             return 0;
2979         return createPrimitiveNumericValue(valueList->current());
2980     }
2981     return 0;
2982 }
2983
2984 void CSSParser::parseFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
2985 {
2986     CSSParserValue* value = valueList->current();
2987
2988     // Parse the first value.  We're just making sure that it is one of the valid keywords or a percentage/length.
2989     unsigned cumulativeFlags = 0;
2990     FillPositionFlag value1Flag = InvalidFillPosition;
2991     FillPositionFlag value2Flag = InvalidFillPosition;
2992     value1 = parseFillPositionComponent(valueList, cumulativeFlags, value1Flag);
2993     if (!value1)
2994         return;
2995
2996     // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
2997     // can assume that any other values belong to the rest of the shorthand).  If we're not parsing a shorthand, though, the
2998     // value was explicitly specified for our property.
2999     value = valueList->next();
3000
3001     // First check for the comma.  If so, we are finished parsing this value or value pair.
3002     if (value && value->unit == CSSParserValue::Operator && value->iValue == ',')
3003         value = 0;
3004
3005     if (value) {
3006         value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag);
3007         if (value2)
3008             valueList->next();
3009         else {
3010             if (!inShorthand()) {
3011                 value1.clear();
3012                 return;
3013             }
3014         }
3015     }
3016
3017     if (!value2)
3018         // Only one value was specified.  If that value was not a keyword, then it sets the x position, and the y position
3019         // is simply 50%.  This is our default.
3020         // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center).
3021         // For left/right/center, the default of 50% in the y is still correct.
3022         value2 = cssValuePool()->createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
3023
3024     if (value1Flag == YFillPosition || value2Flag == XFillPosition)
3025         value1.swap(value2);
3026 }
3027
3028 void CSSParser::parseFillRepeat(RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
3029 {
3030     CSSParserValue* value = m_valueList->current();
3031
3032     int id = m_valueList->current()->id;
3033     if (id == CSSValueRepeatX) {
3034         m_implicitShorthand = true;
3035         value1 = cssValuePool()->createIdentifierValue(CSSValueRepeat);
3036         value2 = cssValuePool()->createIdentifierValue(CSSValueNoRepeat);
3037         m_valueList->next();
3038         return;
3039     }
3040     if (id == CSSValueRepeatY) {
3041         m_implicitShorthand = true;
3042         value1 = cssValuePool()->createIdentifierValue(CSSValueNoRepeat);
3043         value2 = cssValuePool()->createIdentifierValue(CSSValueRepeat);
3044         m_valueList->next();
3045         return;
3046     }
3047     if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)
3048         value1 = cssValuePool()->createIdentifierValue(id);
3049     else {
3050         value1 = 0;
3051         return;
3052     }
3053
3054     value = m_valueList->next();
3055
3056     // First check for the comma.  If so, we are finished parsing this value or value pair.
3057     if (value && value->unit == CSSParserValue::Operator && value->iValue == ',')
3058         value = 0;
3059
3060     if (value)
3061         id = m_valueList->current()->id;
3062
3063     if (value && (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)) {
3064         value2 = cssValuePool()->createIdentifierValue(id);
3065         m_valueList->next();
3066     } else {
3067         // If only one value was specified, value2 is the same as value1.
3068         m_implicitShorthand = true;
3069         value2 = cssValuePool()->createIdentifierValue(static_cast<CSSPrimitiveValue*>(value1.get())->getIdent());
3070     }
3071 }
3072
3073 PassRefPtr<CSSValue> CSSParser::parseFillSize(int propId, bool& allowComma)
3074 {
3075     allowComma = true;
3076     CSSParserValue* value = m_valueList->current();
3077
3078     if (value->id == CSSValueContain || value->id == CSSValueCover)
3079         return cssValuePool()->createIdentifierValue(value->id);
3080
3081     RefPtr<CSSPrimitiveValue> parsedValue1;
3082
3083     if (value->id == CSSValueAuto)
3084         parsedValue1 = cssValuePool()->createIdentifierValue(CSSValueAuto);
3085     else {
3086         if (!validUnit(value, FLength | FPercent, m_strict))
3087             return 0;
3088         parsedValue1 = createPrimitiveNumericValue(value);
3089     }
3090
3091     CSSPropertyID property = static_cast<CSSPropertyID>(propId);
3092     RefPtr<CSSPrimitiveValue> parsedValue2;
3093     if ((value = m_valueList->next())) {
3094         if (value->unit == CSSParserValue::Operator && value->iValue == ',')
3095             allowComma = false;
3096         else if (value->id != CSSValueAuto) {
3097             if (!validUnit(value, FLength | FPercent, m_strict))
3098                 return 0;
3099             parsedValue2 = createPrimitiveNumericValue(value);
3100         }
3101     } else if (!parsedValue2 && property == CSSPropertyWebkitBackgroundSize) {
3102         // For backwards compatibility we set the second value to the first if it is omitted.
3103         // We only need to do this for -webkit-background-size. It should be safe to let masks match
3104         // the real property.
3105         parsedValue2 = parsedValue1;
3106     }
3107
3108     if (!parsedValue2)
3109         return parsedValue1;
3110     return cssValuePool()->createValue(Pair::create(parsedValue1.release(), parsedValue2.release()));
3111 }
3112
3113 bool CSSParser::parseFillProperty(int propId, int& propId1, int& propId2,
3114                                   RefPtr<CSSValue>& retValue1, RefPtr<CSSValue>& retValue2)
3115 {
3116     RefPtr<CSSValueList> values;
3117     RefPtr<CSSValueList> values2;
3118     CSSParserValue* val;
3119     RefPtr<CSSValue> value;
3120     RefPtr<CSSValue> value2;
3121
3122     bool allowComma = false;
3123
3124     retValue1 = retValue2 = 0;
3125     propId1 = propId;
3126     propId2 = propId;
3127     if (propId == CSSPropertyBackgroundPosition) {
3128         propId1 = CSSPropertyBackgroundPositionX;
3129         propId2 = CSSPropertyBackgroundPositionY;
3130     } else if (propId == CSSPropertyWebkitMaskPosition) {
3131         propId1 = CSSPropertyWebkitMaskPositionX;
3132         propId2 = CSSPropertyWebkitMaskPositionY;
3133     } else if (propId == CSSPropertyBackgroundRepeat) {
3134         propId1 = CSSPropertyBackgroundRepeatX;
3135         propId2 = CSSPropertyBackgroundRepeatY;
3136     } else if (propId == CSSPropertyWebkitMaskRepeat) {
3137         propId1 = CSSPropertyWebkitMaskRepeatX;
3138         propId2 = CSSPropertyWebkitMaskRepeatY;
3139     }
3140
3141     while ((val = m_valueList->current())) {
3142         RefPtr<CSSValue> currValue;
3143         RefPtr<CSSValue> currValue2;
3144
3145         if (allowComma) {
3146             if (val->unit != CSSParserValue::Operator || val->iValue != ',')
3147                 return false;
3148             m_valueList->next();
3149             allowComma = false;
3150         } else {
3151             allowComma = true;
3152             switch (propId) {
3153                 case CSSPropertyBackgroundColor:
3154                     currValue = parseBackgroundColor();
3155                     if (currValue)
3156                         m_valueList->next();
3157                     break;
3158                 case CSSPropertyBackgroundAttachment:
3159                 case CSSPropertyWebkitMaskAttachment:
3160                     if (val->id == CSSValueScroll || val->id == CSSValueFixed || val->id == CSSValueLocal) {
3161                         currValue = cssValuePool()->createIdentifierValue(val->id);
3162                         m_valueList->next();
3163                     }
3164                     break;
3165                 case CSSPropertyBackgroundImage:
3166                 case CSSPropertyWebkitMaskImage:
3167                     if (parseFillImage(m_valueList.get(), currValue))
3168                         m_valueList->next();
3169                     break;
3170                 case CSSPropertyWebkitBackgroundClip:
3171                 case CSSPropertyWebkitBackgroundOrigin:
3172                 case CSSPropertyWebkitMaskClip:
3173                 case CSSPropertyWebkitMaskOrigin:
3174                     // The first three values here are deprecated and do not apply to the version of the property that has
3175                     // the -webkit- prefix removed.
3176                     if (val->id == CSSValueBorder || val->id == CSSValuePadding || val->id == CSSValueContent ||
3177                         val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox ||
3178                         ((propId == CSSPropertyWebkitBackgroundClip || propId == CSSPropertyWebkitMaskClip) &&
3179                          (val->id == CSSValueText || val->id == CSSValueWebkitText))) {
3180                         currValue = cssValuePool()->createIdentifierValue(val->id);
3181                         m_valueList->next();
3182                     }
3183                     break;
3184                 case CSSPropertyBackgroundClip:
3185                     if (parseBackgroundClip(val, currValue, cssValuePool()))
3186                         m_valueList->next();
3187                     break;
3188                 case CSSPropertyBackgroundOrigin:
3189                     if (val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox) {
3190                         currValue = cssValuePool()->createIdentifierValue(val->id);
3191                         m_valueList->next();
3192                     }
3193                     break;
3194                 case CSSPropertyBackgroundPosition:
3195                 case CSSPropertyWebkitMaskPosition:
3196                     parseFillPosition(m_valueList.get(), currValue, currValue2);
3197                     // parseFillPosition advances the m_valueList pointer
3198                     break;
3199                 case CSSPropertyBackgroundPositionX:
3200                 case CSSPropertyWebkitMaskPositionX: {
3201                     currValue = parseFillPositionX(m_valueList.get());
3202                     if (currValue)
3203                         m_valueList->next();
3204                     break;
3205                 }
3206                 case CSSPropertyBackgroundPositionY:
3207                 case CSSPropertyWebkitMaskPositionY: {
3208                     currValue = parseFillPositionY(m_valueList.get());
3209                     if (currValue)
3210                         m_valueList->next();
3211                     break;
3212                 }
3213                 case CSSPropertyWebkitBackgroundComposite:
3214                 case CSSPropertyWebkitMaskComposite:
3215                     if ((val->id >= CSSValueClear && val->id <= CSSValuePlusLighter) || val->id == CSSValueHighlight) {
3216                         currValue = cssValuePool()->createIdentifierValue(val->id);
3217                         m_valueList->next();
3218                     }
3219                     break;
3220                 case CSSPropertyBackgroundRepeat:
3221                 case CSSPropertyWebkitMaskRepeat:
3222                     parseFillRepeat(currValue, currValue2);
3223                     // parseFillRepeat advances the m_valueList pointer
3224                     break;
3225                 case CSSPropertyBackgroundSize:
3226                 case CSSPropertyWebkitBackgroundSize:
3227                 case CSSPropertyWebkitMaskSize: {
3228                     currValue = parseFillSize(propId, allowComma);
3229                     if (currValue)
3230                         m_valueList->next();
3231                     break;
3232                 }
3233             }
3234             if (!currValue)
3235                 return false;
3236
3237             if (value && !values) {
3238                 values = CSSValueList::createCommaSeparated();
3239                 values->append(value.release());
3240             }
3241
3242             if (value2 && !values2) {
3243                 values2 = CSSValueList::createCommaSeparated();
3244                 values2->append(value2.release());
3245             }
3246
3247             if (values)
3248                 values->append(currValue.release());
3249             else
3250                 value = currValue.release();
3251             if (currValue2) {
3252                 if (values2)
3253                     values2->append(currValue2.release());
3254                 else
3255                     value2 = currValue2.release();
3256             }
3257         }
3258
3259         // When parsing any fill shorthand property, we let it handle building up the lists for all
3260         // properties.
3261         if (inShorthand())
3262             break;
3263     }
3264
3265     if (values && values->length()) {
3266         retValue1 = values.release();
3267         if (values2 && values2->length())
3268             retValue2 = values2.release();
3269         return true;
3270     }
3271     if (value) {
3272         retValue1 = value.release();
3273         retValue2 = value2.release();
3274         return true;
3275     }
3276     return false;
3277 }
3278
3279 PassRefPtr<CSSValue> CSSParser::parseAnimationDelay()
3280 {
3281     CSSParserValue* value = m_valueList->current();
3282     if (validUnit(value, FTime, m_strict))
3283         return createPrimitiveNumericValue(value);
3284     return 0;
3285 }
3286
3287 PassRefPtr<CSSValue> CSSParser::parseAnimationDirection()
3288 {
3289     CSSParserValue* value = m_valueList->current();
3290     if (value->id == CSSValueNormal || value->id == CSSValueAlternate)
3291         return cssValuePool()->createIdentifierValue(value->id);
3292     return 0;
3293 }
3294
3295 PassRefPtr<CSSValue> CSSParser::parseAnimationDuration()
3296 {
3297     CSSParserValue* value = m_valueList->current();
3298     if (validUnit(value, FTime | FNonNeg, m_strict))
3299         return createPrimitiveNumericValue(value);
3300     return 0;
3301 }
3302
3303 PassRefPtr<CSSValue> CSSParser::parseAnimationFillMode()
3304 {
3305     CSSParserValue* value = m_valueList->current();
3306     if (value->id == CSSValueNone || value->id == CSSValueForwards || value->id == CSSValueBackwards || value->id == CSSValueBoth)
3307         return cssValuePool()->createIdentifierValue(value->id);
3308     return 0;
3309 }
3310
3311 PassRefPtr<CSSValue> CSSParser::parseAnimationIterationCount()
3312 {
3313     CSSParserValue* value = m_valueList->current();
3314     if (value->id == CSSValueInfinite)
3315         return cssValuePool()->createIdentifierValue(value->id);
3316     if (validUnit(value, FInteger | FNonNeg, m_strict))
3317         return createPrimitiveNumericValue(value);
3318     return 0;
3319 }
3320
3321 PassRefPtr<CSSValue> CSSParser::parseAnimationName()
3322 {
3323     CSSParserValue* value = m_valueList->current();
3324     if (value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT) {
3325         if (value->id == CSSValueNone || (value->unit == CSSPrimitiveValue::CSS_STRING && equalIgnoringCase(value->string, "none"))) {
3326             return cssValuePool()->createIdentifierValue(CSSValueNone);
3327         } else {
3328             return createPrimitiveStringValue(value);
3329         }
3330     }
3331     return 0;
3332 }
3333
3334 PassRefPtr<CSSValue> CSSParser::parseAnimationPlayState()
3335 {
3336     CSSParserValue* value = m_valueList->current();
3337     if (value->id == CSSValueRunning || value->id == CSSValuePaused)
3338         return cssValuePool()->createIdentifierValue(value->id);
3339     return 0;
3340 }
3341
3342 PassRefPtr<CSSValue> CSSParser::parseAnimationProperty()
3343 {
3344     CSSParserValue* value = m_valueList->current();
3345     if (value->unit != CSSPrimitiveValue::CSS_IDENT)
3346         return 0;
3347     int result = cssPropertyID(value->string);
3348     if (result)
3349         return cssValuePool()->createIdentifierValue(result);
3350     if (equalIgnoringCase(value->string, "all"))
3351         return cssValuePool()->createIdentifierValue(CSSValueAll);
3352     if (equalIgnoringCase(value->string, "none"))
3353         return cssValuePool()->createIdentifierValue(CSSValueNone);
3354     return 0;
3355 }
3356
3357 bool CSSParser::parseTransformOriginShorthand(RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, RefPtr<CSSValue>& value3)
3358 {
3359     parseFillPosition(m_valueList.get(), value1, value2);
3360
3361     // now get z
3362     if (m_valueList->current()) {
3363         if (validUnit(m_valueList->current(), FLength, m_strict)) {
3364             value3 = createPrimitiveNumericValue(m_valueList->current());
3365             m_valueList->next();
3366             return true;
3367         }
3368         return false;
3369     }
3370     return true;
3371 }
3372
3373 bool CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result)
3374 {
3375     CSSParserValue* v = args->current();
3376     if (!validUnit(v, FNumber, m_strict))
3377         return false;
3378     result = v->fValue;
3379     v = args->next();
3380     if (!v)
3381         // The last number in the function has no comma after it, so we're done.
3382         return true;
3383     if (v->unit != CSSParserValue::Operator && v->iValue != ',')
3384         return false;
3385     v = args->next();
3386     return true;
3387 }
3388
3389 PassRefPtr<CSSValue> CSSParser::parseAnimationTimingFunction()
3390 {
3391     CSSParserValue* value = m_valueList->current();
3392     if (value->id == CSSValueEase || value->id == CSSValueLinear || value->id == CSSValueEaseIn || value->id == CSSValueEaseOut
3393         || value->id == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd)
3394         return cssValuePool()->createIdentifierValue(value->id);
3395
3396     // We must be a function.
3397     if (value->unit != CSSParserValue::Function)
3398         return 0;
3399
3400     CSSParserValueList* args = value->function->args.get();
3401
3402     if (equalIgnoringCase(value->function->name, "steps(")) {
3403         // For steps, 1 or 2 params must be specified (comma-separated)
3404         if (!args || (args->size() != 1 && args->size() != 3))
3405             return 0;
3406
3407         // There are two values.
3408         int numSteps;
3409         bool stepAtStart = false;
3410
3411         CSSParserValue* v = args->current();
3412         if (!validUnit(v, FInteger, m_strict))
3413             return 0;
3414         numSteps = clampToInteger(v->fValue);
3415         if (numSteps < 1)
3416             return 0;
3417         v = args->next();
3418
3419         if (v) {
3420             // There is a comma so we need to parse the second value
3421             if (v->unit != CSSParserValue::Operator && v->iValue != ',')
3422                 return 0;
3423             v = args->next();
3424             if (v->id != CSSValueStart && v->id != CSSValueEnd)
3425                 return 0;
3426             stepAtStart = v->id == CSSValueStart;
3427         }
3428
3429         return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart);
3430     }
3431
3432     if (equalIgnoringCase(value->function->name, "cubic-bezier(")) {
3433         // For cubic bezier, 4 values must be specified.
3434         if (!args || args->size() != 7)
3435             return 0;
3436
3437         // There are two points specified.  The values must be between 0 and 1.
3438         double x1, y1, x2, y2;
3439
3440         if (!parseCubicBezierTimingFunctionValue(args, x1))
3441             return 0;
3442         if (!parseCubicBezierTimingFunctionValue(args, y1))
3443             return 0;
3444         if (!parseCubicBezierTimingFunctionValue(args, x2))
3445             return 0;
3446         if (!parseCubicBezierTimingFunctionValue(args, y2))
3447             return 0;
3448
3449         return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
3450     }
3451
3452     return 0;
3453 }
3454
3455 bool CSSParser::parseAnimationProperty(int propId, RefPtr<CSSValue>& result)
3456 {
3457     RefPtr<CSSValueList> values;
3458     CSSParserValue* val;
3459     RefPtr<CSSValue> value;
3460     bool allowComma = false;
3461
3462     result = 0;
3463
3464     while ((val = m_valueList->current())) {
3465         RefPtr<CSSValue> currValue;
3466         if (allowComma) {
3467             if (val->unit != CSSParserValue::Operator || val->iValue != ',')
3468                 return false;
3469             m_valueList->next();
3470             allowComma = false;
3471         }
3472         else {
3473             switch (propId) {
3474                 case CSSPropertyWebkitAnimationDelay:
3475                 case CSSPropertyWebkitTransitionDelay:
3476                     currValue = parseAnimationDelay();
3477                     if (currValue)
3478                         m_valueList->next();
3479                     break;
3480                 case CSSPropertyWebkitAnimationDirection:
3481                     currValue = parseAnimationDirection();
3482                     if (currValue)
3483                         m_valueList->next();
3484                     break;
3485                 case CSSPropertyWebkitAnimationDuration:
3486                 case CSSPropertyWebkitTransitionDuration:
3487                     currValue = parseAnimationDuration();
3488                     if (currValue)
3489                         m_valueList->next();
3490                     break;
3491                 case CSSPropertyWebkitAnimationFillMode:
3492                     currValue = parseAnimationFillMode();
3493                     if (currValue)
3494                         m_valueList->next();
3495                     break;
3496                 case CSSPropertyWebkitAnimationIterationCount:
3497                     currValue = parseAnimationIterationCount();
3498                     if (currValue)
3499                         m_valueList->next();
3500                     break;
3501                 case CSSPropertyWebkitAnimationName:
3502                     currValue = parseAnimationName();
3503                     if (currValue)
3504                         m_valueList->next();
3505                     break;
3506                 case CSSPropertyWebkitAnimationPlayState:
3507                     currValue = parseAnimationPlayState();
3508                     if (currValue)
3509                         m_valueList->next();
3510                     break;
3511                 case CSSPropertyWebkitTransitionProperty:
3512                     currValue = parseAnimationProperty();
3513                     if (currValue)
3514                         m_valueList->next();
3515                     break;
3516                 case CSSPropertyWebkitAnimationTimingFunction:
3517                 case CSSPropertyWebkitTransitionTimingFunction:
3518                     currValue = parseAnimationTimingFunction();
3519                     if (currValue)
3520                         m_valueList->next();
3521                     break;
3522             }
3523
3524             if (!currValue)
3525                 return false;
3526
3527             if (value && !values) {
3528                 values = CSSValueList::createCommaSeparated();
3529                 values->append(value.release());
3530             }
3531
3532             if (values)
3533                 values->append(currValue.release());
3534             else
3535                 value = currValue.release();
3536
3537             allowComma = true;
3538         }
3539
3540         // When parsing the 'transition' shorthand property, we let it handle building up the lists for all
3541         // properties.
3542         if (inShorthand())
3543             break;
3544     }
3545
3546     if (values && values->length()) {
3547         result = values.release();
3548         return true;
3549     }
3550     if (value) {
3551         result = value.release();
3552         return true;
3553     }
3554     return false;
3555 }
3556
3557 #if ENABLE(CSS_GRID_LAYOUT)
3558 bool CSSParser::parseGridTrackList(int propId, bool important)
3559 {
3560     CSSParserValue* value = m_valueList->current();
3561     if (value->id == CSSValueNone) {
3562         if (m_valueList->next())
3563             return false;
3564
3565         addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important);
3566         return true;
3567     }
3568
3569     RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
3570     while (value) {
3571         bool valid = validUnit(value, FLength | FPercent, m_strict) || value->id == CSSValueAuto;
3572         if (!valid)
3573             return false;
3574
3575         RefPtr<CSSPrimitiveValue> primitiveValue = value->id == CSSValueAuto ? cssValuePool()->createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(value);
3576         values->append(primitiveValue.release());
3577         value = m_valueList->next();
3578     }
3579     addProperty(propId, values.release(), important);
3580     return true;
3581 }
3582 #endif
3583
3584
3585
3586 #if ENABLE(DASHBOARD_SUPPORT)
3587
3588 #define DASHBOARD_REGION_NUM_PARAMETERS  6
3589 #define DASHBOARD_REGION_SHORT_NUM_PARAMETERS  2
3590
3591 static CSSParserValue* skipCommaInDashboardRegion(CSSParserValueList *args)
3592 {
3593     if (args->size() == (DASHBOARD_REGION_NUM_PARAMETERS*2-1) ||
3594          args->size() == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
3595         CSSParserValue* current = args->current();
3596         if (current->unit == CSSParserValue::Operator && current->iValue == ',')
3597             return args->next();
3598     }
3599     return args->current();
3600 }
3601
3602 bool CSSParser::parseDashboardRegions(int propId, bool important)
3603 {
3604     bool valid = true;
3605
3606     CSSParserValue* value = m_valueList->current();
3607
3608     if (value->id == CSSValueNone) {
3609         if (m_valueList->next())
3610             return false;
3611         addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important);
3612         return valid;
3613     }
3614
3615     RefPtr<DashboardRegion> firstRegion = DashboardRegion::create();
3616     DashboardRegion* region = 0;
3617
3618     while (value) {
3619         if (region == 0) {
3620             region = firstRegion.get();
3621         } else {
3622             RefPtr<DashboardRegion> nextRegion = DashboardRegion::create();
3623             region->m_next = nextRegion;
3624             region = nextRegion.get();
3625         }
3626
3627         if (value->unit != CSSParserValue::Function) {
3628             valid = false;
3629             break;
3630         }
3631
3632         // Commas count as values, so allow:
3633         // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l)
3634         // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l)
3635         // also allow
3636         // dashboard-region(label, type) or dashboard-region(label type)
3637         // dashboard-region(label, type) or dashboard-region(label type)
3638         CSSParserValueList* args = value->function->args.get();
3639         if (!equalIgnoringCase(value->function->name, "dashboard-region(") || !args) {
3640             valid = false;
3641             break;
3642         }
3643
3644         int numArgs = args->size();
3645         if ((numArgs != DASHBOARD_REGION_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_NUM_PARAMETERS*2-1)) &&
3646             (numArgs != DASHBOARD_REGION_SHORT_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1))) {
3647             valid = false;
3648             break;
3649         }
3650
3651         // First arg is a label.
3652         CSSParserValue* arg = args->current();
3653         if (arg->unit != CSSPrimitiveValue::CSS_IDENT) {
3654             valid = false;
3655             break;
3656         }
3657
3658         region->m_label = arg->string;
3659
3660         // Second arg is a type.
3661         arg = args->next();
3662         arg = skipCommaInDashboardRegion(args);
3663         if (arg->unit != CSSPrimitiveValue::CSS_IDENT) {
3664             valid = false;
3665             break;
3666         }
3667
3668         if (equalIgnoringCase(arg->string, "circle"))
3669             region->m_isCircle = true;
3670         else if (equalIgnoringCase(arg->string, "rectangle"))
3671             region->m_isRectangle = true;
3672         else {
3673             valid = false;
3674             break;
3675         }
3676
3677         region->m_geometryType = arg->string;
3678
3679         if (numArgs == DASHBOARD_REGION_SHORT_NUM_PARAMETERS || numArgs == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) {
3680             // This originally used CSSValueInvalid by accident. It might be more logical to use something else.
3681             RefPtr<CSSPrimitiveValue> amount = cssValuePool()->createIdentifierValue(CSSValueInvalid);
3682
3683             region->setTop(amount);
3684             region->setRight(amount);
3685             region->setBottom(amount);
3686             region->setLeft(amount);
3687         } else {
3688             // Next four arguments must be offset numbers
3689             int i;
3690             for (i = 0; i < 4; i++) {
3691                 arg = args->next();
3692                 arg = skipCommaInDashboardRegion(args);
3693
3694                 valid = arg->id == CSSValueAuto || validUnit(arg, FLength, m_strict);
3695                 if (!valid)
3696                     break;
3697
3698                 RefPtr<CSSPrimitiveValue> amount = arg->id == CSSValueAuto ?
3699                     cssValuePool()->createIdentifierValue(CSSValueAuto) :
3700                     createPrimitiveNumericValue(arg);
3701
3702                 if (i == 0)
3703                     region->setTop(amount);
3704                 else if (i == 1)
3705                     region->setRight(amount);
3706                 else if (i == 2)
3707                     region->setBottom(amount);
3708                 else
3709                     region->setLeft(amount);
3710             }
3711         }
3712
3713         if (args->next())
3714             return false;
3715
3716         value = m_valueList->next();
3717     }
3718
3719     if (valid)
3720         addProperty(propId, cssValuePool()->createValue(firstRegion.release()), important);
3721
3722     return valid;
3723 }
3724
3725 #endif /* ENABLE(DASHBOARD_SUPPORT) */
3726
3727 PassRefPtr<CSSValue> CSSParser::parseCounterContent(CSSParserValueList* args, bool counters)
3728 {
3729     unsigned numArgs = args->size();
3730     if (counters && numArgs != 3 && numArgs != 5)
3731         return 0;
3732     if (!counters && numArgs != 1 && numArgs != 3)
3733         return 0;
3734
3735     CSSParserValue* i = args->current();
3736     if (i->unit != CSSPrimitiveValue::CSS_IDENT)
3737         return 0;
3738     RefPtr<CSSPrimitiveValue> identifier = createPrimitiveStringValue(i);
3739
3740     RefPtr<CSSPrimitiveValue> separator;
3741     if (!counters)
3742         separator = cssValuePool()->createValue(String(), CSSPrimitiveValue::CSS_STRING);
3743     else {
3744         i = args->next();
3745         if (i->unit != CSSParserValue::Operator || i->iValue != ',')
3746             return 0;
3747
3748         i = args->next();
3749         if (i->unit != CSSPrimitiveValue::CSS_STRING)
3750             return 0;
3751
3752         separator = createPrimitiveStringValue(i);
3753     }
3754
3755     RefPtr<CSSPrimitiveValue> listStyle;
3756     i = args->next();
3757     if (!i) // Make the list style default decimal
3758         listStyle = cssValuePool()->createIdentifierValue(CSSValueDecimal);
3759     else {
3760         if (i->unit != CSSParserValue::Operator || i->iValue != ',')
3761             return 0;
3762
3763         i = args->next();
3764         if (i->unit != CSSPrimitiveValue::CSS_IDENT)
3765             return 0;
3766
3767         int listStyleID = 0;
3768         if (i->id == CSSValueNone || (i->id >= CSSValueDisc && i->id <= CSSValueKatakanaIroha))
3769             listStyleID = i->id;
3770         else
3771             return 0;
3772
3773         listStyle = cssValuePool()->createIdentifierValue(listStyleID);
3774     }
3775
3776     return cssValuePool()->createValue(Counter::create(identifier.release(), listStyle.release(), separator.release()));
3777 }
3778
3779 bool CSSParser::parseShape(int propId, bool important)
3780 {
3781     CSSParserValue* value = m_valueList->current();
3782     CSSParserValueList* args = value->function->args.get();
3783
3784     if (!equalIgnoringCase(value->function->name, "rect(") || !args)
3785         return false;
3786
3787     // rect(t, r, b, l) || rect(t r b l)
3788     if (args->size() != 4 && args->size() != 7)
3789         return false;
3790     RefPtr<Rect> rect = Rect::create();
3791     bool valid = true;
3792     int i = 0;
3793     CSSParserValue* a = args->current();
3794     while (a) {
3795         valid = a->id == CSSValueAuto || validUnit(a, FLength, m_strict);
3796         if (!valid)
3797             break;
3798         RefPtr<CSSPrimitiveValue> length = a->id == CSSValueAuto ?
3799             cssValuePool()->createIdentifierValue(CSSValueAuto) :
3800             createPrimitiveNumericValue(a);
3801         if (i == 0)
3802             rect->setTop(length);
3803         else if (i == 1)
3804             rect->setRight(length);
3805         else if (i == 2)
3806             rect->setBottom(length);
3807         else
3808             rect->setLeft(length);
3809         a = args->next();
3810         if (a && args->size() == 7) {
3811             if (a->unit == CSSParserValue::Operator && a->iValue == ',') {
3812                 a = args->next();
3813             } else {
3814                 valid = false;
3815                 break;
3816             }
3817         }
3818         i++;
3819     }
3820     if (valid) {
3821         addProperty(propId, cssValuePool()->createValue(rect.release()), important);
3822         m_valueList->next();
3823         return true;
3824     }
3825     return false;
3826 }
3827
3828 PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeRect(CSSParserValueList* args)
3829 {
3830     ASSERT(args);
3831
3832     // rect(x, y, width, height, [[rx], ry])
3833     if (args->size() != 7 && args->size() != 9 && args->size() != 11)
3834         return 0;
3835
3836     RefPtr<CSSWrapShapeRect> shape = CSSWrapShapeRect::create();
3837
3838     unsigned argumentNumber = 0;
3839     CSSParserValue* argument = args->current();
3840     while (argument) {
3841         if (!validUnit(argument, FLength, m_strict))
3842             return 0;
3843
3844         RefPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(argument);
3845         ASSERT(argumentNumber < 6);
3846         switch (argumentNumber) {
3847         case 0:
3848             shape->setLeft(length);
3849             break;
3850         case 1:
3851             shape->setTop(length);
3852             break;
3853         case 2:
3854             shape->setWidth(length);
3855             break;
3856         case 3:
3857             shape->setHeight(length);
3858             break;
3859         case 4:
3860             shape->setRadiusX(length);
3861             break;
3862         case 5:
3863             shape->setRadiusY(length);
3864             break;
3865         }
3866         argument = args->next();
3867         if (argument) {
3868             if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
3869                 return 0;
3870
3871             argument = args->next();
3872         }
3873         argumentNumber++;
3874     }
3875
3876     if (argumentNumber < 4)
3877         return 0;
3878     return shape;
3879 }
3880
3881 PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeCircle(CSSParserValueList* args)
3882 {
3883     ASSERT(args);
3884
3885     // circle(x, y, r)
3886     if (args->size() != 5)
3887         return 0;
3888
3889     RefPtr<CSSWrapShapeCircle> shape = CSSWrapShapeCircle::create();
3890
3891     unsigned argumentNumber = 0;
3892     CSSParserValue* argument = args->current();
3893     while (argument) {
3894         if (!validUnit(argument, FLength, m_strict))
3895             return 0;
3896
3897         RefPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(argument);
3898         ASSERT(argumentNumber < 3);
3899         switch (argumentNumber) {
3900         case 0:
3901             shape->setLeft(length);
3902             break;
3903         case 1:
3904             shape->setTop(length);
3905 &nbs